promptlayer 1.0.59__py3-none-any.whl → 1.0.61__py3-none-any.whl

promptlayer/__init__.py

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

promptlayer/promptlayer.py

@@ -9,6 +9,7 @@ import nest_asyncio
 from promptlayer.groups import AsyncGroupManager, GroupManager
 from promptlayer.promptlayer_base import PromptLayerBase
 from promptlayer.promptlayer_mixins import PromptLayerMixin
+from promptlayer.streaming import astream_response, stream_response
 from promptlayer.templates import AsyncTemplateManager, TemplateManager
 from promptlayer.track import AsyncTrackManager, TrackManager
 from promptlayer.types.prompt_template import PromptTemplate
@@ -16,10 +17,8 @@ from promptlayer.utils import (
     RERAISE_ORIGINAL_EXCEPTION,
     _get_workflow_workflow_id_or_name,
     arun_workflow_request,
-    astream_response,
     atrack_request,
     autil_log_request,
-    stream_response,
     track_request,
     util_log_request,
 )
@@ -169,6 +168,7 @@ class PromptLayer(PromptLayerMixin):
                     pl_run_span_id=pl_run_span_id,
                 ),
                 map_results=llm_data["stream_function"],
+                metadata=llm_data["prompt_blueprint"]["metadata"],
             )
 
         request_log = self._track_request_log(
@@ -320,6 +320,7 @@ class PromptLayer(PromptLayerMixin):
         price: float = 0.0,
         function_name: str = "",
         score: int = 0,
+        prompt_id: Union[int, None] = None,
     ):
         return util_log_request(
             self.api_key,
@@ -340,6 +341,7 @@ class PromptLayer(PromptLayerMixin):
             price=price,
             function_name=function_name,
             score=score,
+            prompt_id=prompt_id,
         )
 
 
@@ -478,6 +480,7 @@ class AsyncPromptLayer(PromptLayerMixin):
         price: float = 0.0,
         function_name: str = "",
         score: int = 0,
