Python: add stepwise planner

python/semantic_kernel/__init__.py

@@ -16,6 +16,7 @@
 from semantic_kernel.utils.null_logger import NullLogger
 from semantic_kernel.utils.settings import (
     azure_openai_settings_from_dot_env,
+    bing_search_settings_from_dot_env,
     google_palm_settings_from_dot_env,
     openai_settings_from_dot_env,
     pinecone_settings_from_dot_env,
@@ -29,6 +30,7 @@
     "azure_openai_settings_from_dot_env",
     "postgres_settings_from_dot_env",
     "pinecone_settings_from_dot_env",
+    "bing_search_settings_from_dot_env",
     "google_palm_settings_from_dot_env",
     "PromptTemplateConfig",
     "PromptTemplate",

python/semantic_kernel/connectors/ai/chat_request_settings.py

@@ -1,7 +1,7 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Dict, List
 
 if TYPE_CHECKING:
     from semantic_kernel.semantic_functions.prompt_template_config import (
@@ -18,16 +18,19 @@ class ChatRequestSettings:
     number_of_responses: int = 1
     max_tokens: int = 256
     token_selection_biases: Dict[int, int] = field(default_factory=dict)
+    stop_sequences: List[str] = field(default_factory=list)
 
     def update_from_completion_config(
         self, completion_config: "PromptTemplateConfig.CompletionConfig"
     ):
         self.temperature = completion_config.temperature
         self.top_p = completion_config.top_p
-        self.presence_penalty = completion_config.presence_penalty
-        self.frequency_penalty = completion_config.frequency_penalty
         self.number_of_responses = completion_config.number_of_responses
+        self.stop_sequences = completion_config.stop_sequences
         self.max_tokens = completion_config.max_tokens
+        self.presence_penalty = completion_config.presence_penalty
+        self.frequency_penalty = completion_config.frequency_penalty
+        self.token_selection_biases = completion_config.token_selection_biases
 
     @staticmethod
     def from_completion_config(

python/semantic_kernel/connectors/ai/open_ai/services/open_ai_chat_completion.py

@@ -101,15 +101,8 @@ async def complete_async(
             str -- The completed text.
         """
         prompt_to_message = [("user", prompt)]
-        chat_settings = ChatRequestSettings(
-            temperature=request_settings.temperature,
-            top_p=request_settings.top_p,
-            presence_penalty=request_settings.presence_penalty,
-            frequency_penalty=request_settings.frequency_penalty,
-            max_tokens=request_settings.max_tokens,
-            number_of_responses=request_settings.number_of_responses,
-            token_selection_biases=request_settings.token_selection_biases,
-        )
+        chat_settings = ChatRequestSettings.from_completion_config(request_settings)
+
         response = await self._send_chat_request(
             prompt_to_message, chat_settings, False
         )
@@ -131,6 +124,7 @@ async def complete_stream_async(
             max_tokens=request_settings.max_tokens,
             number_of_responses=request_settings.number_of_responses,
             token_selection_biases=request_settings.token_selection_biases,
+            stop_sequences=request_settings.stop_sequences,
         )
         response = await self._send_chat_request(prompt_to_message, chat_settings, True)
 
@@ -205,11 +199,17 @@ async def _send_chat_request(
                 messages=formatted_messages,
                 temperature=request_settings.temperature,
                 top_p=request_settings.top_p,
-                presence_penalty=request_settings.presence_penalty,
-                frequency_penalty=request_settings.frequency_penalty,
-                max_tokens=request_settings.max_tokens,
                 n=request_settings.number_of_responses,
                 stream=stream,
+                stop=(
+                    request_settings.stop_sequences
+                    if request_settings.stop_sequences is not None
+                    and len(request_settings.stop_sequences) > 0
+                    else None
+                ),
+                max_tokens=request_settings.max_tokens,
+                presence_penalty=request_settings.presence_penalty,
+                frequency_penalty=request_settings.frequency_penalty,
                 logit_bias=(
                     request_settings.token_selection_biases
                     if request_settings.token_selection_biases is not None

python/semantic_kernel/planning/__init__.py

@@ -4,10 +4,12 @@
 from semantic_kernel.planning.basic_planner import BasicPlanner
 from semantic_kernel.planning.plan import Plan
 from semantic_kernel.planning.sequential_planner import SequentialPlanner
+from semantic_kernel.planning.stepwise_planner import StepwisePlanner
 
 __all__ = [
-    "SequentialPlanner",
     "BasicPlanner",
     "Plan",
+    "SequentialPlanner",
+    "StepwisePlanner",
     "ActionPlanner",
 ]

python/semantic_kernel/planning/stepwise_planner/Skills/StepwiseStep/config.json

@@ -0,0 +1,32 @@
+{
+    "schema": 1,
+    "description": "Given a request or command or goal generate multi-step plan to reach the goal. After each step LLM is called to perform the reasoning for the next step.",
+    "type": "completion",
+    "completion": {
+      "max_tokens": 1024,
+      "temperature": 0,
+      "top_p": 0,
+      "presence_penalty": 0,
+      "frequency_penalty": 0,
+      "stop_sequences": ["[OBSERVATION]", "\n[THOUGHT]"]
+    },
+    "input": {
+      "parameters": [
+        {
+          "name": "question",
+          "description": "The question to answer",
+          "defaultValue": ""
+        },
+        {
+          "name": "agentScratchPad",
+          "description": "The agent's scratch pad",
+          "defaultValue": ""
+        },
+        {
+          "name": "functionDescriptions",
+          "description": "The manual of the agent's functions",
+          "defaultValue": ""
+        }
+      ]
+    }
+  }

python/semantic_kernel/planning/stepwise_planner/Skills/StepwiseStep/skprompt.txt

@@ -0,0 +1,53 @@
+[INSTRUCTION]
+Answer the following questions as accurately as possible using the provided functions.
+
+[AVAILABLE FUNCTIONS]
+The function definitions below are in the following format:
+<functionName>: <description>
+  inputs:
+    - <parameterName>: <parameterDescription>
+    - ...
+
+{{$function_descriptions}}
+[END AVAILABLE FUNCTIONS]
+
+[USAGE INSTRUCTIONS]
+To use the functions, specify a JSON blob representing an action. The JSON blob should contain an "action" key with the name of the function to use, and an "action_variables" key with a JSON object of string values to use when calling the function.
+Do not call functions directly; they must be invoked through an action.
+The "action_variables" value should always include an "input" key, even if the input value is empty. Additional keys in the "action_variables" value should match the defined [PARAMETERS] of the named "action" in [AVAILABLE FUNCTIONS].
+Dictionary values in "action_variables" must be strings and represent the actual values to be passed to the function.
+Ensure that the $JSON_BLOB contains only a SINGLE action; do NOT return multiple actions.
+IMPORTANT: Use only the available functions listed in the [AVAILABLE FUNCTIONS] section. Do not attempt to use any other functions that are not specified.
+
+Here is an example of a valid $JSON_BLOB:
+{
+  "action": "functionName",
+  "action_variables": {"parameterName": "some value", ...}
+}
+[END USAGE INSTRUCTIONS]
+[END INSTRUCTION]
+
+[THOUGHT PROCESS]
+[QUESTION]
+the input question I must answer
+[THOUGHT]
+To solve this problem, I should carefully analyze the given question and identify the necessary steps. Any facts I discover earlier in my thought process should be repeated here to keep them readily available.
+[ACTION]
+{
+  "action": "functionName",
+  "action_variables": {"parameterName": "some value", ...}
+}
+[OBSERVATION]
+The result of the action will be provided here.
+... (These Thought/Action/Observation can repeat until the final answer is reached.)
+[FINAL ANSWER]
+Once I have gathered all the necessary observations and performed any required actions, I can provide the final answer in a clear and human-readable format.
+[END THOUGHT PROCESS]
+
+Let's break down the problem step by step and think about the best approach. Questions and observations should be followed by a single thought and an optional single action to take.
+
+Begin!
+
+[QUESTION]
+{{$question}}
+{{$agent_scratch_pad}}

python/semantic_kernel/planning/stepwise_planner/__init__.py

@@ -0,0 +1,5 @@
+from semantic_kernel.planning.stepwise_planner.stepwise_planner import StepwisePlanner
+
+__all__ = [
+    "StepwisePlanner",
+]