promptlayer 1.0.67__tar.gz → 1.0.69__tar.gz

{promptlayer-1.0.67 → promptlayer-1.0.69}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: promptlayer
-Version: 1.0.67
+Version: 1.0.69
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
+License-File: LICENSE
 Author: Magniv
 Author-email: hello@magniv.io
 Requires-Python: >=3.9,<4.0
@@ -13,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: ably (>=2.0.11,<3.0.0)
 Requires-Dist: aiohttp (>=3.10.10,<4.0.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/__init__.py

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

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/promptlayer.py

@@ -599,10 +599,10 @@ class AsyncPromptLayer(PromptLayerMixin):
             function_kwargs=llm_data["function_kwargs"],
         )
 
-        if isinstance(response, dict):
-            request_response = response
-        else:
+        if hasattr(response, "model_dump"):
             request_response = response.model_dump(mode="json")
+        else:
+            request_response = response
 
         if stream:
             track_request_callable = await self._create_track_request_callable(

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/promptlayer_mixins.py

@@ -19,12 +19,14 @@ from promptlayer.streaming import (
     amistral_stream_chat,
     anthropic_stream_completion,
     anthropic_stream_message,
+    aopenai_responses_stream_chat,
     aopenai_stream_chat,
     aopenai_stream_completion,
     bedrock_stream_message,
     google_stream_chat,
     google_stream_completion,
     mistral_stream_chat,
+    openai_responses_stream_chat,
     openai_stream_chat,
     openai_stream_completion,
 )
@@ -48,7 +50,7 @@ from promptlayer.utils import (
 )
 
 MAP_PROVIDER_TO_FUNCTION_NAME = {
-    "openai": {
+    "openai:chat-completions": {
         "chat": {
             "function_name": "openai.chat.completions.create",
             "stream_function": openai_stream_chat,
@@ -58,6 +60,16 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": openai_stream_completion,
         },
     },
+    "openai:responses": {
+        "chat": {
+            "function_name": "openai.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+    },
     "anthropic": {
         "chat": {
             "function_name": "anthropic.messages.create",
@@ -68,7 +80,7 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": anthropic_stream_completion,
         },
     },
-    "openai.azure": {
+    "openai.azure:chat-completions": {
         "chat": {
             "function_name": "openai.AzureOpenAI.chat.completions.create",
             "stream_function": openai_stream_chat,
@@ -78,6 +90,16 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": openai_stream_completion,
         },
     },
+    "openai.azure:responses": {
+        "chat": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+    },
     "mistral": {
         "chat": {
             "function_name": "mistral.client.chat",
@@ -133,7 +155,7 @@ MAP_PROVIDER_TO_FUNCTION = {
 }
 
 AMAP_PROVIDER_TO_FUNCTION_NAME = {
-    "openai": {
+    "openai:chat-completions": {
         "chat": {
             "function_name": "openai.chat.completions.create",
             "stream_function": aopenai_stream_chat,
@@ -143,6 +165,16 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": aopenai_stream_completion,
         },
     },
+    "openai:responses": {
+        "chat": {
+            "function_name": "openai.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+    },
     "anthropic": {
         "chat": {
             "function_name": "anthropic.messages.create",
@@ -153,7 +185,7 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": aanthropic_stream_completion,
         },
     },
-    "openai.azure": {
+    "openai.azure:chat-completions": {
         "chat": {
             "function_name": "openai.AzureOpenAI.chat.completions.create",
             "stream_function": aopenai_stream_chat,
@@ -163,6 +195,16 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": aopenai_stream_completion,
         },
     },
+    "openai.azure:responses": {
+        "chat": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+    },
     "mistral": {
         "chat": {
             "function_name": "mistral.client.chat",
@@ -275,6 +317,7 @@ class PromptLayerMixin:
         function_kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
         function_kwargs["stream"] = stream
         provider = prompt_blueprint_model["provider"]
+        api_type = prompt_blueprint_model["api_type"]
 
         if custom_provider := prompt_blueprint.get("custom_provider"):
             provider = custom_provider["client"]
@@ -285,7 +328,7 @@ class PromptLayerMixin:
         elif provider_base_url := prompt_blueprint.get("provider_base_url"):
             client_kwargs["base_url"] = provider_base_url["url"]
 
-        if stream and provider in ["openai", "openai.azure"]:
+        if stream and provider in ["openai", "openai.azure"] and api_type == "chat-completions":
             function_kwargs["stream_options"] = {"include_usage": True}
 
         provider_function_name = provider
@@ -295,6 +338,9 @@ class PromptLayerMixin:
             elif "claude" in prompt_blueprint_model["name"]:
                 provider_function_name = "anthropic"
 
+        if provider_function_name in ("openai", "openai.azure"):
+            provider_function_name = f"{provider_function_name}:{api_type}"
+
         if is_async:
             config = AMAP_PROVIDER_TO_FUNCTION_NAME[provider_function_name][prompt_template["type"]]
             request_function = AMAP_PROVIDER_TO_FUNCTION[provider]

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/streaming/__init__.py

@@ -9,6 +9,7 @@ from .blueprint_builder import (
     build_prompt_blueprint_from_anthropic_event,
     build_prompt_blueprint_from_google_event,
     build_prompt_blueprint_from_openai_chunk,
+    build_prompt_blueprint_from_openai_responses_event,
 )
 from .response_handlers import (
     aanthropic_stream_completion,
@@ -19,12 +20,14 @@ from .response_handlers import (
     amistral_stream_chat,
     anthropic_stream_completion,
     anthropic_stream_message,
+    aopenai_responses_stream_chat,
     aopenai_stream_chat,
     aopenai_stream_completion,
     bedrock_stream_message,
     google_stream_chat,
     google_stream_completion,
     mistral_stream_chat,
+    openai_responses_stream_chat,
     openai_stream_chat,
     openai_stream_completion,
 )
@@ -34,13 +37,16 @@ from .stream_processor import (
 )
 
 __all__ = [
+    "build_prompt_blueprint_from_anthropic_event",
     "build_prompt_blueprint_from_google_event",
     "build_prompt_blueprint_from_openai_chunk",
-    "build_prompt_blueprint_from_anthropic_event",
+    "build_prompt_blueprint_from_openai_responses_event",
     "stream_response",
     "astream_response",
     "openai_stream_chat",
     "aopenai_stream_chat",
+    "openai_responses_stream_chat",
+    "aopenai_responses_stream_chat",
     "anthropic_stream_message",
     "aanthropic_stream_message",
     "openai_stream_completion",

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/streaming/blueprint_builder.py

@@ -8,14 +8,19 @@ 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]:
+def _create_tool_call(call_id: str, function_name: str, arguments: Any, tool_id: str = None) -> Dict[str, Any]:
     """Create a standardized tool call structure"""
-    return {"id": tool_id, "type": "function", "function": {"name": function_name, "arguments": arguments}}
+    tool_call = {"id": call_id, "type": "function", "function": {"name": function_name, "arguments": arguments}}
+    if tool_id:
+        tool_call["tool_id"] = tool_id
+    return tool_call
 
 
-def _create_content_item(content_type: str, **kwargs) -> Dict[str, Any]:
+def _create_content_item(content_type: str, item_id: str = None, **kwargs) -> Dict[str, Any]:
     """Create a standardized content item"""
     content_item = {"type": content_type}
+    if item_id:
+        content_item["id"] = item_id
     content_item.update(kwargs)
     return content_item
 
@@ -67,6 +72,127 @@ def build_prompt_blueprint_from_openai_chunk(chunk, metadata):
     return _build_prompt_blueprint(assistant_message, metadata)
 
 
+def build_prompt_blueprint_from_openai_responses_event(event, metadata):
+    """Build a prompt blueprint from an OpenAI responses event"""
+
+    assistant_content = []
+    tool_calls = []
+
+    event_dict = event.model_dump() if hasattr(event, "model_dump") else event
+    event_type = event_dict.get("type")
+
+    if event_type == "response.reasoning_summary_text.delta":
+        delta = event_dict.get("delta", "")
+        item_id = event_dict.get("item_id")
+        if delta:
+            assistant_content.append(_create_content_item("thinking", item_id=item_id, thinking=delta, signature=None))
+
+    elif event_type == "response.reasoning_summary_text.done":
+        final_text = event_dict.get("text", "")
+        item_id = event_dict.get("item_id")
+        if final_text:
+            assistant_content.append(
+                _create_content_item("thinking", item_id=item_id, thinking=final_text, signature=None)
+            )
+
+    elif event_type == "response.reasoning_summary_part.added":
+        part = event_dict.get("part", {})
+        item_id = event_dict.get("item_id")
+        if part.get("type") == "summary_text":
+            text = part.get("text", "")
+            assistant_content.append(_create_content_item("thinking", item_id=item_id, thinking=text, signature=None))
+
+    elif event_type == "response.reasoning_summary_part.done":
+        part = event_dict.get("part", {})
+        item_id = event_dict.get("item_id")
+        if part.get("type") == "summary_text":
+            text = part.get("text", "")
+            if text:
+                assistant_content.append(
+                    _create_content_item("thinking", item_id=item_id, thinking=text, signature=None)
+                )
+
+    elif event_type == "response.function_call_arguments.delta":
+        item_id = event_dict.get("item_id")
+        delta = event_dict.get("delta", "")
+        if delta:
+            tool_calls.append(_create_tool_call("", "", delta, tool_id=item_id))
+
+    elif event_type == "response.function_call_arguments.done":
+        item_id = event_dict.get("item_id")
+        final_arguments = event_dict.get("arguments", "")
+        if final_arguments:
+            tool_calls.append(_create_tool_call("", "", final_arguments, tool_id=item_id))
+
+    elif event_type == "response.output_item.added":
+        item = event_dict.get("item", {})
+        item_type = item.get("type")
+        item_id = item.get("id")
+
+        if item_type == "reasoning":
+            assistant_content.append(_create_content_item("thinking", item_id=item_id, thinking="", signature=None))
+        elif item_type == "function_call":
+            tool_calls.append(_create_tool_call(item.get("call_id", ""), item.get("name", ""), "", tool_id=item_id))
+        elif item_type == "message":
+            assistant_content.append(_create_content_item("text", item_id=item_id, text="[Message started]"))
+
+    elif event_type == "response.content_part.added":
+        item_id = event_dict.get("item_id")
+        part = event_dict.get("part", {})
+        part_type = part.get("type", "output_text")
+
+        if part_type == "output_text":
+            text = part.get("text", "")
+            assistant_content.append(
+                _create_content_item("text", item_id=item_id, text=text if text else "[Content part added]")
+            )
+
+    elif event_type == "response.output_text.delta":
+        item_id = event_dict.get("item_id")
+        delta_text = event_dict.get("delta", "")
+        if delta_text:
+            assistant_content.append(_create_content_item("text", item_id=item_id, text=delta_text))
+
+    elif event_type == "response.output_text.done":
+        item_id = event_dict.get("item_id")
+        final_text = event_dict.get("text", "")
+        if final_text:
+            assistant_content.append(_create_content_item("text", item_id=item_id, text=final_text))
+
+    elif event_type == "response.output_item.done":
+        item = event_dict.get("item", {})
+        item_type = item.get("type")
+        item_id = item.get("id")
+
+        if item_type == "reasoning":
+            summary = item.get("summary", [])
+            for summary_part in summary:
+                if summary_part.get("type") == "summary_text":
+                    text = summary_part.get("text", "")
+                    if text:
+                        assistant_content.append(
+                            _create_content_item("thinking", item_id=item_id, thinking=text, signature=None)
+                        )
+
+        elif item_type == "function_call":
+            tool_calls.append(
+                _create_tool_call(
+                    item.get("call_id", ""), item.get("name", ""), item.get("arguments", ""), tool_id=item_id
+                )
+            )
+
+        elif item_type == "message":
+            content = item.get("content", [])
+            for content_part in content:
+                if content_part.get("type") == "output_text":
+                    text = content_part.get("text", "")
+                    if text:
+                        assistant_content.append(_create_content_item("text", item_id=item_id, text=text))
+
+    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"""
 

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/streaming/response_handlers.py

@@ -155,6 +155,262 @@ async def aopenai_stream_chat(generator: AsyncIterable[Any]) -> Any:
     return response
 
 
+def _initialize_openai_response_data():
+    """Initialize the response data structure for OpenAI responses"""
+    return {
+        "id": None,
+        "object": "response",
+        "created_at": None,
+        "status": None,
+        "error": None,
+        "incomplete_details": None,
+        "instructions": None,
+        "max_output_tokens": None,
+        "model": None,
+        "output": [],
+        "parallel_tool_calls": True,
+        "previous_response_id": None,
+        "reasoning": {"effort": None, "summary": None},
+        "store": True,
+        "temperature": 1,
+        "text": {"format": {"type": "text"}},
+        "tool_choice": "auto",
+        "tools": [],
+        "top_p": 1,
+        "truncation": "disabled",
+        "usage": None,
+        "user": None,
+        "metadata": {},
+    }
+
+
+def _process_openai_response_event(chunk_dict, response_data, current_items):
+    """Process a single OpenAI response event and update the response data"""
+    event_type = chunk_dict.get("type")
+    has_reasoning = False
+
+    if event_type == "response.created":
+        response_info = chunk_dict.get("response", {})
+        response_data["id"] = response_info.get("id")
+        response_data["created_at"] = response_info.get("created_at")
+        response_data["model"] = response_info.get("model")
+        response_data["status"] = response_info.get("status")
+        response_data["parallel_tool_calls"] = response_info.get("parallel_tool_calls", True)
+        response_data["temperature"] = response_info.get("temperature", 1)
+        response_data["tool_choice"] = response_info.get("tool_choice", "auto")
+        response_data["tools"] = response_info.get("tools", [])
+        response_data["top_p"] = response_info.get("top_p", 1)
+        response_data["truncation"] = response_info.get("truncation", "disabled")
+        response_data["max_output_tokens"] = response_info.get("max_output_tokens")
+        response_data["previous_response_id"] = response_info.get("previous_response_id")
+        response_data["store"] = response_info.get("store", True)
+        response_data["user"] = response_info.get("user")
+        response_data["metadata"] = response_info.get("metadata", {})
+
+        text_config = response_info.get("text", {})
+        if text_config:
+            response_data["text"] = text_config
+
+        reasoning = response_info.get("reasoning", {})
+        if reasoning:
+            response_data["reasoning"] = reasoning
+            has_reasoning = True
+
+    elif event_type == "response.in_progress":
+        response_info = chunk_dict.get("response", {})
+        response_data["status"] = response_info.get("status")
+
+    elif event_type == "response.output_item.added":
+        item = chunk_dict.get("item", {})
+        item_id = item.get("id")
+        item_type = item.get("type")
+
+        if item_type == "reasoning":
+            current_items[item_id] = {
+                "type": "reasoning",
+                "id": item_id,
+                "summary": [],
+                "status": item.get("status", "in_progress"),
+            }
+            has_reasoning = True
+
+        elif item_type == "function_call":
+            current_items[item_id] = {
+                "type": "function_call",
+                "id": item_id,
+                "call_id": item.get("call_id"),
+                "name": item.get("name"),
+                "arguments": "",
+                "status": item.get("status", "in_progress"),
+            }
+
+        elif item_type == "message":
+            current_items[item_id] = {
+                "type": "message",
+                "id": item_id,
+                "role": item.get("role", "assistant"),
+                "content": [],
+                "status": item.get("status", "in_progress"),
+            }
+
+    elif event_type == "response.reasoning_summary_part.added":
+        item_id = chunk_dict.get("item_id")
+        part = chunk_dict.get("part", {})
+
+        if item_id in current_items and current_items[item_id]["type"] == "reasoning":
+            summary_part = {"type": part.get("type", "summary_text"), "text": part.get("text", "")}
+            current_items[item_id]["summary"].append(summary_part)
+
+    elif event_type == "response.reasoning_summary_text.delta":
+        item_id = chunk_dict.get("item_id")
+        delta = chunk_dict.get("delta", "")
+        summary_index = chunk_dict.get("summary_index", 0)
+
+        if item_id in current_items and current_items[item_id]["type"] == "reasoning":
+            while len(current_items[item_id]["summary"]) <= summary_index:
+                current_items[item_id]["summary"].append({"type": "summary_text", "text": ""})
+
+            current_items[item_id]["summary"][summary_index]["text"] += delta
+
+    elif event_type == "response.reasoning_summary_text.done":
+        item_id = chunk_dict.get("item_id")
+        final_text = chunk_dict.get("text", "")
+        summary_index = chunk_dict.get("summary_index", 0)
+
+        if item_id in current_items and current_items[item_id]["type"] == "reasoning":
+            while len(current_items[item_id]["summary"]) <= summary_index:
+                current_items[item_id]["summary"].append({"type": "summary_text", "text": ""})
+
+            current_items[item_id]["summary"][summary_index]["text"] = final_text
+
+    elif event_type == "response.reasoning_summary_part.done":
+        item_id = chunk_dict.get("item_id")
+        part = chunk_dict.get("part", {})
+
+        if item_id in current_items and current_items[item_id]["type"] == "reasoning":
+            summary_index = chunk_dict.get("summary_index", 0)
+            if summary_index < len(current_items[item_id]["summary"]):
+                current_items[item_id]["summary"][summary_index] = {
+                    "type": part.get("type", "summary_text"),
+                    "text": part.get("text", ""),
+                }
+
+    elif event_type == "response.function_call_arguments.delta":
+        item_id = chunk_dict.get("item_id")
+        delta = chunk_dict.get("delta", "")
+
+        if item_id in current_items:
+            current_items[item_id]["arguments"] += delta
+
+    elif event_type == "response.function_call_arguments.done":
+        item_id = chunk_dict.get("item_id")
+        final_arguments = chunk_dict.get("arguments", "")
+
+        if item_id in current_items:
+            current_items[item_id]["arguments"] = final_arguments
+
+    elif event_type == "response.content_part.added":
+        part = chunk_dict.get("part", {})
+
+        message_item = None
+        for item in current_items.values():
+            if item.get("type") == "message":
+                message_item = item
+                break
+
+        if message_item:
+            content_part = {
+                "type": part.get("type", "output_text"),
+                "text": part.get("text", ""),
+                "annotations": part.get("annotations", []),
+            }
+            message_item["content"].append(content_part)
+
+    elif event_type == "response.output_text.delta":
+        delta_text = chunk_dict.get("delta", "")
+
+        for item in current_items.values():
+            if item.get("type") == "message" and item.get("content"):
+                if item["content"] and item["content"][-1].get("type") == "output_text":
+                    item["content"][-1]["text"] += delta_text
+                break
+
+    elif event_type == "response.output_text.done":
+        final_text = chunk_dict.get("text", "")
+
+        for item in current_items.values():
+            if item.get("type") == "message" and item.get("content"):
+                if item["content"] and item["content"][-1].get("type") == "output_text":
+                    item["content"][-1]["text"] = final_text
+                break
+
+    elif event_type == "response.output_item.done":
+        item = chunk_dict.get("item", {})
+        item_id = item.get("id")
+
+        if item_id in current_items:
+            current_items[item_id]["status"] = item.get("status", "completed")
+
+            if item.get("type") == "reasoning":
+                current_items[item_id].update({"summary": item.get("summary", current_items[item_id]["summary"])})
+            elif item.get("type") == "function_call":
+                current_items[item_id].update(
+                    {
+                        "arguments": item.get("arguments", current_items[item_id]["arguments"]),
+                        "call_id": item.get("call_id", current_items[item_id]["call_id"]),
+                        "name": item.get("name", current_items[item_id]["name"]),
+                    }
+                )
+            elif item.get("type") == "message":
+                current_items[item_id].update(
+                    {
+                        "content": item.get("content", current_items[item_id]["content"]),
+                        "role": item.get("role", current_items[item_id]["role"]),
+                    }
+                )
+
+            response_data["output"].append(current_items[item_id])
+
+    elif event_type == "response.completed":
+        response_info = chunk_dict.get("response", {})
+        response_data["status"] = response_info.get("status", "completed")
+        response_data["usage"] = response_info.get("usage")
+        response_data["output"] = response_info.get("output", response_data["output"])
+
+        if response_info.get("reasoning"):
+            response_data["reasoning"] = response_info["reasoning"]
+
+    return has_reasoning
+
+
+def openai_responses_stream_chat(results: list):
+    """Process OpenAI Responses streaming chat results and return response"""
+    from openai.types.responses import Response
+
+    response_data = _initialize_openai_response_data()
+    current_items = {}
+
+    for chunk in results:
+        chunk_dict = chunk.model_dump()
+        _process_openai_response_event(chunk_dict, response_data, current_items)
+
+    return Response(**response_data)
+
+
+async def aopenai_responses_stream_chat(generator: AsyncIterable[Any]) -> Any:
+    """Async version of openai_responses_stream_chat"""
+    from openai.types.responses import Response
+
+    response_data = _initialize_openai_response_data()
+    current_items = {}
+
+    async for chunk in generator:
+        chunk_dict = chunk.model_dump()
+        _process_openai_response_event(chunk_dict, response_data, current_items)
+
+    return Response(**response_data)
+
+
 def anthropic_stream_message(results: list):
     """Process Anthropic streaming message results and return response + blueprint"""
     from anthropic.types import Message, MessageStreamEvent, Usage

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/streaming/stream_processor.py

@@ -5,6 +5,7 @@ from .blueprint_builder import (
     build_prompt_blueprint_from_bedrock_event,
     build_prompt_blueprint_from_google_event,
     build_prompt_blueprint_from_openai_chunk,
+    build_prompt_blueprint_from_openai_responses_event,
 )
 
 
@@ -14,7 +15,11 @@ def _build_stream_blueprint(result: Any, metadata: Dict) -> Any:
     model_name = model_info.get("name", "")
 
     if provider == "openai" or provider == "openai.azure":
-        return build_prompt_blueprint_from_openai_chunk(result, metadata)
+        api_type = model_info.get("api_type", "chat-completions") if metadata else "chat-completions"
+        if api_type == "chat-completions":
+            return build_prompt_blueprint_from_openai_chunk(result, metadata)
+        elif api_type == "responses":
+            return build_prompt_blueprint_from_openai_responses_event(result, metadata)
 
     elif provider == "google" or (provider == "vertexai" and model_name.startswith("gemini")):
         return build_prompt_blueprint_from_google_event(result, metadata)

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/templates.py

@@ -20,8 +20,8 @@ class TemplateManager:
     def publish(self, body: PublishPromptTemplate):
         return publish_prompt_template(body, self.api_key)
 
-    def all(self, page: int = 1, per_page: int = 30):
-        return get_all_prompt_templates(page, per_page, self.api_key)
+    def all(self, page: int = 1, per_page: int = 30, release_label: str = None):
+        return get_all_prompt_templates(page, per_page, self.api_key, release_label)
 
 
 class AsyncTemplateManager:
@@ -31,5 +31,5 @@ class AsyncTemplateManager:
     async def get(self, prompt_name: str, params: Union[GetPromptTemplate, None] = None):
         return await aget_prompt_template(prompt_name, params, self.api_key)
 
-    async def all(self, page: int = 1, per_page: int = 30):
-        return await aget_all_prompt_templates(page, per_page, self.api_key)
+    async def all(self, page: int = 1, per_page: int = 30, release_label: str = None):
+        return await aget_all_prompt_templates(page, per_page, self.api_key, release_label)

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/types/prompt_template.py

@@ -21,12 +21,14 @@ class ImageUrl(TypedDict, total=False):
 class TextContent(TypedDict, total=False):
     type: Literal["text"]
     text: str
+    id: Union[str, None]
 
 
 class ThinkingContent(TypedDict, total=False):
     signature: Union[str, None]
     type: Literal["thinking"]
     thinking: str
+    id: Union[str, None]
 
 
 class ImageContent(TypedDict, total=False):
@@ -87,6 +89,7 @@ class UserMessage(TypedDict, total=False):
 
 class ToolCall(TypedDict, total=False):
     id: str
+    tool_id: Union[str, None]
     type: Literal["function"]
     function: FunctionCall
 

{promptlayer-1.0.67 → promptlayer-1.0.69}/promptlayer/utils.py

@@ -1193,13 +1193,16 @@ async def apublish_prompt_template(
 
 
 def get_all_prompt_templates(
-    page: int = 1, per_page: int = 30, api_key: str = None
+    page: int = 1, per_page: int = 30, api_key: str = None, release_label: str = None
 ) -> List[ListPromptTemplateResponse]:
     try:
+        params = {"page": page, "per_page": per_page}
+        if release_label:
+            params["release_label"] = release_label
         response = requests.get(
             f"{URL_API_PROMPTLAYER}/prompt-templates",
             headers={"X-API-KEY": api_key},
-            params={"page": page, "per_page": per_page},
+            params=params,
         )
         if response.status_code != 200:
             raise Exception(
@@ -1212,14 +1215,17 @@ def get_all_prompt_templates(
 
 
 async def aget_all_prompt_templates(
-    page: int = 1, per_page: int = 30, api_key: str = None
+    page: int = 1, per_page: int = 30, api_key: str = None, release_label: str = None
 ) -> List[ListPromptTemplateResponse]:
     try:
+        params = {"page": page, "per_page": per_page}
+        if release_label:
+            params["release_label"] = release_label
         async with _make_httpx_client() as client:
             response = await client.get(
                 f"{URL_API_PROMPTLAYER}/prompt-templates",
                 headers={"X-API-KEY": api_key},
-                params={"page": page, "per_page": per_page},
+                params=params,
             )
 
         if RAISE_FOR_STATUS:
@@ -1253,8 +1259,13 @@ def openai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: d
     from openai import OpenAI
 
     client = OpenAI(**client_kwargs)
-    request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **function_kwargs)
+    api_type = prompt_blueprint["metadata"]["model"]["api_type"]
+
+    if api_type == "chat-completions":
+        request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
+        return request_to_make(client, **function_kwargs)
+    else:
+        return client.responses.create(**function_kwargs)
 
 
 async def aopenai_chat_request(client, **kwargs):
@@ -1275,16 +1286,26 @@ async def aopenai_request(prompt_blueprint: GetPromptTemplateResponse, client_kw
     from openai import AsyncOpenAI
 
     client = AsyncOpenAI(**client_kwargs)
-    request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return await request_to_make(client, **function_kwargs)
+    api_type = prompt_blueprint["metadata"]["model"]["api_type"]
+
+    if api_type == "chat-completions":
+        request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
+        return await request_to_make(client, **function_kwargs)
+    else:
+        return await client.responses.create(**function_kwargs)
 
 
 def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import AzureOpenAI
 
     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, **function_kwargs)
+    api_type = prompt_blueprint["metadata"]["model"]["api_type"]
+
+    if api_type == "chat-completions":
+        request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
+        return request_to_make(client, **function_kwargs)
+    else:
+        return client.responses.create(**function_kwargs)
 
 
 async def aazure_openai_request(
@@ -1293,8 +1314,13 @@ async def aazure_openai_request(
     from openai import AsyncAzureOpenAI
 
     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, **function_kwargs)
+    api_type = prompt_blueprint["metadata"]["model"]["api_type"]
+
+    if api_type == "chat-completions":
+        request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
+        return await request_to_make(client, **function_kwargs)
+    else:
+        return await client.responses.create(**function_kwargs)
 
 
 def anthropic_chat_request(client, **kwargs):

{promptlayer-1.0.67 → promptlayer-1.0.69}/pyproject.toml

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