+        prompt_id: Union[int, None] = None,
     ):
         return await autil_log_request(
             self.api_key,
@@ -498,6 +501,7 @@ class AsyncPromptLayer(PromptLayerMixin):
             price=price,
             function_name=function_name,
             score=score,
+            prompt_id=prompt_id,
         )
 
     async def _create_track_request_callable(
@@ -600,6 +604,7 @@ class AsyncPromptLayer(PromptLayerMixin):
                 response,
                 track_request_callable,
                 llm_data["stream_function"],
+                llm_data["prompt_blueprint"]["metadata"],
             )
 
         request_log = await self._track_request_log(

promptlayer/promptlayer_mixins.py

@@ -10,32 +10,34 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.semconv.resource import ResourceAttributes
 
 from promptlayer.span_exporter import PromptLayerSpanExporter
-from promptlayer.utils import (
-    aanthropic_request,
+from promptlayer.streaming import (
     aanthropic_stream_completion,
     aanthropic_stream_message,
-    aazure_openai_request,
-    agoogle_request,
     agoogle_stream_chat,
     agoogle_stream_completion,
-    amistral_request,
     amistral_stream_chat,
-    anthropic_request,
     anthropic_stream_completion,
     anthropic_stream_message,
-    aopenai_request,
     aopenai_stream_chat,
     aopenai_stream_completion,
-    avertexai_request,
-    azure_openai_request,
-    google_request,
     google_stream_chat,
     google_stream_completion,
-    mistral_request,
     mistral_stream_chat,
-    openai_request,
     openai_stream_chat,
     openai_stream_completion,
+)
+from promptlayer.utils import (
+    aanthropic_request,
+    aazure_openai_request,
+    agoogle_request,
+    amistral_request,
+    anthropic_request,
+    aopenai_request,
+    avertexai_request,
+    azure_openai_request,
+    google_request,
+    mistral_request,
+    openai_request,
     vertexai_request,
 )
 

promptlayer/streaming/__init__.py

@@ -0,0 +1,54 @@
+"""
+Streaming prompt blueprint support for PromptLayer
+
+This module provides comprehensive streaming support for building prompt blueprints
+from various LLM providers during streaming responses.
+"""
+
+from .blueprint_builder import (
+    build_prompt_blueprint_from_anthropic_event,
+    build_prompt_blueprint_from_google_event,
+    build_prompt_blueprint_from_openai_chunk,
+)
+from .response_handlers import (
+    aanthropic_stream_completion,
+    aanthropic_stream_message,
+    agoogle_stream_chat,
+    agoogle_stream_completion,
+    amistral_stream_chat,
+    anthropic_stream_completion,
+    anthropic_stream_message,
+    aopenai_stream_chat,
+    aopenai_stream_completion,
+    google_stream_chat,
+    google_stream_completion,
+    mistral_stream_chat,
+    openai_stream_chat,
+    openai_stream_completion,
+)
+from .stream_processor import (
+    astream_response,
+    stream_response,
+)
+
+__all__ = [
+    "build_prompt_blueprint_from_google_event",
+    "build_prompt_blueprint_from_openai_chunk",
+    "build_prompt_blueprint_from_anthropic_event",
+    "stream_response",
+    "astream_response",
+    "openai_stream_chat",
+    "aopenai_stream_chat",
+    "anthropic_stream_message",
+    "aanthropic_stream_message",
+    "openai_stream_completion",
+    "aopenai_stream_completion",
+    "anthropic_stream_completion",
+    "aanthropic_stream_completion",
+    "google_stream_chat",
+    "google_stream_completion",
+    "agoogle_stream_chat",
+    "agoogle_stream_completion",
+    "mistral_stream_chat",
+    "amistral_stream_chat",
+]

promptlayer/streaming/blueprint_builder.py

@@ -0,0 +1,139 @@
+"""
+Blueprint builders for various LLM providers
+
+This module contains functions to build prompt blueprints from LLM responses
+and streaming events for different providers (OpenAI, Anthropic, etc.)
+"""
+
+from typing import Any, Dict, List, Optional
+
+
+def _create_tool_call(tool_id: str, function_name: str, arguments: Any) -> Dict[str, Any]:
+    """Create a standardized tool call structure"""
+    return {"id": tool_id, "type": "function", "function": {"name": function_name, "arguments": arguments}}
+
+
+def _create_content_item(content_type: str, **kwargs) -> Dict[str, Any]:
+    """Create a standardized content item"""
+    content_item = {"type": content_type}
+    content_item.update(kwargs)
+    return content_item
+
+
+def _build_assistant_message(
+    content: List[Dict], tool_calls: Optional[List[Dict]] = None, template_format: str = "f-string"
+) -> Dict[str, Any]:
+    """Build a standardized assistant message structure"""
+    message = {"role": "assistant", "content": content, "input_variables": [], "template_format": template_format}
+
+    if tool_calls:
+        message["tool_calls"] = tool_calls
+
+    return message
+
+
+def _build_prompt_blueprint(assistant_message: Dict[str, Any], metadata: Any) -> Dict[str, Any]:
+    """Build a standardized prompt blueprint structure"""
+    prompt_template = {"type": "chat", "messages": [assistant_message], "input_variables": []}
+
+    blueprint = {"prompt_template": prompt_template, "metadata": metadata}
+
+    return blueprint
+
+
+def build_prompt_blueprint_from_openai_chunk(chunk, metadata):
+    """Build a prompt blueprint from an OpenAI chat completion chunk"""
+
+    assistant_content = []
+    tool_calls = []
+
+    if hasattr(chunk, "choices") and len(chunk.choices) > 0:
+        delta = chunk.choices[0].delta
+
+        if hasattr(delta, "content") and delta.content:
+            assistant_content.append(_create_content_item("text", text=delta.content))
+
+        if hasattr(delta, "tool_calls") and delta.tool_calls:
+            for tool_call in delta.tool_calls:
+                tool_calls.append(
+                    _create_tool_call(
+                        getattr(tool_call, "id", ""),
+                        getattr(tool_call.function, "name", "") if tool_call.function else "",
+                        getattr(tool_call.function, "arguments", "") if tool_call.function else "",
+                    )
+                )
+
+    assistant_message = _build_assistant_message(assistant_content, tool_calls or None)
+    return _build_prompt_blueprint(assistant_message, metadata)
+
+
+def build_prompt_blueprint_from_anthropic_event(event, metadata):
+    """Build a prompt blueprint from an Anthropic stream event"""
+
+    assistant_content = []
+    tool_calls = []
+
+    if hasattr(event, "type"):
+        if event.type == "content_block_start" and hasattr(event, "content_block"):
+            if event.content_block.type == "thinking":
+                assistant_content.append(_create_content_item("thinking", thinking="", signature=None))
+            elif event.content_block.type == "text":
+                assistant_content.append(_create_content_item("text", text=""))
+            elif event.content_block.type == "tool_use":
+                tool_calls.append(
+                    _create_tool_call(
+                        getattr(event.content_block, "id", ""),
+                        getattr(event.content_block, "name", ""),
+                        getattr(event.content_block, "input", ""),
+                    )
+                )
+        elif event.type == "content_block_delta" and hasattr(event, "delta"):
+            if hasattr(event.delta, "text"):
+                assistant_content.append(_create_content_item("text", text=event.delta.text))
+            elif hasattr(event.delta, "thinking"):
+                assistant_content.append(
+                    _create_content_item(
+                        "thinking", thinking=event.delta.thinking, signature=getattr(event.delta, "signature", None)
+                    )
+                )
+            elif hasattr(event.delta, "partial_json"):
+                tool_calls.append(
+                    _create_tool_call(
+                        getattr(event.delta, "id", ""),
+                        getattr(event.delta, "name", ""),
+                        getattr(event.delta, "input", event.delta.partial_json),
+                    )
+                )
+
+    assistant_message = _build_assistant_message(assistant_content, tool_calls or None)
+    return _build_prompt_blueprint(assistant_message, metadata)
+
+
+def build_prompt_blueprint_from_google_event(event, metadata):
+    """
+    Build a prompt blueprint from a Google (Gemini) streaming event (raw dict or GenerateContentResponse).
+    """
+    assistant_content = []
+    tool_calls = []
+    candidate = event.candidates[0]
+
+    if candidate and hasattr(candidate, "content") and candidate.content and hasattr(candidate.content, "parts"):
+        for part in candidate.content.parts:
+            # "thought" is a boolean attribute on Part for Gemini
+            if hasattr(part, "thought") and part.thought is True:
+                assistant_content.append(
+                    _create_content_item("thinking", thinking=getattr(part, "text", ""), signature=None)
+                )
+            elif hasattr(part, "text") and part.text:
+                assistant_content.append(_create_content_item("text", text=part.text))
+            elif hasattr(part, "function_call"):
+                tool_calls.append(
+                    _create_tool_call(
+                        getattr(part.function_call, "id", ""),
+                        getattr(part.function_call, "name", ""),
+                        getattr(part.function_call, "args", {}),
+                    )
+                )
+
+    assistant_message = _build_assistant_message(assistant_content, tool_calls or None, template_format="f-string")
+    return _build_prompt_blueprint(assistant_message, metadata)