semantic-kernel 0.2.4.dev0__py3-none-any.whl → 0.2.5.dev0__py3-none-any.whl

semantic_kernel/orchestration/sk_function.py

@@ -6,10 +6,16 @@ from enum import Enum
 from logging import Logger
 from typing import Any, Callable, List, Optional, cast
 
-from semantic_kernel.ai.chat_completion_client_base import ChatCompletionClientBase
-from semantic_kernel.ai.chat_request_settings import ChatRequestSettings
-from semantic_kernel.ai.complete_request_settings import CompleteRequestSettings
-from semantic_kernel.ai.text_completion_client_base import TextCompletionClientBase
+from semantic_kernel.connectors.ai.chat_completion_client_base import (
+    ChatCompletionClientBase,
+)
+from semantic_kernel.connectors.ai.chat_request_settings import ChatRequestSettings
+from semantic_kernel.connectors.ai.complete_request_settings import (
+    CompleteRequestSettings,
+)
+from semantic_kernel.connectors.ai.text_completion_client_base import (
+    TextCompletionClientBase,
+)
 from semantic_kernel.kernel_exception import KernelException
 from semantic_kernel.memory.null_memory import NullMemory
 from semantic_kernel.memory.semantic_text_memory_base import SemanticTextMemoryBase
@@ -41,9 +47,9 @@ class SKFunction(SKFunctionBase):
     _function: Callable[..., Any]
     _skill_collection: Optional[ReadOnlySkillCollectionBase]
     _log: Logger
-    _ai_backend: Optional[TextCompletionClientBase]
+    _ai_service: Optional[TextCompletionClientBase]
     _ai_request_settings: CompleteRequestSettings
-    _chat_backend: Optional[ChatCompletionClientBase]
+    _chat_service: Optional[ChatCompletionClientBase]
     _chat_request_settings: ChatRequestSettings
 
     @staticmethod
@@ -99,7 +105,7 @@ class SKFunction(SKFunctionBase):
 
         async def _local_func(client, request_settings, context):
             if client is None:
-                raise ValueError("AI LLM backend cannot be `None`")
+                raise ValueError("AI LLM service cannot be `None`")
 
             try:
                 if function_config.has_chat_prompt:
@@ -125,9 +131,7 @@ class SKFunction(SKFunctionBase):
                     context.variables.update(completion)
                 else:
                     prompt = await function_config.prompt_template.render_async(context)
-                    completion = await client.complete_simple_async(
-                        prompt, request_settings
-                    )
+                    completion = await client.complete_async(prompt, request_settings)
                     context.variables.update(completion)
             except Exception as e:
                 # TODO: "critical exceptions"
@@ -194,9 +198,9 @@ class SKFunction(SKFunctionBase):
         self._is_semantic = is_semantic
         self._log = log if log is not None else NullLogger()
         self._skill_collection = None
-        self._ai_backend = None
+        self._ai_service = None
         self._ai_request_settings = CompleteRequestSettings()
