prompty 1.0.0a1__tar.gz → 1.0.0b1__tar.gz

{prompty-1.0.0a1 → prompty-1.0.0b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompty
-Version: 1.0.0a1
+Version: 1.0.0b1
 Summary: Prompty is a new asset class and format for LLM prompts that aims to provide observability, understandability, and portability for developers. It includes spec, tooling, and a runtime. This Prompty runtime supports Python
 Author-email: Seth Juarez <seth.juarez@microsoft.com>
 Requires-Python: >=3.9

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/__init__.py

@@ -482,7 +482,7 @@ async def run_async(
 
 @trace(description="Execute a prompty")
 def execute(
-    prompt: Union[str, Prompty],
+    prompt: Union[str, Path, Prompty],
     connection: dict[str, typing.Any] = {},
     options: dict[str, typing.Any] = {},
     inputs: dict[str, typing.Any] = {},
@@ -525,7 +525,7 @@ def execute(
             # get caller's path (take into account trace frame)
             caller = Path(traceback.extract_stack()[-3].filename)
             path = Path(caller.parent / path).resolve().absolute()
-        prompt = load(path, config_name)
+        prompt = load(str(path), config_name)
 
     # prepare content
     content = prepare(prompt, inputs, merge_sample)
@@ -538,7 +538,7 @@ def execute(
 
 @trace(description="Execute a prompty")
 async def execute_async(
-    prompt: Union[str, Prompty],
+    prompt: Union[str, Path, Prompty],
     connection: dict[str, typing.Any] = {},
     options: dict[str, typing.Any] = {},
     inputs: dict[str, typing.Any] = {},
@@ -581,7 +581,7 @@ async def execute_async(
             # get caller's path (take into account trace frame)
             caller = Path(traceback.extract_stack()[-3].filename)
             path = Path(caller.parent / path).resolve().absolute()
-        prompt = await load_async(path, config_name)
+        prompt = await load_async(str(path), config_name)
 
     # prepare content
     content = await prepare_async(prompt, inputs, merge_sample)

prompty-1.0.0b1/prompty/_version.py

@@ -0,0 +1 @@
+VERSION = "1.0.0b1"

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/azure/executor.py

@@ -1,16 +1,17 @@
+import inspect
 import json
 import typing
 from collections.abc import AsyncIterator, Iterator
 
 import azure.identity
-from openai import APIResponse, AsyncAzureOpenAI, AzureOpenAI
+from openai import AsyncAzureOpenAI, AzureOpenAI
 from openai.types.chat.chat_completion import ChatCompletion
 
 from prompty.tracer import Tracer
 
 from .._version import VERSION
 from ..common import convert_function_tools, convert_output_props
-from ..core import AsyncPromptyStream, Prompty, PromptyStream
+from ..core import AsyncPromptyStream, InputProperty, Prompty, PromptyStream, ToolProperty
 from ..invoker import Invoker, InvokerFactory
 
 
@@ -146,6 +147,22 @@ class AzureOpenAIExecutor(Invoker):
 
         return args
 
+    def _execute_chat_completion(self, client: AzureOpenAI, args: dict, trace) -> typing.Any:
+        if "stream" in args and args["stream"]:
+            response = client.chat.completions.create(**args)
+        else:
+            raw = client.chat.completions.with_raw_response.create(**args)
+
+            response = ChatCompletion.model_validate_json(raw.text)
+
+            for k, v in raw.headers.raw:
+                trace(k.decode("utf-8"), v.decode("utf-8"))
+
+            trace("request_id", raw.request_id)
+            trace("retries_taken", raw.retries_taken)
+
+        return response
+
     def _create_chat(self, client: AzureOpenAI, data: typing.Any, ignore_thread_content=False) -> typing.Any:
         with Tracer.start("create") as trace:
             trace("type", "LLM")
@@ -153,20 +170,25 @@ class AzureOpenAIExecutor(Invoker):
             trace("signature", "AzureOpenAI.chat.completions.create")
             args = self._resolve_chat_args(data, ignore_thread_content)
             trace("inputs", args)
-            if "stream" in args and args["stream"]:
-                response = client.chat.completions.create(**args)
-            else:
-                raw = client.chat.completions.with_raw_response.create(**args)
+            response = self._execute_chat_completion(client, args, trace)
+            trace("result", response)
+            return response
 
-                response = ChatCompletion.model_validate_json(raw.text)
+    async def _execute_chat_completion_async(self, client: AsyncAzureOpenAI, args: dict, trace) -> typing.Any:
+        if "stream" in args and args["stream"]:
+            response = await client.chat.completions.create(**args)
+        else:
+            raw = await client.chat.completions.with_raw_response.create(**args)
 
-                for k, v in raw.headers.raw:
-                    trace(k.decode("utf-8"), v.decode("utf-8"))
+            response = ChatCompletion.model_validate_json(raw.text)
 
-                trace("request_id", raw.request_id)
-                trace("retries_taken", raw.retries_taken)
-            trace("result", response)
-            return response
+            for k, v in raw.headers.raw:
+                trace(k.decode("utf-8"), v.decode("utf-8"))
+
+            trace("request_id", raw.request_id)
+            trace("retries_taken", raw.retries_taken)
+
+        return response
 
     async def _create_chat_async(
         self, client: AsyncAzureOpenAI, data: typing.Any, ignore_thread_content=False
@@ -178,82 +200,130 @@ class AzureOpenAIExecutor(Invoker):
             trace("signature", "AzureOpenAIAsync.chat.completions.create")
             args = self._resolve_chat_args(data, ignore_thread_content)
             trace("inputs", args)
-            if "stream" in args and args["stream"]:
-                response = await client.chat.completions.create(**args)
-            else:
-                raw: APIResponse = await client.chat.completions.with_raw_response.create(**args)
-                if raw is not None and raw.text is not None and isinstance(raw.text, str):
-                    response = ChatCompletion.model_validate_json(raw.text)
-
-                for k, v in raw.headers.raw:
-                    trace(k.decode("utf-8"), v.decode("utf-8"))
-
-                trace("request_id", raw.request_id)
-                trace("retries_taken", raw.retries_taken)
+            response = await self._execute_chat_completion_async(client, args, trace)
             trace("result", response)
 
             return response
 
+    def _get_thread(self) -> InputProperty:
+        thread = self.prompty.get_input("thread")
+        if thread is None:
+            raise ValueError("thread requires thread input")
+
+        return thread
+
+    def _retrieve_tool(self, tool_name: str) -> ToolProperty:
+        tool = self.prompty.get_tool(tool_name)
+        if tool is None:
+            raise ValueError(f"Tool {tool_name} does not exist")
+
+        if tool.type != "function":
+            raise ValueError(f"Server tool ({tool_name}) is currently not supported")
+
+        if tool.value is None:
+            raise ValueError(f"Tool {tool_name} has not been initialized")
+
+        return tool
+
     def _execute_agent(self, client: AzureOpenAI, data: typing.Any) -> typing.Any:
         with Tracer.start("create") as trace:
             trace("type", "LLM")
             trace("description", "Azure OpenAI Client")
-
             trace("signature", "AzureOpenAI.chat.agent.create")
+
             trace("inputs", data)
 
             response = self._create_chat(client, data)
-            if isinstance(response, ChatCompletion):
-                message = response.choices[0].message
-                if message.tool_calls:
-                    thread = self.prompty.get_input("thread")
-                    if thread is None:
-                        raise ValueError("thread requires thread input")
 
-                    thread.value.append(
-                        {
-                            "role": "assistant",
-                            "tool_calls": [t.model_dump() for t in message.tool_calls],
-                        }
-                    )
+            # execute tool calls if any (until no more tool calls)
+            while (
+                isinstance(response, ChatCompletion)
+                and response.choices[0].finish_reason == "tool_calls"
+                and response.choices[0].message.tool_calls is not None
+                and len(response.choices[0].message.tool_calls) > 0
+            ):
+
+                tool_calls = response.choices[0].message.tool_calls
+                thread = self._get_thread()
+                thread.value.append(
+                    {
+                        "role": "assistant",
+                        "tool_calls": [t.model_dump() for t in tool_calls],
+                    }
+                )
 
-                    for tool_call in message.tool_calls:
-                        tool = self.prompty.get_tool(tool_call.function.name)
-                        if tool is None:
-                            raise ValueError(f"Tool {tool_call.function.name} does not exist")
+                for tool_call in tool_calls:
+                    tool = self._retrieve_tool(tool_call.function.name)
+                    function_args = json.loads(tool_call.function.arguments)
 
-                        function_args = json.loads(tool_call.function.arguments)
+                    if inspect.iscoroutinefunction(tool.value):
+                        raise ValueError("Cannot execute async tool in sync mode")
 
-                        if tool.value is None:
-                            raise ValueError(f"Tool {tool_call.function.name} does not have a value")
+                    r = tool.value(**function_args)
 
-                        r = tool.value(**function_args)
+                    thread.value.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "name": tool_call.function.name,
+                            "content": r,
+                        }
+                    )
 
-                        thread.value.append(
-                            {
-                                "role": "tool",
-                                "tool_call_id": tool_call.id,
-                                "name": tool_call.function.name,
-                                "content": r,
-                            }
-                        )
-                else:
-                    trace("result", response)
-                    return response
+                response = self._create_chat(client, data, True)
 
-            response = self._create_chat(client, data, True)
             trace("result", response)
-
             return response
 
     async def _execute_agent_async(self, client: AsyncAzureOpenAI, data: typing.Any) -> typing.Any:
         with Tracer.start("create") as trace:
             trace("type", "LLM")
             trace("description", "Azure OpenAI Client")
-            trace("signature", "AzureOpenAI.chat.agent.create")
-            args = self._resolve_chat_args(data)
-            trace("inputs", args)
-            response = 5
+            trace("signature", "AzureOpenAIAsync.chat.agent.create")
+
+            trace("inputs", data)
+
+            response = await self._create_chat_async(client, data)
+
+            # execute tool calls if any (until no more tool calls)
+            while (
+                isinstance(response, ChatCompletion)
+                and response.choices[0].finish_reason == "tool_calls"
+                and response.choices[0].message.tool_calls is not None
+                and len(response.choices[0].message.tool_calls) > 0
+            ):
+
+                tool_calls = response.choices[0].message.tool_calls
+                thread = self._get_thread()
+                thread.value.append(
+                    {
+                        "role": "assistant",
+                        "tool_calls": [t.model_dump() for t in tool_calls],
+                    }
+                )
+
+                for tool_call in tool_calls:
+                    tool = self._retrieve_tool(tool_call.function.name)
+                    function_args = json.loads(tool_call.function.arguments)
+
+                    if inspect.iscoroutinefunction(tool.value):
+                        # if the tool is async, we need to await it
+                        r = await tool.value(**function_args)
+                    else:
+                        # if the tool is not async, we can call it directly
+                        r = tool.value(**function_args)
+
+                    thread.value.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "name": tool_call.function.name,
+                            "content": r,
+                        }
+                    )
+
+                response = await self._create_chat_async(client, data, True)
+
             trace("result", response)
             return response
 
@@ -358,7 +428,7 @@ class AzureOpenAIExecutor(Invoker):
 
             return response
 
-    def invoke(self, data: typing.Any) -> typing.Union[str, PromptyStream]:
+    def invoke(self, data: typing.Any) -> typing.Any:
         """Invoke the Azure OpenAI API
 
         Parameters
@@ -374,28 +444,29 @@ class AzureOpenAIExecutor(Invoker):
 
         client = self._get_ctor()
 
+        r = None
         if self.api == "chat":
-            response = self._create_chat(client, data)
+            r = self._create_chat(client, data)
         elif self.api == "agent":
-            response = self._execute_agent(client, data)
+            r = self._execute_agent(client, data)
         elif self.api == "completion":
-            response = self._create_completion(client, data)
+            r = self._create_completion(client, data)
         elif self.api == "embedding":
-            response = self._create_embedding(client, data)
+            r = self._create_embedding(client, data)
         elif self.api == "image":
-            response = self._create_image(client, data)
+            r = self._create_image(client, data)
 
         # stream response
-        if isinstance(response, Iterator):
+        if isinstance(r, Iterator):
             if self.api == "chat":
                 # TODO: handle the case where there might be no usage in the stream
-                return PromptyStream("AzureOpenAIExecutor", response)
+                return PromptyStream("AzureOpenAIExecutor", r)
             else:
-                return PromptyStream("AzureOpenAIExecutor", response)
+                return PromptyStream("AzureOpenAIExecutor", r)
         else:
-            return response
+            return r
 
-    async def invoke_async(self, data: str) -> typing.Union[str, AsyncPromptyStream]:
+    async def invoke_async(self, data: str) -> typing.Any:
         """Invoke the Prompty Chat Parser (Async)
 
         Parameters
@@ -410,23 +481,24 @@ class AzureOpenAIExecutor(Invoker):
         """
         client = self._get_async_ctor()
 
+        r = None
         if self.api == "chat":
-            response = await self._create_chat_async(client, data)
+            r = await self._create_chat_async(client, data)
         elif self.api == "agent":
-            response = await self._execute_agent_async(client, data)
+            r = await self._execute_agent_async(client, data)
         elif self.api == "completion":
-            response = await self._create_completion_async(client, data)
+            r = await self._create_completion_async(client, data)
         elif self.api == "embedding":
-            response = await self._create_embedding_async(client, data)
+            r = await self._create_embedding_async(client, data)
         elif self.api == "image":
-            response = await self._create_image_async(client, data)
+            r = await self._create_image_async(client, data)
 
         # stream response
-        if isinstance(response, AsyncIterator):
+        if isinstance(r, AsyncIterator):
             if self.api == "chat":
                 # TODO: handle the case where there might be no usage in the stream
-                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", r)
             else:
-                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", r)
         else:
-            return response
+            return r

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/azure/processor.py

@@ -42,13 +42,6 @@ class AzureOpenAIProcessor(Invoker):
         any
             The response from the OpenAI/Azure API
         """
-        # agent invocations return the thread
-        # and the last message is the response
-        if self.prompty.model.api == "agent" and isinstance(data, list):
-            if isinstance(data[-1], dict):
-                return data[-1]["content"]
-            else:
-                return data
 
         if isinstance(data, ChatCompletion):
             response = data.choices[0].message
@@ -94,12 +87,12 @@ class AzureOpenAIProcessor(Invoker):
         elif isinstance(data, ImagesResponse):
             item: ImagesResponse = data
 
-            if len(data.data) == 0:
+            if item.data is None or len(item.data) == 0:
                 raise ValueError("Invalid data")
-            elif len(data.data) == 1:
-                return data.data[0].url if item.data[0].url else item.data[0].b64_json
+            elif len(item.data) == 1:
+                return item.data[0].url if item.data[0].url else item.data[0].b64_json
             else:
-                return [item.url if item.url else item.b64_json for item in data.data]
+                return [i.url if i.url else i.b64_json for i in item.data]
 
         elif isinstance(data, Iterator):
 
@@ -113,7 +106,7 @@ class AzureOpenAIProcessor(Invoker):
         else:
             return data
 
-    async def invoke_async(self, data: str) -> typing.Union[str, AsyncPromptyStream]:
+    async def invoke_async(self, data: str) -> typing.Any:
         """Invoke the Prompty Chat Parser (Async)
 
         Parameters
@@ -126,13 +119,6 @@ class AzureOpenAIProcessor(Invoker):
         str
             The parsed data
         """
-        # agent invocations return the thread
-        # and the last message is the response
-        if self.prompty.model.api == "agent" and isinstance(data, list):
-            if isinstance(data[-1], dict):
-                return data[-1]["content"]
-            else:
-                return data
 
         if isinstance(data, ChatCompletion):
             response = data.choices[0].message
@@ -179,7 +165,7 @@ class AzureOpenAIProcessor(Invoker):
             elif len(data.data) == 1:
                 return data.data[0].url if item.data[0].url else item.data[0].b64_json
             else:
-                return [item.url if item.url else item.b64_json for item in data.data]
+                return [str(item.url) if item.url else item.b64_json for item in data.data]
 
         elif isinstance(data, AsyncIterator):
 

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/common.py

@@ -60,15 +60,39 @@ def convert_output_props(name: str, outputs: list[OutputProperty]) -> dict[str,
                 "strict": True,
                 "schema": {
                     "type": "object",
-                    "properties": {
-                        p.name: {
-                            "type": p.type,
-                        }
-                        for p in outputs
-                    },
-                    "required": [p.name for p in outputs],
+                    "properties": {p.name: _convert_output_object(p) for p in outputs},
+                    "required": [p.name for p in outputs if p.required],
                     "additionalProperties": False,
                 },
             },
         }
     return {}
+
+
+def _convert_output_object(output: OutputProperty) -> dict[str, typing.Any]:
+    """Convert an OutputProperty to a dictionary"""
+    if output.type == "array":
+        if output.items is None:
+            raise ValueError("Array type must have items defined")
+
+        o = _convert_output_object(output.items)
+        if "name" in o:
+            o.pop("name")
+
+        return {
+            "type": "array",
+            "items": o,
+        }
+    elif output.type == "object":
+        return {
+            "type": "object",
+            "properties": {prop.name: _convert_output_object(prop) for prop in output.properties},
+            "required": [prop.name for prop in output.properties if prop.required],
+            "additionalProperties": False,
+        }
+    else:
+        return {
+            "type": output.type,
+            "description": output.description,
+            **({"enum": output.enum} if output.enum else {}),
+        }

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/core.py

@@ -71,10 +71,13 @@ class OutputProperty:
     type: Literal["string", "number", "array", "object", "boolean"]
     name: str = field(default="")
     description: str = field(default="")
-    # only for array type - need to update schema
-    items: list["OutputProperty"] = field(default_factory=list)
+    required: bool = field(default=True)
+    enum: list[typing.Any] = field(default_factory=list)
 
-    json_schema: Optional[dict] = field(default_factory=dict)
+    # for array types, items is a type of OutputProperty
+    items: Optional["OutputProperty"] = field(default=None)
+    # for object types, properties is a list of OutputProperty
+    properties: list["OutputProperty"] = field(default_factory=list)
 
 
 @dataclass
@@ -266,25 +269,6 @@ class Prompty:
 
         raise ValueError(f"Tool {name} not found")
 
-    def get_output(self, name: str) -> OutputProperty:
-        """Get the output property of the prompty
-
-        Parameters
-        ----------
-        name : str
-            The name of the property
-
-        Returns
-        -------
-        OutputProperty
-            The property of the prompty
-        """
-
-        for i in self.outputs:
-            if i.name == name:
-                return i
-        raise ValueError(f"Property {name} not found")
-
     def to_safe_dict(self) -> dict[str, typing.Any]:
         d: dict[str, typing.Any] = {}
         for items in fields(self):
@@ -371,7 +355,14 @@ class Prompty:
         default: Union[Callable[[], dict[str, typing.Any]], None] = None,
     ) -> dict[str, typing.Any]:
 
-        if isinstance(value, dict) and any([f.name in value for f in fields(cls)]):
+        if isinstance(value, dict):
+            # check for minimal set of properties
+            if "type" not in value:
+                if "sample" in value:
+                    # if sample is present, type is not required
+                    value["type"] = get_json_type(type(value["sample"]))
+                else:
+                    raise ValueError(f"{cls.__name__} type is required or must be inferred from sample")
             return {**value}
         else:
             if default is not None:
@@ -591,13 +582,35 @@ class Prompty:
 
         return {**attributes, **prompty, "content": content}
 
+    @staticmethod
+    def _load_output(attributes: dict) -> OutputProperty:
+        if "type" in attributes and attributes["type"] == "array":
+            items = attributes.pop("items", [])
+            attributes["items"] = Prompty._load_output({"name": "item", **items})
+
+        elif "type" in attributes and attributes["type"] == "object":
+            p = attributes.pop("properties", [])
+            if isinstance(p, dict):
+                p = [{"name": k, **v} for k, v in p.items()]
+
+            properties = [Prompty._load_output(i) for i in p]
+            attributes["properties"] = properties
+
+        return OutputProperty(**attributes)
+
     @staticmethod
     def load_raw(attributes: dict, file: Path) -> "Prompty":
+        # normalize outputs
+        outputs = []
+        if "outputs" in attributes:
+            outputs = attributes.pop("outputs")
+            if isinstance(outputs, dict):
+                outputs = [{"name": k, **v} for k, v in outputs.items()]
 
         prompty = Prompty(
             model=ModelProperty(**attributes.pop("model")),
             inputs=[InputProperty(**i) for i in attributes.pop("inputs", [])],
-            outputs=[OutputProperty(**i) for i in attributes.pop("outputs", [])],
+            outputs=[Prompty._load_output(i) for i in outputs],
             tools=Prompty.load_tools(attributes.pop("tools", [])),
             template=TemplateProperty(**attributes.pop("template")),
             file=file,

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/invoker.py

@@ -270,6 +270,7 @@ class Parser(Invoker):
         """
         pass
 
+    @trace
     def run(self, data: typing.Any) -> typing.Any:
         """Method to run the invoker
 
@@ -287,6 +288,7 @@ class Parser(Invoker):
         parsed = self.invoke(data)
         return self.process(parsed)
 
+    @trace
     async def run_async(self, data: typing.Any) -> typing.Any:
         """Method to run the invoker asynchronously
 
@@ -304,6 +306,9 @@ class Parser(Invoker):
         return self.process(parsed)
 
 
+InvokerTypes = Literal["renderer", "parser", "executor", "processor"]
+
+
 class InvokerFactory:
     """Factory class for Invoker"""
 
@@ -367,7 +372,7 @@ class InvokerFactory:
     @classmethod
     def _get_name(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
     ) -> str:
         if type == "renderer":
@@ -384,7 +389,7 @@ class InvokerFactory:
     @classmethod
     def _get_invoker(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
     ) -> Invoker:
         if type == "renderer":
@@ -421,7 +426,7 @@ class InvokerFactory:
     @classmethod
     def run(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
         data: typing.Any,
         default: typing.Any = None,
@@ -439,7 +444,7 @@ class InvokerFactory:
     @classmethod
     async def run_async(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
         data: typing.Any,
         default: typing.Any = None,

{prompty-1.0.0a1 → prompty-1.0.0b1}/prompty/openai/executor.py

@@ -55,6 +55,8 @@ class OpenAIExecutor(Invoker):
         any
             The response from the OpenAI API
         """
+
+        response = None
         with Tracer.start("OpenAI") as trace:
             trace("type", "LLM")
             trace("signature", "OpenAI.ctor")