pixie-prompts 0.1.2__tar.gz → 0.1.3__tar.gz

{pixie_prompts-0.1.2 → pixie_prompts-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixie-prompts
-Version: 0.1.2
+Version: 0.1.3
 Summary: Code-first, type-safe prompt management
 License: MIT
 License-File: LICENSE

{pixie_prompts-0.1.2 → pixie_prompts-0.1.3}/pixie/prompts/file_watcher.py

@@ -10,7 +10,7 @@ from watchdog.observers import Observer
 import asyncio
 import logging
 
-from pixie.prompts.storage import initialize_prompt_storage
+from pixie.prompts.storage import PromptLoadError, initialize_prompt_storage
 
 logger = logging.getLogger(__name__)
 
@@ -311,7 +311,11 @@ async def stop_storage_watcher() -> None:
 def init_prompt_storage():
 
     storage_directory = os.getenv("PIXIE_PROMPT_STORAGE_DIR", ".pixie/prompts")
-    initialize_prompt_storage(storage_directory)
+    try:
+        initialize_prompt_storage(storage_directory)
+    except PromptLoadError as e:
+        for err in e.failures:
+            logger.error("Prompt load error: %s", err)
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):

{pixie_prompts-0.1.2 → pixie_prompts-0.1.3}/pixie/prompts/graphql.py

@@ -1,12 +1,15 @@
 """GraphQL schema for SDK server."""
 
 from datetime import datetime
+import json
 import logging
-from typing import Any, Optional, cast
+from typing import Any, Optional, cast, get_args
 
 from graphql import GraphQLError
+import jinja2
 from pydantic_ai import ModelSettings
 from pydantic_ai.direct import model_request
+from pydantic_ai.models import KnownModelName
 import strawberry
 from strawberry.scalars import JSON
 
@@ -15,6 +18,7 @@ from pixie.prompts.prompt_management import get_prompt, list_prompts
 from pixie.prompts.utils import (
     assemble_model_request_parameters,
     openai_messages_to_pydantic_ai_messages,
+    pydantic_ai_messages_to_openai_messages,
 )
 
 logger = logging.getLogger(__name__)
@@ -81,17 +85,28 @@ class ToolCall:
 @strawberry.type
 class LlmCallResult:
 
+    input: JSON
     output: JSON | None
     tool_calls: list[ToolCall] | None
     usage: JSON
     cost: float
     timestamp: datetime
+    reasoning: str | None
 
 
 @strawberry.type
 class Query:
     """GraphQL queries."""
 
+    @strawberry.field
+    async def possible_models(self) -> list[str]:
+        """List possible model names.
+
+        Returns:
+            A list of model names supported by the server.
+        """
+        return list(get_args(KnownModelName.__value__))
+
     @strawberry.field
     async def health_check(self) -> str:
         """Health check endpoint."""