-        self._chat_backend = None
+        self._chat_service = None
         self._chat_request_settings = ChatRequestSettings()
 
     def set_default_skill_collection(
@@ -205,22 +209,22 @@ class SKFunction(SKFunctionBase):
         self._skill_collection = skills
         return self
 
-    def set_ai_backend(
-        self, ai_backend: Callable[[], TextCompletionClientBase]
+    def set_ai_service(
+        self, ai_service: Callable[[], TextCompletionClientBase]
     ) -> "SKFunction":
-        if ai_backend is None:
-            raise ValueError("AI LLM backend factory cannot be `None`")
+        if ai_service is None:
+            raise ValueError("AI LLM service factory cannot be `None`")
         self._verify_is_semantic()
-        self._ai_backend = ai_backend()
+        self._ai_service = ai_service()
         return self
 
-    def set_chat_backend(
-        self, chat_backend: Callable[[], ChatCompletionClientBase]
+    def set_chat_service(
+        self, chat_service: Callable[[], ChatCompletionClientBase]
     ) -> "SKFunction":
-        if chat_backend is None:
-            raise ValueError("Chat LLM backend factory cannot be `None`")
+        if chat_service is None:
+            raise ValueError("Chat LLM service factory cannot be `None`")
         self._verify_is_semantic()
-        self._chat_backend = chat_backend()
+        self._chat_service = chat_service()
         return self
 
     def set_ai_configuration(self, settings: CompleteRequestSettings) -> "SKFunction":
@@ -279,7 +283,6 @@ class SKFunction(SKFunctionBase):
                 skill_collection=self._skill_collection,
                 memory=memory if memory is not None else NullMemory.instance,
                 logger=log if log is not None else self._log,
-                # TODO: ctoken?
             )
         else:
             # If context is passed, we need to merge the variables
@@ -326,7 +329,6 @@ class SKFunction(SKFunctionBase):
                 skill_collection=self._skill_collection,
                 memory=memory if memory is not None else NullMemory.instance,
                 logger=log if log is not None else self._log,
-                # TODO: ctoken?
             )
         else:
             # If context is passed, we need to merge the variables
@@ -355,20 +357,20 @@ class SKFunction(SKFunctionBase):
         self._ensure_context_has_skills(context)
 
         if settings is None:
-            if self._ai_backend is not None:
+            if self._ai_service is not None:
                 settings = self._ai_request_settings
-            elif self._chat_backend is not None:
+            elif self._chat_service is not None:
                 settings = self._chat_request_settings
             else:
                 raise KernelException(
                     KernelException.ErrorCodes.UnknownError,
-                    "Semantic functions must have either an AI backend or Chat backend",
+                    "Semantic functions must have either an AI service or Chat service",
                 )
 
-        backend = (
-            self._ai_backend if self._ai_backend is not None else self._chat_backend
+        service = (
+            self._ai_service if self._ai_service is not None else self._chat_service
         )
-        new_context = await self._function(backend, settings, context)
+        new_context = await self._function(service, settings, context)
         context.variables.merge_or_overwrite(new_context.variables)
         return context
 

semantic_kernel/orchestration/sk_function_base.py

@@ -4,8 +4,12 @@ from abc import ABC, abstractmethod
 from logging import Logger
 from typing import TYPE_CHECKING, Callable, Optional
 
-from semantic_kernel.ai.complete_request_settings import CompleteRequestSettings
-from semantic_kernel.ai.text_completion_client_base import TextCompletionClientBase
+from semantic_kernel.connectors.ai.complete_request_settings import (
+    CompleteRequestSettings,
+)
+from semantic_kernel.connectors.ai.text_completion_client_base import (
+    TextCompletionClientBase,
+)
 from semantic_kernel.memory.semantic_text_memory_base import SemanticTextMemoryBase
 from semantic_kernel.orchestration.context_variables import ContextVariables
 from semantic_kernel.orchestration.sk_context import SKContext
@@ -80,7 +84,7 @@ class SKFunctionBase(ABC):
     @property
     @abstractmethod
     def request_settings(self) -> CompleteRequestSettings:
-        """AI backend settings"""
+        """AI service settings"""
         pass
 
     @abstractmethod
@@ -103,7 +107,6 @@ class SKFunctionBase(ABC):
         memory: Optional[SemanticTextMemoryBase] = None,
         settings: Optional[CompleteRequestSettings] = None,
         log: Optional[Logger] = None,
-        # TODO: ctoken
     ) -> SKContext:
         """
         Invokes the function with an explicit string input
@@ -129,7 +132,6 @@ class SKFunctionBase(ABC):
         memory: Optional[SemanticTextMemoryBase] = None,
         settings: Optional[CompleteRequestSettings] = None,
         log: Optional[Logger] = None,
-        # TODO: ctoken
     ) -> SKContext:
         """
         Invokes the function with an explicit string input
@@ -165,16 +167,16 @@ class SKFunctionBase(ABC):
         pass
 
     @abstractmethod
-    def set_ai_backend(
-        self, backend_factory: Callable[[], TextCompletionClientBase]
+    def set_ai_service(
+        self, service_factory: Callable[[], TextCompletionClientBase]
     ) -> "SKFunctionBase":
         """
-        Sets the AI backend used by the semantic function, passing in a factory
+        Sets the AI service used by the semantic function, passing in a factory
         method. The factory allows us to lazily instantiate the client and to
         properly handle its disposal
 
         Arguments:
-            backend_factory -- AI backend factory
+            service_factory -- AI service factory
 
         Returns:
             SKFunctionBase -- The function instance

semantic_kernel/semantic_functions/prompt_template_config.py

@@ -33,7 +33,7 @@ class PromptTemplateConfig:
     completion: "PromptTemplateConfig.CompletionConfig" = field(
         default_factory=CompletionConfig
     )
-    default_backends: List[str] = field(default_factory=list)
+    default_services: List[str] = field(default_factory=list)
     input: "PromptTemplateConfig.InputConfig" = field(default_factory=InputConfig)
 
     @staticmethod
@@ -52,7 +52,7 @@ class PromptTemplateConfig:
         config.completion.frequency_penalty = completion_dict.get("frequency_penalty")
         config.completion.max_tokens = completion_dict.get("max_tokens")
         config.completion.stop_sequences = completion_dict.get("stop_sequences", [])
-        config.default_backends = data.get("default_backends", [])
+        config.default_services = data.get("default_services", [])
 
         # Some skills may not have input parameters defined
         config.input = PromptTemplateConfig.InputConfig()

semantic_kernel/text/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from semantic_kernel.text.function_extension import aggregate_chunked_results_async
+from semantic_kernel.text.text_chunker import (
+    split_markdown_lines,
+    split_markdown_paragraph,
+    split_plaintext_lines,
+    split_plaintext_paragraph,
+)
+
+__all__ = [
+    "split_plaintext_lines",
+    "split_markdown_paragraph",
+    "split_plaintext_paragraph",
+    "split_markdown_lines",
+    "aggregate_chunked_results_async",
+]

semantic_kernel/text/function_extension.py

@@ -0,0 +1,23 @@
+# Copyright (c) Microsoft. All rights reserved.
+
+from typing import List
+
+from semantic_kernel.orchestration.sk_context import SKContext
+from semantic_kernel.orchestration.sk_function import SKFunction
+
+
+async def aggregate_chunked_results_async(
+    func: SKFunction, chunked_results: List[str], context: SKContext
+) -> SKContext:
+    """
+    Aggregate the results from the chunked results.
+    """
+    results = []
+    for chunk in chunked_results:
+        context.variables.update(chunk)
+        context = await func.invoke_async(context=context)
+
+        results.append(str(context.variables))
+
+    context.variables.update("\n".join(results))
+    return context

semantic_kernel/text/text_chunker.py

@@ -0,0 +1,250 @@
+# Copyright (c) Microsoft. All rights reserved.
+"""
+Split text in chunks, attempting to leave meaning intact.
+For plain text, split looking at new lines first, then periods, and so on.
+For markdown, split looking at punctuation first, and so on.
+"""
+import os
+from typing import List
+
+NEWLINE = os.linesep
+
+TEXT_SPLIT_OPTIONS = [
+    ["\n", "\r"],
+    ["."],
+    ["?", "!"],
+    [";"],
+    [":"],
+    [","],
+    [")", "]", "}"],
+    [" "],
+    ["-"],
+    None,
+]
+
+MD_SPLIT_OPTIONS = [
+    ["."],
+    ["?", "!"],
+    [";"],
+    [":"],
+    [","],
+    [")", "]", "}"],
+    [" "],
+    ["-"],
+    ["\n", "\r"],
+    None,
+]
+
+
+def split_plaintext_lines(text: str, max_token_per_line: int) -> List[str]:
+    """
+    Split plain text into lines.
+    it will split on new lines first, and then on punctuation.
+    """
+    return _split_text_lines(text, max_token_per_line, True)
+
+
+def split_markdown_lines(text: str, max_token_per_line: int) -> List[str]:
+    """
+    Split markdown into lines.
+    It will split on punctuation first, and then on space and new lines.
+    """
+    return _split_markdown_lines(text, max_token_per_line, True)
+
+
+def split_plaintext_paragraph(text: List[str], max_tokens: int) -> List[str]:
+    """
+    Split plain text into paragraphs.
+    """
+
+    split_lines = []
+    for line in text:
+        split_lines.extend(_split_text_lines(line, max_tokens, True))
+
+    return _split_text_paragraph(split_lines, max_tokens)
+
+
+def split_markdown_paragraph(text: List[str], max_tokens: int) -> List[str]:
+    """
+    Split markdown into paragraphs.
+    """
+    split_lines = []
+    for line in text:
+        split_lines.extend(_split_markdown_lines(line, max_tokens, False))
+
+    return _split_text_paragraph(split_lines, max_tokens)
+
+
+def _split_text_paragraph(text: List[str], max_tokens: int) -> List[str]:
+    """
+    Split text into paragraphs.
+    """
+    if not text:
+        return []
+
+    paragraphs = []
+    current_paragraph = []
+
+    for line in text:
+        num_tokens_line = _token_count(line)
+        num_tokens_paragraph = _token_count("".join(current_paragraph))
+
+        if (
+            num_tokens_paragraph + num_tokens_line + 1 >= max_tokens
+            and len(current_paragraph) > 0
+        ):
+            paragraphs.append("".join(current_paragraph).strip())
+            current_paragraph = []
+
+        current_paragraph.append(f"{line}{NEWLINE}")
+
+    if len(current_paragraph) > 0:
+        paragraphs.append("".join(current_paragraph).strip())
+        current_paragraph = []
+
+    # Distribute text more evenly in the last paragraphs
+    # when the last paragraph is too short.
+
+    if len(paragraphs) > 1:
+        last_para = paragraphs[-1]
+        sec_last_para = paragraphs[-2]
+
+        if _token_count(last_para) < max_tokens / 4:
+            last_para_tokens = last_para.split(" ")
+            sec_last_para_tokens = sec_last_para.split(" ")
+            last_para_token_count = len(last_para_tokens)
+            sec_last_para_token_count = len(sec_last_para_tokens)
+
+            if last_para_token_count + sec_last_para_token_count <= max_tokens:
+                sec_last_para = " ".join(sec_last_para_tokens) + NEWLINE
+                last_para = " ".join(last_para_tokens)
+                new_sec_last_para = sec_last_para + last_para
+                paragraphs[-2] = new_sec_last_para.strip()
+                paragraphs.pop()
+
+    return paragraphs
+
+
+def _split_markdown_lines(text: str, max_token_per_line: int, trim: bool) -> List[str]:
+    """
+    Split markdown into lines.
+    """
+
+    lines = _split_str_lines(text, max_token_per_line, MD_SPLIT_OPTIONS, trim)
+    return lines
+
+
+def _split_text_lines(text: str, max_token_per_line: int, trim: bool) -> List[str]:
+    """
+    Split text into lines.
+    """
+
+    lines = _split_str_lines(text, max_token_per_line, TEXT_SPLIT_OPTIONS, trim)
+
+    return lines
+
+
+def _split_str_lines(
+    text: str, max_tokens: int, separators: List[List[str]], trim: bool
+) -> List[str]:
+    if not text:
+        return []
+
+    text = text.replace("\r\n", "\n")
+    lines = []
+    was_split = False
+    for split_option in separators:
+        if not lines:
+            lines, was_split = _split_str(text, max_tokens, split_option, trim)
+        else:
+            lines, was_split = _split_list(lines, max_tokens, split_option, trim)
+        if not was_split:
+            break
+
+    return lines
+
+
+def _split_str(
+    text: str, max_tokens: int, separators: List[str], trim: bool
+) -> List[str]:
+    """
+    Split text into lines.
+    """
+    if not text:
+        return []
+
+    input_was_split = False
+    text = text.strip() if trim else text
+
+    text_as_is = [text]
+
+    if _token_count(text) <= max_tokens:
+        return text_as_is, input_was_split
+
+    input_was_split = True
+
+    half = int(len(text) / 2)
+
+    cutpoint = -1
+
+    if not separators:
+        cutpoint = half
+
+    elif set(separators) & set(text) and len(text) > 2:
+        for index, text_char in enumerate(text):
+            if text_char not in separators:
+                continue
+
+            if abs(half - index) < abs(half - cutpoint):
+                cutpoint = index + 1
+
+    else:
+        return text_as_is, input_was_split
+
+    if 0 < cutpoint < len(text):
+        lines = []
+        first_split, has_split1 = _split_str(
+            text[:cutpoint], max_tokens, separators, trim
+        )
+        second_split, has_split2 = _split_str(
+            text[cutpoint:], max_tokens, separators, trim
+        )
+
+        lines.extend(first_split)
+        lines.extend(second_split)
+
+        input_was_split = has_split1 or has_split2
+    else:
+        return text_as_is, input_was_split
+
+    return lines, input_was_split
+
+
+def _split_list(
+    text: List[str], max_tokens: int, separators: List[str], trim: bool
+) -> List[str]:
+    """
+    Split list of sring into lines.
+    """
+    if not text:
+        return []
+
+    lines = []
+    input_was_split = False
+    for line in text:
+        split_str, was_split = _split_str(line, max_tokens, separators, trim)
+        lines.extend(split_str)
+        input_was_split = input_was_split or was_split
+
+    return lines, input_was_split
+
+
+def _token_count(text: str) -> int:
+    """
+    Count the number of tokens in a string.
+
+    TODO: chunking methods should be configurable to allow for different
+          tokenization strategies depending on the model to be called.
+          For now, we use an extremely rough estimate.
+    """
+    return int(len(text) / 4)

{semantic_kernel-0.2.4.dev0.dist-info → semantic_kernel-0.2.5.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: semantic-kernel
-Version: 0.2.4.dev0
+Version: 0.2.5.dev0
 Summary: 
 Author: Microsoft
 Author-email: SK-Support@microsoft.com
@@ -13,6 +13,9 @@ Classifier: Programming Language :: Python :: 3.11
 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: sentence-transformers (>=2.2.2,<3.0.0)
+Requires-Dist: torch (>=2.0.0,<3.0.0)
+Requires-Dist: transformers (>=4.28.1,<5.0.0)
 Description-Content-Type: text/markdown
 
 # Get Started with Semantic Kernel ⚡
@@ -22,7 +25,7 @@ Install the latest package:
     python -m pip install --upgrade semantic-kernel
 
 
-# AI backends
+# AI Services
 
 ## OpenAI / Azure OpenAI API keys
 
@@ -44,17 +47,17 @@ AZURE_OPENAI_API_KEY=""
 
 ```python
 import semantic_kernel as sk
-from semantic_kernel.ai.open_ai import OpenAITextCompletion, AzureTextCompletion
+from semantic_kernel.connectors.ai.open_ai import OpenAITextCompletion, AzureTextCompletion
 
 kernel = sk.Kernel()
 
-# Prepare OpenAI backend using credentials stored in the `.env` file
+# Prepare OpenAI service using credentials stored in the `.env` file
 api_key, org_id = sk.openai_settings_from_dot_env()
-kernel.config.add_text_backend("dv", OpenAITextCompletion("text-davinci-003", api_key, org_id))
+kernel.config.add_text_service("dv", OpenAITextCompletion("text-davinci-003", api_key, org_id))
 
 # Alternative using Azure:
 # deployment, api_key, endpoint = sk.azure_openai_settings_from_dot_env()
-# kernel.config.add_text_backend("dv", AzureTextCompletion(deployment, endpoint, api_key))
+# kernel.config.add_text_service("dv", AzureTextCompletion(deployment, endpoint, api_key))
 
 # Wrap your prompt in a function
 prompt = kernel.create_semantic_function("""

{semantic_kernel-0.2.4.dev0.dist-info → semantic_kernel-0.2.5.dev0.dist-info}/RECORD

@@ -1,57 +1,56 @@
 semantic_kernel/__init__.py,sha256=Adohtrqn3wRrsYGz3peEca8ZuR6jeWPFtpC-zLfLkbI,1302
-semantic_kernel/ai/ai_exception.py,sha256=L_Cc_YTIbveXSOXQ8BbSjnjgLCxBz9297akNfX6EsGo,1647
-semantic_kernel/ai/chat_completion_client_base.py,sha256=bziq9Kxe7pUU5HzWtloE3CyqpVm_deRgQRsBA3Ek_q4,495
-semantic_kernel/ai/chat_request_settings.py,sha256=EusH7xhpVXxO7lcIcG7_ErfcyYdm5-eu1fSiEIurt6s,1129
-semantic_kernel/ai/complete_request_settings.py,sha256=s6BYw-jES7JEyXvuh6pz2jrOOPlx_xC4j7CJY0ptlp4,1332
-semantic_kernel/ai/embeddings/embedding_generator_base.py,sha256=TjWr4gf-SUBLBVCgF3ekFEs8dPHLAKzUWZ5WVTucdfk,282
-semantic_kernel/ai/embeddings/embedding_index_base.py,sha256=My8pCcg0vJCOHyNXTpPu3AykIB2D6hT9xRKP8R8GstU,479
-semantic_kernel/ai/open_ai/__init__.py,sha256=AKc76fUVfNtnkfHfwhRQbs6NkKUNIRt6hKvUztwBBS8,817
-semantic_kernel/ai/open_ai/services/azure_chat_completion.py,sha256=3UefhXZF18KIU8lbXG3Wi7CEuLuGNhePvxFfmTD3HZU,2771
-semantic_kernel/ai/open_ai/services/azure_text_completion.py,sha256=_l_5hHc8P4xoBehR5dRHwU1n0P927-gfvBKmUAvUSQ0,2763
-semantic_kernel/ai/open_ai/services/azure_text_embedding.py,sha256=ro9D-fi-2a5DYNNHAlsA6uE5h5iUW37QssIEZRfJjOY,2758
-semantic_kernel/ai/open_ai/services/open_ai_chat_completion.py,sha256=b3AUiZq9N0nZnp7K3EO3VTcMwhX-43nX_j47hlgdb48,4007
-semantic_kernel/ai/open_ai/services/open_ai_text_completion.py,sha256=W6lpmIG-gRdy5S5Ratbu-2MIPFbUPqN1ZgkrzT8mCa4,4441
-semantic_kernel/ai/open_ai/services/open_ai_text_embedding.py,sha256=r3u1Kiw7Bck8Bj83zjC11dYdC73-17rqgEV1mtfKgM4,2427
-semantic_kernel/ai/text_completion_client_base.py,sha256=YCzHEdPmFhdwZNtu0BPX40PGmugsf59alm505Dm4by0,476
+semantic_kernel/connectors/ai/ai_exception.py,sha256=L_Cc_YTIbveXSOXQ8BbSjnjgLCxBz9297akNfX6EsGo,1647
+semantic_kernel/connectors/ai/chat_completion_client_base.py,sha256=FUSw5GFUPTLIcea1MGz2rEve7o6qO1n3J22xWEshOL0,506
+semantic_kernel/connectors/ai/chat_request_settings.py,sha256=EusH7xhpVXxO7lcIcG7_ErfcyYdm5-eu1fSiEIurt6s,1129
+semantic_kernel/connectors/ai/complete_request_settings.py,sha256=s6BYw-jES7JEyXvuh6pz2jrOOPlx_xC4j7CJY0ptlp4,1332
+semantic_kernel/connectors/ai/embeddings/embedding_generator_base.py,sha256=TjWr4gf-SUBLBVCgF3ekFEs8dPHLAKzUWZ5WVTucdfk,282
+semantic_kernel/connectors/ai/hugging_face/__init__.py,sha256=-QjM630BtqkYKXYnuuCj0rHAtvi2y1PxfShIwpEfbIk,352
+semantic_kernel/connectors/ai/hugging_face/services/hf_text_completion.py,sha256=rOBfXi2qU6ntdJg0Wp6y1-unaPR0-Xv9B3_7lvYMvg4,3463
+semantic_kernel/connectors/ai/hugging_face/services/hf_text_embedding.py,sha256=EHzm9BgWFEVDww0Xd1YesYpWwdflEMdHLnHv4WnV7S4,2093
+semantic_kernel/connectors/ai/open_ai/__init__.py,sha256=R2DKk3sI0QoVHReuJbuAKbeBBAcLeTcyD_ZNrYT5irk,892
+semantic_kernel/connectors/ai/open_ai/services/azure_chat_completion.py,sha256=LNT9Fz2qJNbKuJY_gm_nW31kxG62QfQNawr21UtUsoc,2782
+semantic_kernel/connectors/ai/open_ai/services/azure_text_completion.py,sha256=uYv4e9APYRDVmYgR470Uh9VbwGXcEqkJMY7DS8CKuRI,2774
+semantic_kernel/connectors/ai/open_ai/services/azure_text_embedding.py,sha256=I8ePGCK4BnnglS86VepZ0Jf24n-FgK7hB_TACTn4Xnw,2769
+semantic_kernel/connectors/ai/open_ai/services/open_ai_chat_completion.py,sha256=-NfP5PPg5pb7cofxiBDm5S9AGycpxpI67w8me3fErUk,5227
+semantic_kernel/connectors/ai/open_ai/services/open_ai_text_completion.py,sha256=IYrt-XTTaMtb32p7iaP6ItCeOdLrQsPiMGSOdAy-SIo,4471
+semantic_kernel/connectors/ai/open_ai/services/open_ai_text_embedding.py,sha256=AVGeSTLr5UC_eqnSFRByB1LIbDxvJDxMFxsELzr08j8,2449
+semantic_kernel/connectors/ai/text_completion_client_base.py,sha256=PxLOwDatOlddLObfF33OaCUq2qQCfab8llLc_a0cVV8,497
 semantic_kernel/core_skills/__init__.py,sha256=CyLz2bgmsaKu3FSTzU7KmoAZPlWl4YQpIQ7inVmSZJs,457
 semantic_kernel/core_skills/file_io_skill.py,sha256=b9m7Ll3A7exhb49eCOYQBO1H8AEJbwCIdnGdDXuj2Ts,2072
 semantic_kernel/core_skills/http_skill.py,sha256=ferr2_4x5mMfUj-FHjLRCdtHLOlMBsTx4H03g4o1V4I,3754
 semantic_kernel/core_skills/text_memory_skill.py,sha256=LSv6G2rE-Zhhym_ry9oyUQJxeiYAI3okBU_kEpz4VoM,4641
 semantic_kernel/core_skills/text_skill.py,sha256=GdB8tAs8lFYBSGXNX9R6ppGzLt1-tlR2oz5-ecrXiH8,2403
-semantic_kernel/core_skills/time_skill.py,sha256=q9Ps8Cwm5AZajITYRcweQ2r7MQbrb5Q6HuxCMZgjPtM,5613
-semantic_kernel/kernel.py,sha256=pyHrO_0WDm1jXdwbnWVLKScKQSOzNCs8BNQI_jzsgfo,12421
+semantic_kernel/core_skills/time_skill.py,sha256=fu7vrXL4yFPdYNCZGu7Jp-d51EU1GsBOFkGCZGuz2Yo,5849
+semantic_kernel/kernel.py,sha256=P3CJ3qTSUW-Dq7wX9hwRRiu-j-zQEozC5hlMmMVPghM,12503
 semantic_kernel/kernel_base.py,sha256=0MZCdswabNiRuo60RUrxakoRmW65-5qK5ZVmn7PhwQY,2240
-semantic_kernel/kernel_config.py,sha256=u8y0xKHWrtjFuPByJ87KGdLicZK-0bKp0aRI9qhXWFY,9134
-semantic_kernel/kernel_exception.py,sha256=qAkVdqiqsMiLGoQkymrmGdX3NbAA9C7ZV6cl5eyFPFk,1626
+semantic_kernel/kernel_config.py,sha256=mGqNucb5nON4-qg54mRihs4eIr4X3vuV6S1SPP-TEpA,9401
+semantic_kernel/kernel_exception.py,sha256=HpUGXGHndLzV1d1QxED3UEQQAHuc46r6XyBNDjT92es,1626
 semantic_kernel/kernel_extensions/__init__.py,sha256=84fkiRzxl3He5DrBuj5zGbHOqPGfa-pTbcYCneZdi7k,710
 semantic_kernel/kernel_extensions/extends_kernel.py,sha256=lStaPx4YT1f61-y9-fYw4-z18DTrsOW9WlhsM2JDAKY,210
-semantic_kernel/kernel_extensions/import_skills.py,sha256=TGjIv3kxZ1hpc_QdFXRFNJcPKW8wkezQTDSLVmmwnKE,3826
+semantic_kernel/kernel_extensions/import_skills.py,sha256=l-97gUpNgILOhfyUAF09xyp-Tebi0bTqSH9krGS11So,3822
 semantic_kernel/kernel_extensions/inline_definition.py,sha256=caPbJ99BdZdYa6GsegLQ4SurP0hDY9nK1lLUF887Quw,2323
-semantic_kernel/kernel_extensions/memory_configuration.py,sha256=osiqszNW4Gsu3T96F8Taw9paKp9g44oOb6PDbcgaWog,1531
+semantic_kernel/kernel_extensions/memory_configuration.py,sha256=URcNYZiCiEp28T4XvePmmEgpxdzNGueGz4sUpBKbyu8,1481
 semantic_kernel/memory/__init__.py,sha256=S67WhFdqzVoXcIHWDZ1_zKtEn50_iBqpX6W2Y1LCB34,160
-semantic_kernel/memory/memory_query_result.py,sha256=sfkohuWK5jpbvzPPtGrVmq2UrnarnNIYQrslDG4oMn0,1174
-semantic_kernel/memory/memory_record.py,sha256=l1iPWl264GaiCFpj7uUBaE_e2-sT4OWu7QmpyuOYjKw,1598
-semantic_kernel/memory/memory_store_base.py,sha256=WImY5_PZz0_4xdNuRStJqxz99XBhvoGQ3RX1VFrdIwE,299
+semantic_kernel/memory/memory_query_result.py,sha256=2gJxIhGPFrxd_nDncYGqBB1n7FlQuHAGf8l9o-jHyGg,2345
+semantic_kernel/memory/memory_record.py,sha256=yb4DE9SNGrhbMJsZd1tMifvZp5uQeOcHz50Onf9hW0w,3089
+semantic_kernel/memory/memory_store_base.py,sha256=ZW7xs_lPH3yDgQv4p77pOu1DLowJ_UU0GPCxyMP0Hpo,2012
 semantic_kernel/memory/null_memory.py,sha256=Ucoj269Qexr8jHHZmLzgfwAW1yIqne65Tm8e6TTpJek,1137
-semantic_kernel/memory/semantic_text_memory.py,sha256=wgwN_k2FVp5i3crLShE_xlo9U6fKYnTRKmbWe02MD88,2499
-semantic_kernel/memory/semantic_text_memory_base.py,sha256=gDlZvq020wEHD8GwTN3-RfGr9sIJoxF0pm4OaPUq8Vg,1237
-semantic_kernel/memory/storage/data_entry.py,sha256=lGpmZoQKxlZ7SMjlAXYltfzJaUOh924cqtWQAyHpkD4,836
-semantic_kernel/memory/storage/data_store_base.py,sha256=E9-Dv-YztU_H1fqa4ExPx1c2LllXcKAP-qMD3GVTP-w,953
-semantic_kernel/memory/storage/volatile_data_store.py,sha256=NdmZ7hUpR1-3tN7TQ5AYutZfWZ3Pl44X-D5b3rOJW5k,1989
-semantic_kernel/memory/volatile_memory_store.py,sha256=kxN4YAR32WT2h0o1qSiqCYze0zKwqQ1vfv8xDsYBo3U,4050
+semantic_kernel/memory/semantic_text_memory.py,sha256=gYrlq1-bOn-qMtFxBS3FHaTMZuQjjGz8ASWLvr73YZw,6036
+semantic_kernel/memory/semantic_text_memory_base.py,sha256=-IF6cmtrqM2aNQyjL6ikm1ZIGNULmvBAtehHDS6SHRI,1196
+semantic_kernel/memory/volatile_memory_store.py,sha256=SxmvMt2snwDCKazsgozcCcrtxaQ4t2Ov6Kc5GNIBHmg,12032
 semantic_kernel/orchestration/context_variables.py,sha256=sNGrZPxZQXE3pGVoahjYqb5BZ49WFvyBDpMwI-VWT0Q,2361
 semantic_kernel/orchestration/delegate_handlers.py,sha256=uyZsiPr5v-UphQXwsH1ftqbJxPCigXoqMsrY2m9VVjQ,5079
 semantic_kernel/orchestration/delegate_inference.py,sha256=c3ullA55Mf8kX6jcdiIuBv6eGsSSRsFphF_vHL-viA8,8966
 semantic_kernel/orchestration/delegate_types.py,sha256=ZcnZCMtyrZMj7r8y6cPom3IuD0sHa4KQPucdZHpQsKE,638
 semantic_kernel/orchestration/sk_context.py,sha256=DZl_ucEtGjKqbOZYWgSRn9-FMLzhDJbli5Cqv3PMlIg,7514
-semantic_kernel/orchestration/sk_function.py,sha256=gEMssukiyBChGCvY2bClO-LYCcDbtv__Wkh2vH5urBM,15963
-semantic_kernel/orchestration/sk_function_base.py,sha256=snGj6DPmPdAraCWvvl55Yz7Re8oo1Ap8drVFR62rolg,6164
+semantic_kernel/orchestration/sk_function.py,sha256=VOsEEQQQMJviofHc906P4dC1KYo48bS4K97Xx_t6UwU,15917
+semantic_kernel/orchestration/sk_function_base.py,sha256=oSADu3xi7foDHGSbo156Lvm0iJnSAv0VTLNhYZkbuFA,6158
 semantic_kernel/reliability/pass_through_without_retry.py,sha256=ULbry84vLGbh58naaBgwVCrPQr0Y_sxQFO9FRlpA5yg,919
 semantic_kernel/reliability/retry_mechanism.py,sha256=kXQp4M1MKeGob84L4F02lVM1d0fDEwzS1kI1MI0ezHg,673
 semantic_kernel/semantic_functions/chat_prompt_template.py,sha256=lZF02xYXuZNtRVAZ4h2DYN_le-kNow2RhXWQnLD1UU4,2101
 semantic_kernel/semantic_functions/prompt_template.py,sha256=7qzsY_3Yyf3sqUM7XuMw35PlX-N7Feqqw24b5-3Ek0A,2332
 semantic_kernel/semantic_functions/prompt_template_base.py,sha256=y_pG7LtwbSsdWTikxUQNApAscIJtB0S_E53-WMk-JVQ,506
-semantic_kernel/semantic_functions/prompt_template_config.py,sha256=gXNIiDI3gYE2dD0s0mCVXnJNB2v0STAh0fD44nkI8pw,4269
+semantic_kernel/semantic_functions/prompt_template_config.py,sha256=6Zq1bkIao_D8eE0dYagUEUKVRrX1SXnCh8PQV4KeniM,4269
 semantic_kernel/semantic_functions/semantic_function_config.py,sha256=buON4ZVTHBQQSVOJ1AVEIZtONqgVJFH1tXeiVkFip1Q,671
 semantic_kernel/skill_definition/__init__.py,sha256=rEhtQBLH1L-OMTailF4yORbOKzSUudA5F1fZSSjPYgw,322
 semantic_kernel/skill_definition/function_view.py,sha256=YFj7mhTI2OMv2QcxMEABMW7C6RrgKv-iadmZQLkZQqo,2053
@@ -78,10 +77,13 @@ semantic_kernel/template_engine/protocols/code_renderer.py,sha256=edZ4gseJdB9xw6
 semantic_kernel/template_engine/protocols/prompt_templating_engine.py,sha256=e7THxsNhLKZ5l55FOkGch_N2nTnXLU-iTX2gupamd5o,3043
 semantic_kernel/template_engine/protocols/text_renderer.py,sha256=9tr0wF6TilL5ZmZzrlDIUBTVzNT_JHbjQxVgfjTAovM,596
 semantic_kernel/template_engine/template_tokenizer.py,sha256=IfnnsN6u43ks0RuM6eyNmlzGPU8r9VsCWsmY0eTOva4,7637
+semantic_kernel/text/__init__.py,sha256=lOLUtteokw8bUV4ZckhI3VHa4Z0YxDa4baPzAb4ZpFk,473
+semantic_kernel/text/function_extension.py,sha256=Qv9fHLSjOswJY1bve52hJ42G-ZfsmZiZ6Yyz1fcMUI4,667
+semantic_kernel/text/text_chunker.py,sha256=uSGYBkJ3F6a5mrawWtbrs3m__bDQCXHqYUIyCgKsJj8,6466
 semantic_kernel/utils/null_logger.py,sha256=DSEc9sUhmhPq2PHw8ClA8p_cyETMVmghhaKbzMcRe1w,403
 semantic_kernel/utils/settings.py,sha256=nH4uQvS4v22w2CiImJxSDa-yQ9hQW9uttlCN4krgotM,2436
 semantic_kernel/utils/static_property.py,sha256=Yx0skR7C6-7tPG47rB_T5dteYmKxGVLksKcGinwBRFI,221
 semantic_kernel/utils/validation.py,sha256=vo3Xuvj0P9FlGZeQZYbcSwcQI19w7b8KyJ2QgWbAchY,2198
-semantic_kernel-0.2.4.dev0.dist-info/METADATA,sha256=7WaYhe9W1MnyzWVDpNB5lp9nYeR6vvtbamAu6qIo3mY,5136
-semantic_kernel-0.2.4.dev0.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
-semantic_kernel-0.2.4.dev0.dist-info/RECORD,,
+semantic_kernel-0.2.5.dev0.dist-info/METADATA,sha256=WtOH8wy7lzp9U8a04qEb2WY2OHHp2VeAJkZiOxvFU6w,5285
+semantic_kernel-0.2.5.dev0.dist-info/WHEEL,sha256=7Z8_27uaHI_UZAc4Uox4PpBhQ9Y5_modZXWMxtUi4NU,88
+semantic_kernel-0.2.5.dev0.dist-info/RECORD,,