semantic-kernel 0.3.1.dev0__tar.gz → 0.3.2.dev0__tar.gz

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantic-kernel
-Version: 0.3.1.dev0
+Version: 0.3.2.dev0
 Summary: 
 Author: Microsoft
 Author-email: SK-Support@microsoft.com
@@ -14,6 +14,7 @@ Requires-Dist: aiofiles (>=23.1.0,<24.0.0)
 Requires-Dist: numpy (>=1.24.2,<2.0.0)
 Requires-Dist: openai (>=0.27.0,<0.28.0)
 Requires-Dist: python-dotenv (==1.0.0)
+Requires-Dist: regex (>=2023.6.3,<2024.0.0)
 Description-Content-Type: text/markdown
 
 # About Semantic Kernel

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "semantic-kernel"
-version = "0.3.1.dev"
+version = "0.3.2.dev"
 description = ""
 authors = ["Microsoft <SK-Support@microsoft.com>"]
 readme = "pip/README.md"
@@ -12,16 +12,16 @@ numpy = "^1.24.2"
 openai = "^0.27.0"
 aiofiles = "^23.1.0"
 python-dotenv = "1.0.0"
+regex = "^2023.6.3"
 
 [tool.poetry.group.dev.dependencies]
-pre-commit = "2.21.0"
+pre-commit = "3.3.3"
 black = {version = "23.3.0", allow-prereleases = true}
 ipykernel = "^6.21.1"
-pytest = "7.2.0"
-ruff = "0.0.257"
+pytest = "7.4.0"
+ruff = "0.0.277"
 pytest-asyncio = "0.21.0"
 
-
 [tool.poetry.group.hugging_face.dependencies]
 transformers = "^4.28.1"
 sentence-transformers = "^2.2.2"
@@ -34,10 +34,14 @@ chromadb = "^0.3.23"
 [tool.poetry.group.weaviate.dependencies]
 weaviate-client = "^3.18.0"
 
+[tool.poetry.group.pinecone.dependencies]
+pinecone-client = "^2.2.2"
+
 [tool.isort]
 profile = "black"
 
 [tool.ruff]
+select = ["E", "F", "I"]
 line-length = 120
 
 [build-system]

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/__init__.py

