promptlayer 1.0.51__tar.gz → 1.0.53__tar.gz

{promptlayer-1.0.51 → promptlayer-1.0.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: promptlayer
-Version: 1.0.51
+Version: 1.0.53
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
 Author: Magniv

{promptlayer-1.0.51 → promptlayer-1.0.53}/promptlayer/__init__.py

@@ -1,4 +1,4 @@
 from .promptlayer import AsyncPromptLayer, PromptLayer
 
-__version__ = "1.0.51"
+__version__ = "1.0.53"
 __all__ = ["PromptLayer", "AsyncPromptLayer", "__version__"]

{promptlayer-1.0.51 → promptlayer-1.0.53}/promptlayer/promptlayer.py

@@ -137,7 +137,7 @@ class PromptLayer(PromptLayerMixin):
         prompt_blueprint_model = self._validate_and_extract_model_from_prompt_blueprint(
             prompt_blueprint=prompt_blueprint, prompt_name=prompt_name
         )
-        llm_request_params = self._prepare_llm_request_params(
+        llm_data = self._prepare_llm_data(
             prompt_blueprint=prompt_blueprint,
             prompt_template=prompt_blueprint["prompt_template"],
             prompt_blueprint_model=prompt_blueprint_model,
@@ -145,24 +145,30 @@ class PromptLayer(PromptLayerMixin):
             stream=stream,
         )
 
-        response = llm_request_params["request_function"](
-            llm_request_params["prompt_blueprint"], **llm_request_params["kwargs"]
+        # response is just whatever the LLM call returns
+        # streaming=False > Pydantic model instance
+        # streaming=True > generator that yields ChatCompletionChunk pieces as they arrive
+        response = llm_data["request_function"](
+            prompt_blueprint=llm_data["prompt_blueprint"],
+            client_kwargs=llm_data["client_kwargs"],
+            function_kwargs=llm_data["function_kwargs"],
         )
 
         if stream:
             return stream_response(
-                response,
-                self._create_track_request_callable(
-                    request_params=llm_request_params,
+                generator=response,
+                after_stream=self._create_track_request_callable(
+                    request_params=llm_data,
                     tags=tags,
                     input_variables=input_variables,
                     group_id=group_id,
                     pl_run_span_id=pl_run_span_id,
                 ),
-                llm_request_params["stream_function"],
+                map_results=llm_data["stream_function"],
             )
+
         request_log = self._track_request_log(
-            llm_request_params,
+            llm_data,
             tags,
             input_variables,
             group_id,
@@ -551,7 +557,7 @@ class AsyncPromptLayer(PromptLayerMixin):
         prompt_blueprint_model = self._validate_and_extract_model_from_prompt_blueprint(
             prompt_blueprint=prompt_blueprint, prompt_name=prompt_name
         )
-        llm_request_params = self._prepare_llm_request_params(
+        llm_data = self._prepare_llm_data(
             prompt_blueprint=prompt_blueprint,
             prompt_template=prompt_blueprint["prompt_template"],
             prompt_blueprint_model=prompt_blueprint_model,
@@ -560,13 +566,15 @@ class AsyncPromptLayer(PromptLayerMixin):
             is_async=True,
         )
 
-        response = await llm_request_params["request_function"](
-            llm_request_params["prompt_blueprint"], **llm_request_params["kwargs"]
+        response = await llm_data["request_function"](
+            prompt_blueprint=llm_data["prompt_blueprint"],
+            client_kwargs=llm_data["client_kwargs"],
+            function_kwargs=llm_data["function_kwargs"],
         )
 
         if stream:
             track_request_callable = await self._create_track_request_callable(
-                request_params=llm_request_params,
+                request_params=llm_data,
                 tags=tags,
                 input_variables=input_variables,
                 group_id=group_id,
@@ -575,11 +583,11 @@ class AsyncPromptLayer(PromptLayerMixin):
             return astream_response(
                 response,
                 track_request_callable,
-                llm_request_params["stream_function"],
+                llm_data["stream_function"],
             )
 
         request_log = await self._track_request_log(
-            llm_request_params,
+            llm_data,
             tags,
             input_variables,
             group_id,

{promptlayer-1.0.51 → promptlayer-1.0.53}/promptlayer/promptlayer_mixins.py

@@ -2,7 +2,7 @@ import asyncio
 import datetime
 from copy import deepcopy
 from functools import wraps
-from typing import Dict, Union
+from typing import Any, Dict, Union
 
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -92,11 +92,11 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
 
 
 MAP_PROVIDER_TO_FUNCTION = {
-    "openai": openai_request,
     "anthropic": anthropic_request,
-    "openai.azure": azure_openai_request,
-    "mistral": mistral_request,
     "google": google_request,
+    "mistral": mistral_request,
+    "openai": openai_request,
+    "openai.azure": azure_openai_request,
 }
 
 AMAP_PROVIDER_TO_FUNCTION_NAME = {
@@ -154,11 +154,11 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
 
 
 AMAP_PROVIDER_TO_FUNCTION = {
-    "openai": aopenai_request,
     "anthropic": aanthropic_request,
-    "openai.azure": aazure_openai_request,
-    "mistral": amistral_request,
     "google": agoogle_request,
+    "mistral": amistral_request,
+    "openai": aopenai_request,
+    "openai.azure": aazure_openai_request,
 }
 
 
@@ -177,7 +177,13 @@ class PromptLayerMixin:
             return None, None
 
     @staticmethod
-    def _prepare_get_prompt_template_params(*, prompt_version, prompt_release_label, input_variables, metadata):
+    def _prepare_get_prompt_template_params(
+        *,
+        prompt_version: Union[int, None],
+        prompt_release_label: Union[str, None],
+        input_variables: Union[Dict[str, Any], None],
+        metadata: Union[Dict[str, str], None],
+    ) -> Dict[str, Any]:
         params = {}
 
         if prompt_version:
@@ -192,7 +198,7 @@ class PromptLayerMixin:
         return params
 
     @staticmethod
-    def _prepare_llm_request_params(
+    def _prepare_llm_data(
         *,
         prompt_blueprint,
         prompt_template,
@@ -201,8 +207,26 @@ class PromptLayerMixin:
         stream,
         is_async=False,
     ):
+        client_kwargs = {}
+        function_kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+        function_kwargs["stream"] = stream
         provider = prompt_blueprint_model["provider"]
-        kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+
+        if custom_provider := prompt_blueprint.get("custom_provider"):
+            provider = custom_provider["client"]
+            client_kwargs = {
+                "api_key": custom_provider["api_key"],
+                "base_url": custom_provider["base_url"],
+            }
+        elif provider_base_url := prompt_blueprint.get("provider_base_url"):
+            client_kwargs["base_url"] = provider_base_url["url"]
+
+        if model_parameter_overrides:
+            function_kwargs.update(model_parameter_overrides)
+
+        if stream and provider in ["openai", "openai.azure"]:
+            function_kwargs["stream_options"] = {"include_usage": True}
+
         if is_async:
             config = AMAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
             request_function = AMAP_PROVIDER_TO_FUNCTION[provider]
@@ -210,22 +234,13 @@ class PromptLayerMixin:
             config = MAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
             request_function = MAP_PROVIDER_TO_FUNCTION[provider]
 
-        if provider_base_url := prompt_blueprint.get("provider_base_url"):
-            kwargs["base_url"] = provider_base_url["url"]
-
-        if model_parameter_overrides:
-            kwargs.update(model_parameter_overrides)
-
-        kwargs["stream"] = stream
-        if stream and provider in ["openai", "openai.azure"]:
-            kwargs["stream_options"] = {"include_usage": True}
-
         return {
             "provider": provider,
             "function_name": config["function_name"],
             "stream_function": config["stream_function"],
             "request_function": request_function,
-            "kwargs": kwargs,
+            "client_kwargs": client_kwargs,
+            "function_kwargs": function_kwargs,
             "prompt_blueprint": prompt_blueprint,
         }
 
@@ -263,7 +278,7 @@ class PromptLayerMixin:
             "function_name": request_params["function_name"],
             "provider_type": request_params["provider"],
             "args": [],
-            "kwargs": request_params["kwargs"],
+            "kwargs": request_params["function_kwargs"],
             "tags": tags,
             "request_start_time": datetime.datetime.now(datetime.timezone.utc).timestamp(),
             "request_end_time": datetime.datetime.now(datetime.timezone.utc).timestamp(),

{promptlayer-1.0.51 → promptlayer-1.0.53}/promptlayer/types/prompt_template.py

@@ -23,6 +23,11 @@ class TextContent(TypedDict, total=False):
     text: str
 
 
+class ThinkingContent(TypedDict, total=False):
+    type: Literal["thinking"]
+    thinking: str
+
+
 class ImageContent(TypedDict, total=False):
     type: Literal["image_url"]
     image_url: ImageUrl
@@ -44,7 +49,7 @@ class MediaVariable(TypedDict, total=False):
     name: str
 
 
-Content = Union[TextContent, ImageContent, MediaContnt, MediaVariable]
+Content = Union[TextContent, ThinkingContent, ImageContent, MediaContnt, MediaVariable]
 
 
 class Function(TypedDict, total=False):

{promptlayer-1.0.51 → promptlayer-1.0.53}/promptlayer/utils.py

@@ -788,30 +788,79 @@ class GeneratorProxy:
             response = ""
             for result in self.results:
                 if hasattr(result, "completion"):
-                    response = f"{response}{result.completion}"
+                    response += result.completion
                 elif hasattr(result, "message") and isinstance(result.message, str):
-                    response = f"{response}{result.message}"
+                    response += result.message
                 elif (
                     hasattr(result, "content_block")
                     and hasattr(result.content_block, "text")
-                    and "type" in result
-                    and result.type != "message_stop"
+                    and getattr(result, "type", None) != "message_stop"
                 ):
-                    response = f"{response}{result.content_block.text}"
-                elif hasattr(result, "delta") and hasattr(result.delta, "text"):
-                    response = f"{response}{result.delta.text}"
-            if (
-                hasattr(self.results[-1], "type") and self.results[-1].type == "message_stop"
-            ):  # this is a message stream and not the correct event
+                    response += result.content_block.text
+                elif hasattr(result, "delta"):
+                    if hasattr(result.delta, "thinking"):
+                        response += result.delta.thinking
+                    elif hasattr(result.delta, "text"):
+                        response += result.delta.text
+
+            # 2) If this is a “stream” (ended by message_stop), reconstruct both ThinkingBlock & TextBlock
+            last_event = self.results[-1]
+            if getattr(last_event, "type", None) == "message_stop":
                 final_result = deepcopy(self.results[0].message)
-                final_result.usage = None
-                content_block = deepcopy(self.results[1].content_block)
-                content_block.text = response
-                final_result.content = [content_block]
+
+                content_blocks = []
+                current_block = None
+                current_signature = ""
+                current_thinking = ""
+                current_text = ""
+
+                for event in self.results:
+                    # On a new content block starting:
+                    if getattr(event, "type", None) == "content_block_start":
+                        current_block = deepcopy(event.content_block)
+
+                        if getattr(event.content_block, "type", None) == "thinking":
+                            current_signature = ""
+                            current_thinking = ""
+                        elif getattr(event.content_block, "type", None) == "text":
+                            current_text = ""
+
+                    elif getattr(event, "type", None) == "content_block_delta" and current_block is not None:
+                        if getattr(current_block, "type", None) == "thinking":
+                            if hasattr(event.delta, "signature"):
+                                current_signature = event.delta.signature
+                            if hasattr(event.delta, "thinking"):
+                                current_thinking += event.delta.thinking
+
+                        elif getattr(current_block, "type", None) == "text":
+                            if hasattr(event.delta, "text"):
+                                current_text += event.delta.text
+
+                    elif getattr(event, "type", None) == "content_block_stop" and current_block is not None:
+                        if getattr(current_block, "type", None) == "thinking":
+                            current_block.signature = current_signature
+                            current_block.thinking = current_thinking
+                        elif getattr(current_block, "type", None) == "text":
+                            current_block.text = current_text
+
+                        content_blocks.append(current_block)
+
+                        current_block = None
+                        current_signature = ""
+                        current_thinking = ""
+                        current_text = ""
+
+                final_result.content = content_blocks
+                for event in reversed(self.results):
+                    if hasattr(event, "usage") and hasattr(event.usage, "output_tokens"):
+                        final_result.usage.output_tokens = event.usage.output_tokens
+                        break
+
+                return final_result
+
+            # 3) Otherwise (not a “stream”), fall back to returning the last raw message
             else:
-                final_result = deepcopy(self.results[-1])
-                final_result.completion = response
-            return final_result
+                return deepcopy(self.results[-1])
         if hasattr(self.results[0].choices[0], "text"):  # this is regular completion
             response = ""
             for result in self.results:
@@ -1485,7 +1534,7 @@ async def aanthropic_stream_completion(generator: AsyncIterable[Any]) -> Any:
     return response
 
 
-def stream_response(generator: Generator, after_stream: Callable, map_results: Callable):
+def stream_response(*, generator: Generator, after_stream: Callable, map_results: Callable):
     data = {
         "request_id": None,
         "raw_response": None,
@@ -1544,12 +1593,12 @@ MAP_TYPE_TO_OPENAI_FUNCTION = {
 }
 
 
-def openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+def openai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import OpenAI
 
-    client = OpenAI(base_url=kwargs.pop("base_url", None))
+    client = OpenAI(**client_kwargs)
     request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
 async def aopenai_chat_request(client, **kwargs):
@@ -1566,28 +1615,30 @@ AMAP_TYPE_TO_OPENAI_FUNCTION = {
 }
 
 
-async def aopenai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+async def aopenai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import AsyncOpenAI
 
-    client = AsyncOpenAI(base_url=kwargs.pop("base_url", None))
+    client = AsyncOpenAI(**client_kwargs)
     request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    return await request_to_make(client, **function_kwargs)
 
 
-def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import AzureOpenAI
 
-    client = AzureOpenAI(azure_endpoint=kwargs.pop("base_url", None))
+    client = AzureOpenAI(azure_endpoint=client_kwargs.pop("base_url", None))
     request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
-async def aazure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+async def aazure_openai_request(
+    prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict
+):
     from openai import AsyncAzureOpenAI
 
-    client = AsyncAzureOpenAI(azure_endpoint=kwargs.pop("base_url", None))
+    client = AsyncAzureOpenAI(azure_endpoint=client_kwargs.pop("base_url", None))
     request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    return await request_to_make(client, **function_kwargs)
 
 
 def anthropic_chat_request(client, **kwargs):
@@ -1604,12 +1655,12 @@ MAP_TYPE_TO_ANTHROPIC_FUNCTION = {
 }
 
 
-def anthropic_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+def anthropic_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from anthropic import Anthropic
 
-    client = Anthropic(base_url=kwargs.pop("base_url", None))
+    client = Anthropic(**client_kwargs)
     request_to_make = MAP_TYPE_TO_ANTHROPIC_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
 async def aanthropic_chat_request(client, **kwargs):
@@ -1626,12 +1677,12 @@ AMAP_TYPE_TO_ANTHROPIC_FUNCTION = {
 }
 
 
-async def aanthropic_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+async def aanthropic_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from anthropic import AsyncAnthropic
 
-    client = AsyncAnthropic(base_url=kwargs.pop("base_url", None))
+    client = AsyncAnthropic(**client_kwargs)
     request_to_make = AMAP_TYPE_TO_ANTHROPIC_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    return await request_to_make(client, **function_kwargs)
 
 
 # do not remove! This is used in the langchain integration.
@@ -1690,31 +1741,29 @@ async def autil_log_request(api_key: str, **kwargs) -> Union[RequestLog, None]:
         return None
 
 
-def mistral_request(
-    prompt_blueprint: GetPromptTemplateResponse,
-    **kwargs,
-):
+def mistral_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from mistralai import Mistral
 
     client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
-    if "stream" in kwargs and kwargs["stream"]:
-        kwargs.pop("stream")
-        return client.chat.stream(**kwargs)
-    if "stream" in kwargs:
-        kwargs.pop("stream")
-    return client.chat.complete(**kwargs)
+    if "stream" in function_kwargs and function_kwargs["stream"]:
+        function_kwargs.pop("stream")
+        return client.chat.stream(**function_kwargs)
+    if "stream" in function_kwargs:
+        function_kwargs.pop("stream")
+    return client.chat.complete(**function_kwargs)
 
 
 async def amistral_request(
     prompt_blueprint: GetPromptTemplateResponse,
-    **kwargs,
+    _: dict,
+    function_kwargs: dict,
 ):
     from mistralai import Mistral
 
     client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
-    if "stream" in kwargs and kwargs["stream"]:
-        return await client.chat.stream_async(**kwargs)
-    return await client.chat.complete_async(**kwargs)
+    if "stream" in function_kwargs and function_kwargs["stream"]:
+        return await client.chat.stream_async(**function_kwargs)
+    return await client.chat.complete_async(**function_kwargs)
 
 
 def mistral_stream_chat(results: list):
@@ -1898,12 +1947,12 @@ MAP_TYPE_TO_GOOGLE_FUNCTION = {
 }
 
 
-def google_request(request: GetPromptTemplateResponse, **kwargs):
+def google_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from google import genai
 
     client = genai.Client()
-    request_to_make = MAP_TYPE_TO_GOOGLE_FUNCTION[request["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    request_to_make = MAP_TYPE_TO_GOOGLE_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
+    return request_to_make(client, **function_kwargs)
 
 
 async def agoogle_chat_request(client, **kwargs):
@@ -1936,12 +1985,12 @@ AMAP_TYPE_TO_GOOGLE_FUNCTION = {
 }
 
 
-async def agoogle_request(request: GetPromptTemplateResponse, **kwargs):
+async def agoogle_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from google import genai
 
     client = genai.Client()
-    request_to_make = AMAP_TYPE_TO_GOOGLE_FUNCTION[request["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    request_to_make = AMAP_TYPE_TO_GOOGLE_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
+    return await request_to_make(client, **function_kwargs)
 
 
 async def amap_google_stream_response(generator: AsyncIterable[Any]):

{promptlayer-1.0.51 → promptlayer-1.0.53}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "promptlayer"
-version = "1.0.51"
+version = "1.0.53"
 description = "PromptLayer is a platform for prompt engineering and tracks your LLM requests."
 authors = ["Magniv <hello@magniv.io>"]
 license = "Apache-2.0"