@@ -177,6 +192,9 @@ class Mutation:
     async def call_llm(
         self,
         model: str,
+        prompt_template: str,
+        variables: Optional[JSON],
+        prompt_placeholder: str,
         input_messages: list[JSON],
         output_schema: Optional[JSON] = None,
         tools: Optional[list[JSON]] = None,
@@ -186,7 +204,10 @@ class Mutation:
 
         Args:
             model: The model name to use (e.g., "openai:gpt-4").
-            input_messages: List of messages as JSON objects in openai format.
+            prompt_template: prompt template string.
+            variables: variables for the prompt template.
+            prompt_placeholder: placeholder string in the prompt template to be replaced.
+            input_messages: List of messages as JSON objects in openai format, containing prompt_placeholder in content.
             output_schema: Optional output schema.
             tools: Optional tools configuration (not yet implemented).
             model_parameters: Optional model parameters.
@@ -198,11 +219,35 @@ class Mutation:
             GraphQLError: If the LLM call fails.
         """
         try:
+            template = jinja2.Template(prompt_template)
+            prompt = template.render(**(cast(dict[str, Any], variables) or {}))
+            print(prompt)
+            print(type(prompt))
+            pydantic_messages = openai_messages_to_pydantic_ai_messages(
+                cast(list[dict[str, Any]], input_messages)
+            )
+            for msg in pydantic_messages:
+                for part in msg.parts:
+                    if part.part_kind == "user-prompt":
+                        if isinstance(part.content, str):
+                            part.content = part.content.replace(
+                                prompt_placeholder,
+                                prompt,
+                            )
+                        else:
+                            part.content = [
+                                p.replace(prompt_placeholder, prompt)
+                                for p in part.content
+                                if isinstance(p, str)
+                            ]
+                    elif part.part_kind == "system-prompt":
+                        part.content = part.content.replace(prompt_placeholder, prompt)
+
+            print(pydantic_messages)
+            # Replace the placeholder in input messages
             response = await model_request(
                 model=model,
-                messages=openai_messages_to_pydantic_ai_messages(
-                    cast(list[dict[str, Any]], input_messages)
-                ),
+                messages=pydantic_messages,
                 model_settings=cast(ModelSettings | None, model_parameters),
                 model_request_parameters=assemble_model_request_parameters(
                     cast(dict[str, Any] | None, output_schema),
@@ -212,7 +257,12 @@ class Mutation:
                 ),
             )
             return LlmCallResult(
-                output=JSON(response.text),
+                input=JSON(pydantic_ai_messages_to_openai_messages(pydantic_messages)),
+                output=(
+                    JSON(json.loads(response.text) if output_schema else response.text)
+                    if response.text
+                    else None
+                ),
                 tool_calls=(
                     [
                         ToolCall(
@@ -225,9 +275,16 @@ class Mutation:
                     if response.tool_calls
                     else None
                 ),
-                usage=JSON(response.usage.details),
+                usage=JSON(
+                    {
+                        "input_tokens": response.usage.input_tokens,
+                        "output_tokens": response.usage.output_tokens,
+                        "total_tokens": response.usage.total_tokens,
+                    }
+                ),
                 cost=float(response.cost().total_price),
                 timestamp=response.timestamp,
+                reasoning=response.thinking,
             )
         except Exception as e:
             logger.error("Error running LLM: %s", str(e))

{pixie_prompts-0.1.2 → pixie_prompts-0.1.3}/pixie/prompts/utils.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
+import base64
 import json
-from typing import Any, Literal
+from typing import Any, Literal, Sequence
 
 from pydantic_ai.messages import (
     ModelMessage,
@@ -21,12 +22,210 @@ from pydantic_ai.messages import (
     VideoUrl,
     DocumentUrl,
     BinaryContent,
+    UserContent,
 )
 from pydantic_ai.models import ModelRequestParameters
 from pydantic_ai.tools import ToolDefinition
 from pydantic_ai.output import OutputObjectDefinition
 
 
+# Mapping from OpenAI audio formats to media types
+AUDIO_FORMAT_TO_MEDIA_TYPE = {
+    "mp3": "audio/mpeg",
+    "wav": "audio/wav",
+    "pcm": "audio/pcm",
+    "flac": "audio/flac",
+    "ogg": "audio/ogg",
+    "aac": "audio/aac",
+    "opus": "audio/opus",
+}
+
+# Mapping from media types to OpenAI audio formats
+MEDIA_TYPE_TO_AUDIO_FORMAT = {
+    "audio/mpeg": "mp3",
+    "audio/mp3": "mp3",
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "audio/wave": "wav",
+    "audio/pcm": "pcm",
+    "audio/flac": "flac",
+    "audio/ogg": "ogg",
+    "audio/aac": "aac",
+    "audio/opus": "opus",
+}
+
+
+def _convert_openai_content_array_to_pydantic(
+    content_array: list[dict[str, Any]],
+) -> list[UserContent]:
+    """Convert OpenAI content array format to Pydantic AI UserContent list.
+
+    Args:
+        content_array: List of content parts in OpenAI format
+
+    Returns:
+        List of Pydantic AI UserContent items (str, ImageUrl, AudioUrl, BinaryContent, etc.)
+    """
+    user_content: list[UserContent] = []
+
+    for part in content_array:
+        part_type = part.get("type")
+
+        if part_type == "text":
+            user_content.append(part.get("text", ""))
+
+        elif part_type == "image_url":
+            image_data = part.get("image_url", {})
+            url = image_data.get("url", "")
+            detail = image_data.get("detail")
+
+            # Check if it's a data URI (base64 encoded)
+            if url.startswith("data:"):
+                binary_content = BinaryContent.from_data_uri(url)
+                if detail:
+                    binary_content.vendor_metadata = {"detail": detail}
+                user_content.append(binary_content)
+            else:
+                # Regular URL
+                vendor_metadata = {"detail": detail} if detail else None
+                user_content.append(ImageUrl(url=url, vendor_metadata=vendor_metadata))
+
+        elif part_type == "input_audio":
+            audio_data = part.get("input_audio", {})
+            data_b64 = audio_data.get("data", "")
+            audio_format = audio_data.get("format", "mp3")
+
+            # Convert base64 to binary
+            audio_bytes = base64.b64decode(data_b64)
+            media_type = AUDIO_FORMAT_TO_MEDIA_TYPE.get(
+                audio_format, f"audio/{audio_format}"
+            )
+
+            user_content.append(BinaryContent(data=audio_bytes, media_type=media_type))
+
+        elif part_type == "file":
+            # File input - convert to DocumentUrl or appropriate type
+            file_data = part.get("file", {})
+            file_id = file_data.get("file_id", "")
+            # OpenAI file references are URLs to their file storage
+            if file_id:
+                user_content.append(DocumentUrl(url=f"openai://file/{file_id}"))
+
+        else:
+            # Unknown type - treat as text if possible
+            if "text" in part:
+                user_content.append(part["text"])
+
+    return user_content
+
+
+def _convert_pydantic_content_to_openai(
+    content: Sequence[UserContent],
+) -> list[dict[str, Any]]:
+    """Convert Pydantic AI UserContent sequence to OpenAI content array format.
+
+    Args:
+        content: Sequence of Pydantic AI UserContent items
+
+    Returns:
+        List of OpenAI content parts
+    """
+    content_array: list[dict[str, Any]] = []
+
+    for item in content:
+        if isinstance(item, str):
+            content_array.append({"type": "text", "text": item})
+
+        elif isinstance(item, ImageUrl):
+            image_url_data: dict[str, Any] = {"url": item.url}
+            # Include detail if present in vendor_metadata
+            if item.vendor_metadata and "detail" in item.vendor_metadata:
+                image_url_data["detail"] = item.vendor_metadata["detail"]
+            content_array.append({"type": "image_url", "image_url": image_url_data})
+
+        elif isinstance(item, BinaryContent):
+            if item.is_image:
+                # Convert binary image to data URI
+                image_url_data: dict[str, Any] = {"url": item.data_uri}
+                if item.vendor_metadata and "detail" in item.vendor_metadata:
+                    image_url_data["detail"] = item.vendor_metadata["detail"]
+                content_array.append({"type": "image_url", "image_url": image_url_data})
+
+            elif item.is_audio:
+                # Convert to OpenAI input_audio format
+                audio_format = MEDIA_TYPE_TO_AUDIO_FORMAT.get(
+                    item.media_type, item.format
+                )
+                content_array.append(
+                    {
+                        "type": "input_audio",
+                        "input_audio": {
+                            "data": item.base64,
+                            "format": audio_format,
+                        },
+                    }
+                )
+
+            elif item.is_video:
+                # Video as data URI (limited support in OpenAI)
+                content_array.append(
+                    {
+                        "type": "video",
+                        "video": {"url": item.data_uri},
+                    }
+                )
+
+            elif item.is_document:
+                # Document as data URI
+                content_array.append(
+                    {
+                        "type": "file",
+                        "file": {"url": item.data_uri},
+                    }
+                )
+
+            else:
+                # Unknown binary type - try as file
+                content_array.append(
+                    {
+                        "type": "file",
+                        "file": {"url": item.data_uri},
+                    }
+                )
+
+        elif isinstance(item, AudioUrl):
+            # Audio URL - OpenAI prefers input_audio with base64 data,
+            # but we can reference the URL
+            content_array.append(
+                {
+                    "type": "audio_url",
+                    "audio_url": {"url": item.url},
+                }
+            )
+
+        elif isinstance(item, VideoUrl):
+            # Video URL
+            content_array.append(
+                {
+                    "type": "video",
+                    "video": {"url": item.url},
+                }
+            )
+
+        elif isinstance(item, DocumentUrl):
+            # Document URL
+            content_array.append(
+                {
+                    "type": "file",
+                    "file": {"url": item.url},
+                }
+            )
+
+        # Skip CachePoint and other non-content types
+
+    return content_array
+
+
 def openai_messages_to_pydantic_ai_messages(
     messages: list[dict[str, Any]],
 ) -> list[ModelMessage]:
@@ -62,14 +261,16 @@ def openai_messages_to_pydantic_ai_messages(
             result.append(ModelRequest(parts=[SystemPromptPart(content=content or "")]))
 
         elif role == "user":
-            # Check for multimedia content
+            # Check for multimodal content (content array)
             if isinstance(content, list):
-                # Content array indicates multimodal content
-                raise NotImplementedError(
-                    "Multimedia content (images, audio, etc.) is not supported. "
-                    "Only text content is currently supported."
+                user_content = _convert_openai_content_array_to_pydantic(content)
+                result.append(
+                    ModelRequest(parts=[UserPromptPart(content=user_content)])
+                )
+            else:
+                result.append(
+                    ModelRequest(parts=[UserPromptPart(content=content or "")])
                 )
-            result.append(ModelRequest(parts=[UserPromptPart(content=content or "")]))
 
         elif role == "assistant":
             parts: list[TextPart | ToolCallPart] = []
@@ -184,30 +385,13 @@ def pydantic_ai_messages_to_openai_messages(
                     result.append({"role": "system", "content": part.content})
 
                 elif isinstance(part, UserPromptPart):
-                    # Check for multimedia content
+                    # Check for multimodal content
                     if not isinstance(part.content, str):
-                        # Content is a sequence, check for non-text content
-                        for item in part.content:
-                            if isinstance(
-                                item,
-                                (
-                                    ImageUrl,
-                                    AudioUrl,
-                                    VideoUrl,
-                                    DocumentUrl,
-                                    BinaryContent,
-                                ),
-                            ):
-                                raise NotImplementedError(
-                                    "Multimedia content is not supported. "
-                                    "Only text content is currently supported."
-                                )
-                        # If we get here, all items should be strings - join them
-                        text_content = " ".join(
-                            item if isinstance(item, str) else str(item)
-                            for item in part.content
+                        # Content is a sequence - convert to OpenAI content array
+                        content_array = _convert_pydantic_content_to_openai(
+                            part.content
                         )
-                        result.append({"role": "user", "content": text_content})
+                        result.append({"role": "user", "content": content_array})
                     else:
                         result.append({"role": "user", "content": part.content})
 

{pixie_prompts-0.1.2 → pixie_prompts-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ packages = [
     { include = "pixie" },
 ]
 
-version = "0.1.2"  # Managed by setuptools-scm
+version = "0.1.3"
 description = "Code-first, type-safe prompt management"
 authors = ["Yiou Li <yol@gopixie.ai>"]
 license = "MIT"