@@ -17,6 +17,7 @@ from semantic_kernel.utils.null_logger import NullLogger
 from semantic_kernel.utils.settings import (
     azure_openai_settings_from_dot_env,
     openai_settings_from_dot_env,
+    pinecone_settings_from_dot_env,
 )
 
 __all__ = [
@@ -24,6 +25,7 @@ __all__ = [
     "NullLogger",
     "openai_settings_from_dot_env",
     "azure_openai_settings_from_dot_env",
+    "pinecone_settings_from_dot_env",
     "PromptTemplateConfig",
     "PromptTemplate",
     "ChatPromptTemplate",

semantic_kernel-0.3.2.dev0/semantic_kernel/connectors/memory/pinecone/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.connectors.memory.pinecone.pinecone_memory_store import (
+    PineconeMemoryStore,
+)
+
+__all__ = ["PineconeMemoryStore"]

semantic_kernel-0.3.2.dev0/semantic_kernel/connectors/memory/pinecone/pinecone_memory_store.py

@@ -0,0 +1,401 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from logging import Logger
+from typing import List, Optional, Tuple
+
+from numpy import ndarray
+
+import pinecone
+from pinecone import FetchResponse, IndexDescription
+from semantic_kernel.connectors.memory.pinecone.utils import (
+    build_payload,
+    parse_payload,
+)
+from semantic_kernel.memory.memory_record import MemoryRecord
+from semantic_kernel.memory.memory_store_base import MemoryStoreBase
+from semantic_kernel.utils.null_logger import NullLogger
+
+# Limitations set by Pinecone at https://docs.pinecone.io/docs/limits
+MAX_DIMENSIONALITY = 20000
+MAX_UPSERT_BATCH_SIZE = 100
+MAX_QUERY_WITHOUT_METADATA_BATCH_SIZE = 10000
+MAX_QUERY_WITH_METADATA_BATCH_SIZE = 1000
+MAX_FETCH_BATCH_SIZE = 1000
+MAX_DELETE_BATCH_SIZE = 1000
+
+
+class PineconeMemoryStore(MemoryStoreBase):
+    _logger: Logger
+    _pinecone_api_key: str
+    _pinecone_environment: str
+    _default_dimensionality: int
+
+    def __init__(
+        self,
+        api_key: str,
+        environment: str,
+        default_dimensionality: int,
+        logger: Optional[Logger] = None,
+    ) -> None:
+        """Initializes a new instance of the PineconeMemoryStore class.
+
+        Arguments:
+            pinecone_api_key {str} -- The Pinecone API key.
+            pinecone_environment {str} -- The Pinecone environment.
+            logger {Optional[Logger]} -- The logger to use. (default: {None})
+            default_dimensionality {int} -- The default dimensionality to use for new collections.
+        """
+        if default_dimensionality > MAX_DIMENSIONALITY:
+            raise ValueError(
+                f"Dimensionality of {default_dimensionality} exceeds "
+                + f"the maximum allowed value of {MAX_DIMENSIONALITY}."
+            )
+        self._pinecone_api_key = api_key
+        self._pinecone_environment = environment
+        self._default_dimensionality = default_dimensionality
+        self._logger = logger or NullLogger()
+
+        pinecone.init(
+            api_key=self._pinecone_api_key, environment=self._pinecone_environment
+        )
+
+    def get_collections(self) -> List[str]:
+        return pinecone.list_indexes()
+
+    async def create_collection_async(
+        self,
+        collection_name: str,
+        dimension_num: Optional[int] = None,
+        distance_type: Optional[str] = "cosine",
+        num_of_pods: Optional[int] = 1,
+        replica_num: Optional[int] = 0,
+        type_of_pod: Optional[str] = "p1.x1",
+        metadata_config: Optional[dict] = None,
+    ) -> None:
+        """Creates a new collection in Pinecone if it does not exist.
+            This function creates an index, by default the following index
+            settings are used: metric = cosine, pods = 1, replicas = 0,
+            pod_type = p1.x1, metadata_config = None.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to create.
+            In Pinecone, a collection is represented as an index. The concept
+            of "collection" in Pinecone is just a static copy of an index.
+
+        Returns:
+            None
+        """
+        if dimension_num is None:
+            dimension_num = self._default_dimensionality
+        if dimension_num > MAX_DIMENSIONALITY:
+            raise ValueError(
+                f"Dimensionality of {dimension_num} exceeds "
+                + f"the maximum allowed value of {MAX_DIMENSIONALITY}."
+            )
+
+        if collection_name not in pinecone.list_indexes():
+            pinecone.create_index(
+                name=collection_name,
+                dimension=dimension_num,
+                metric=distance_type,
+                pods=num_of_pods,
+                replicas=replica_num,
+                pod_type=type_of_pod,
+                metadata_config=metadata_config,
+            )
+
+    async def describe_collection_async(
+        self, collection_name: str
+    ) -> Optional[IndexDescription]:
+        """Gets the description of the index.
+        Arguments:
+            collection_name {str} -- The name of the index to get.
+        Returns:
+            Optional[dict] -- The index.
+        """
+        if collection_name in pinecone.list_indexes():
+            return pinecone.describe_index(collection_name)
+        return None
+
+    async def get_collections_async(
+        self,
+    ) -> List[str]:
+        """Gets the list of collections.
+
+        Returns:
+            List[str] -- The list of collections.
+        """
+        return list(pinecone.list_indexes())
+
+    async def delete_collection_async(self, collection_name: str) -> None:
+        """Deletes a collection.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to delete.
+
+        Returns:
+            None
+        """
+        if collection_name in pinecone.list_indexes():
+            pinecone.delete_index(collection_name)
+
+    async def does_collection_exist_async(self, collection_name: str) -> bool:
+        """Checks if a collection exists.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to check.
+
+        Returns:
+            bool -- True if the collection exists; otherwise, False.
+        """
+        return collection_name in pinecone.list_indexes()
+
+    async def upsert_async(self, collection_name: str, record: MemoryRecord) -> str:
+        """Upserts a record.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to upsert the record into.
+            record {MemoryRecord} -- The record to upsert.
+
+        Returns:
+            str -- The unique database key of the record. In Pinecone, this is the record ID.
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        collection = pinecone.Index(collection_name)
+
+        upsert_response = collection.upsert(
+            vectors=[(record._id, record.embedding.tolist(), build_payload(record))],
+            namespace="",
+        )
+
+        if upsert_response.upserted_count is None:
+            raise Exception(f"Error upserting record: {upsert_response.message}")
+
+        return record._id
+
+    async def upsert_batch_async(
+        self, collection_name: str, records: List[MemoryRecord]
+    ) -> List[str]:
+        """Upserts a batch of records.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to upsert the records into.
+            records {List[MemoryRecord]} -- The records to upsert.
+
+        Returns:
+            List[str] -- The unique database keys of the records.
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        collection = pinecone.Index(collection_name)
+
+        vectors = [
+            (
+                record._id,
+                record.embedding.tolist(),
+                build_payload(record),
+            )
+            for record in records
+        ]
+
+        upsert_response = collection.upsert(
+            vectors, namespace="", batch_size=MAX_UPSERT_BATCH_SIZE
+        )
+
+        if upsert_response.upserted_count is None:
+            raise Exception(f"Error upserting record: {upsert_response.message}")
+        else:
+            return [record._id for record in records]
+
+    async def get_async(
+        self, collection_name: str, key: str, with_embedding: bool = False
+    ) -> MemoryRecord:
+        """Gets a record.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to get the record from.
+            key {str} -- The unique database key of the record.
+            with_embedding {bool} -- Whether to include the embedding in the result. (default: {False})
+
+        Returns:
+            MemoryRecord -- The record.
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        collection = pinecone.Index(collection_name)
+        fetch_response = collection.fetch([key])
+
+        if len(fetch_response.vectors) == 0:
+            raise KeyError(f"Record with key '{key}' does not exist")
+
+        return parse_payload(fetch_response.vectors[key], with_embedding)
+
+    async def get_batch_async(
+        self, collection_name: str, keys: List[str], with_embeddings: bool = False
+    ) -> List[MemoryRecord]:
+        """Gets a batch of records.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to get the records from.
+            keys {List[str]} -- The unique database keys of the records.
+            with_embeddings {bool} -- Whether to include the embeddings in the results. (default: {False})
+
+        Returns:
+            List[MemoryRecord] -- The records.
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        fetch_response = await self.__get_batch_async(
+            collection_name, keys, with_embeddings
+        )
+        return [
+            parse_payload(fetch_response.vectors[key], with_embeddings)
+            for key in fetch_response.vectors.keys()
+        ]
+
+    async def remove_async(self, collection_name: str, key: str) -> None:
+        """Removes a record.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to remove the record from.
+            key {str} -- The unique database key of the record to remove.
+
+        Returns:
+            None
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        collection = pinecone.Index(collection_name)
+        collection.delete([key])
+
+    async def remove_batch_async(self, collection_name: str, keys: List[str]) -> None:
+        """Removes a batch of records.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to remove the records from.
+            keys {List[str]} -- The unique database keys of the records to remove.
+
+        Returns:
+            None
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        collection = pinecone.Index(collection_name)
+        for i in range(0, len(keys), MAX_DELETE_BATCH_SIZE):
+            collection.delete(keys[i : i + MAX_DELETE_BATCH_SIZE])
+        collection.delete(keys)
+
+    async def get_nearest_match_async(
+        self,
+        collection_name: str,
+        embedding: ndarray,
+        min_relevance_score: float = 0.0,
+        with_embedding: bool = False,
+    ) -> Tuple[MemoryRecord, float]:
+        """Gets the nearest match to an embedding using cosine similarity.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to get the nearest match from.
+            embedding {ndarray} -- The embedding to find the nearest match to.
+            min_relevance_score {float} -- The minimum relevance score of the match. (default: {0.0})
+            with_embedding {bool} -- Whether to include the embedding in the result. (default: {False})
+
+        Returns:
+            Tuple[MemoryRecord, float] -- The record and the relevance score.
+        """
+        matches = await self.get_nearest_matches_async(
+            collection_name=collection_name,
+            embedding=embedding,
+            limit=1,
+            min_relevance_score=min_relevance_score,
+            with_embeddings=with_embedding,
+        )
+        return matches[0]
+
+    async def get_nearest_matches_async(
+        self,
+        collection_name: str,
+        embedding: ndarray,
+        limit: int,
+        min_relevance_score: float = 0.0,
+        with_embeddings: bool = False,
+    ) -> List[Tuple[MemoryRecord, float]]:
+        """Gets the nearest matches to an embedding using cosine similarity.
+
+        Arguments:
+            collection_name {str} -- The name of the collection to get the nearest matches from.
+            embedding {ndarray} -- The embedding to find the nearest matches to.
+            limit {int} -- The maximum number of matches to return.
+            min_relevance_score {float} -- The minimum relevance score of the matches. (default: {0.0})
+            with_embeddings {bool} -- Whether to include the embeddings in the results. (default: {False})
+
+        Returns:
+            List[Tuple[MemoryRecord, float]] -- The records and their relevance scores.
+        """
+        if collection_name not in pinecone.list_indexes():
+            raise Exception(f"Collection '{collection_name}' does not exist")
+
+        collection = pinecone.Index(collection_name)
+
+        if limit > MAX_QUERY_WITHOUT_METADATA_BATCH_SIZE:
+            raise Exception(
+                "Limit must be less than or equal to "
+                + f"{MAX_QUERY_WITHOUT_METADATA_BATCH_SIZE}"
+            )
+        elif limit > MAX_QUERY_WITH_METADATA_BATCH_SIZE:
+            query_response = collection.query(
+                vector=embedding.tolist(),
+                top_k=limit,
+                include_values=False,
+                include_metadata=False,
+            )
+            keys = [match.id for match in query_response.matches]
+            fetch_response = await self.__get_batch_async(
+                collection_name, keys, with_embeddings
+            )
+            vectors = fetch_response.vectors
+            for match in query_response.matches:
+                vectors[match.id].update(match)
+            matches = [vectors[key] for key in vectors.keys()]
+        else:
+            query_response = collection.query(
+                vector=embedding.tolist(),
+                top_k=limit,
+                include_values=with_embeddings,
+                include_metadata=True,
+            )
+            matches = query_response.matches
+        if min_relevance_score is not None:
+            matches = [match for match in matches if match.score >= min_relevance_score]
+        return (
+            [
+                (
+                    parse_payload(match, with_embeddings),
+                    match["score"],
+                )
+                for match in matches
+            ]
+            if len(matches) > 0
+            else []
+        )
+
+    async def __get_batch_async(
+        self, collection_name: str, keys: List[str], with_embeddings: bool = False
+    ) -> "FetchResponse":
+        index = pinecone.Index(collection_name)
+        if len(keys) > MAX_FETCH_BATCH_SIZE:
+            fetch_response = index.fetch(keys[0:MAX_FETCH_BATCH_SIZE])
+            for i in range(MAX_FETCH_BATCH_SIZE, len(keys), MAX_FETCH_BATCH_SIZE):
+                fetch_response.vectors.update(
+                    index.fetch(keys[i : i + MAX_FETCH_BATCH_SIZE]).vectors
+                )
+        else:
+            fetch_response = index.fetch(keys)
+        return fetch_response

semantic_kernel-0.3.2.dev0/semantic_kernel/connectors/memory/pinecone/utils.py

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+import numpy
+
+from pinecone import Vector
+from semantic_kernel.memory.memory_record import MemoryRecord
+
+
+def build_payload(record: MemoryRecord) -> dict:
+    """
+    Builds a metadata payload to be sent to Pinecone from a MemoryRecord.
+    """
+    payload: dict = {}
+    if record._text:
+        payload["text"] = record._text
+    if record._description:
+        payload["description"] = record._description
+    if record._additional_metadata:
+        payload["additional_metadata"] = record._additional_metadata
+    return payload
+
+
+def parse_payload(record: Vector, with_embeddings: bool) -> MemoryRecord:
+    """
+    Parses a record from Pinecone into a MemoryRecord.
+    """
+    payload = record.metadata
+    description = payload.get("description", None)
+    text = payload.get("text", None)
+    additional_metadata = payload.get("additional_metadata", None)
+    return MemoryRecord.local_record(
+        id=record.id,
+        description=description,
+        text=text,
+        additional_metadata=additional_metadata,
+        embedding=record.values if with_embeddings else numpy.array([]),
+    )

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/core_skills/file_io_skill.py

@@ -11,7 +11,7 @@ class FileIOSkill:
     Description: Read and write from a file.
 
     Usage:
-        kernel.import_skill("file", FileIOSkill());
+        kernel.import_skill(FileIOSkill(), skill_name="file")
 
     Examples:
 

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/core_skills/math_skill.py

@@ -9,7 +9,7 @@ class MathSkill:
     Description: MathSkill provides a set of functions to make Math calculations.
 
     Usage:
-        kernel.import_skill("math", new MathSkill())
+        kernel.import_skill(MathSkill(), skill_name="math")
 
     Examples:
         {{math.Add}}         => Returns the sum of initial_value_text and Amount (provided in the SKContext)

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/core_skills/text_skill.py

@@ -6,7 +6,7 @@ class TextSkill:
     TextSkill provides a set of functions to manipulate strings.
 
     Usage:
-        kernel.import_skill("text", TextSkill());
+        kernel.import_skill(TextSkill(), skill_name="text")
 
     Examples:
         SKContext["input"] = "  hello world  "

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/core_skills/time_skill.py

@@ -9,11 +9,12 @@ class TimeSkill:
                  to get the current time and date.
 
     Usage:
-        kernel.import_skill("time", TimeSkill())
+        kernel.import_skill(TimeSkill(), skill_name="time")
 
     Examples:
         {{time.date}}            => Sunday, 12 January, 2031
         {{time.today}}           => Sunday, 12 January, 2031
+        {{time.iso_date}}        => 2031-01-12
         {{time.now}}             => Sunday, January 12, 2031 9:15 PM
         {{time.utcNow}}          => Sunday, January 13, 2031 5:15 AM
         {{time.time}}            => 09:15:07 PM
@@ -55,6 +56,17 @@ class TimeSkill:
         """
         return self.date()
 
+    @sk_function(description="Get the current date in iso format.")
+    def iso_date(self) -> str:
+        """
+        Get the current date in iso format
+
+        Example:
+            {{time.iso_date}} => 2031-01-12
+        """
+        today = datetime.date.today()
+        return today.isoformat()
+
     @sk_function(description="Get the current date and time in the local time zone")
     def now(self) -> str:
         """

semantic_kernel-0.3.2.dev0/semantic_kernel/core_skills/wait_skill.py

@@ -0,0 +1,23 @@
+import asyncio
+
+from semantic_kernel.skill_definition import sk_function
+
+
+class WaitSkill:
+    """
+    WaitSkill provides a set of functions to wait for a certain amount of time.
+
+    Usage:
+        kernel.import_skill(WaitSkill(), skill_name="wait")
+
+    Examples:
+        {{wait.seconds 5}} => Wait for 5 seconds
+    """
+
+    @sk_function(description="Wait for a certain number of seconds.")
+    async def wait(self, seconds_text: str):
+        try:
+            seconds = max(float(seconds_text), 0)
+        except ValueError:
+            raise ValueError("seconds text must be a number")
+        await asyncio.sleep(seconds)

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/memory/semantic_text_memory.py

@@ -56,7 +56,9 @@ class SemanticTextMemory(SemanticTextMemoryBase):
         ):
             await self._storage.create_collection_async(collection_name=collection)
 
-        embedding = await self._embeddings_generator.generate_embeddings_async([text])
+        embedding = (
+            await self._embeddings_generator.generate_embeddings_async([text])
+        )[0]
         data = MemoryRecord.local_record(
             id=id,
             text=text,
@@ -94,7 +96,9 @@ class SemanticTextMemory(SemanticTextMemoryBase):
         ):
             await self._storage.create_collection_async(collection_name=collection)
 
-        embedding = await self._embeddings_generator.generate_embeddings_async([text])
+        embedding = (
+            await self._embeddings_generator.generate_embeddings_async([text])
+        )[0]
         data = MemoryRecord.reference_record(
             external_id=external_id,
             source_name=external_source_name,
@@ -142,9 +146,9 @@ class SemanticTextMemory(SemanticTextMemoryBase):
         Returns:
             List[MemoryQueryResult] -- The list of MemoryQueryResult found.
         """
-        query_embedding = await self._embeddings_generator.generate_embeddings_async(
-            [query]
-        )
+        query_embedding = (
+            await self._embeddings_generator.generate_embeddings_async([query])
+        )[0]
         results = await self._storage.get_nearest_matches_async(
             collection_name=collection,
             embedding=query_embedding,

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/orchestration/sk_function.py

@@ -1,6 +1,8 @@
 # Copyright (c) Microsoft. All rights reserved.
 
 import asyncio
+import platform
+import sys
 import threading
 from enum import Enum
 from logging import Logger
@@ -36,6 +38,9 @@ from semantic_kernel.skill_definition.read_only_skill_collection_base import (
 )
 from semantic_kernel.utils.null_logger import NullLogger
 
+if platform.system() == "Windows" and sys.version_info >= (3, 8, 0):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
 
 class SKFunction(SKFunctionBase):
     """

{semantic_kernel-0.3.1.dev0 → semantic_kernel-0.3.2.dev0}/semantic_kernel/planning/basic_planner.py

@@ -3,6 +3,8 @@
 """A basic JSON-based planner for the Python Semantic Kernel"""
 import json
 
+import regex
+
 from semantic_kernel.kernel import Kernel
 from semantic_kernel.orchestration.context_variables import ContextVariables
 from semantic_kernel.planning.plan import Plan
@@ -187,7 +189,13 @@ class BasicPlanner:
         Given a plan, execute each of the functions within the plan
         from start to finish and output the result.
         """
-        generated_plan = json.loads(plan.generated_plan.result)
+
+        # Filter out good JSON from the result in case additional text is present
+        json_regex = r"\{(?:[^{}]|(?R))*\}"
+        generated_plan_string = regex.search(
+            json_regex, plan.generated_plan.result
+        ).group()
+        generated_plan = json.loads(generated_plan_string)
 
         context = ContextVariables()
         context["input"] = generated_plan["input"]