voicerun_completions 0.1.2__py3-none-any.whl

voicerun_completions/providers/google/utils.py

@@ -0,0 +1,142 @@
+from typing import Optional
+from google.genai.types import (
+    Content as GoogleMessageContent,
+    Part as GoogleMessagePart,
+    FunctionDeclaration as GoogleFunctionDefinition,
+    Tool as GoogleToolDefinition,
+    ToolConfig as GoogleToolChoice,
+    FunctionCallingConfig as GoogleFunctionChoice,
+)
+from primfunctions.completions.messages import (
+    ConversationHistory,
+    UserMessage,
+    AssistantMessage,
+    SystemMessage,
+    ToolResultMessage,
+)
+from primfunctions.completions.request import ToolChoice, ToolDefinition
+
+
+def denormalize_conversation_history(normalized_messages: ConversationHistory) -> tuple[list[GoogleMessageContent], Optional[str]]:
+    """Convert normalized Message objects to Google Content format.
+
+    Returns:
+        Tuple of (contents, system_instruction) since Google handles system prompts separately
+    """
+    contents: list[GoogleMessageContent] = []
+    system_messages: list[str] = []
+
+    # TODO: thought signatures required https://ai.google.dev/gemini-api/docs/thought-signatures skip_thought_signature_validator?
+
+    for msg in normalized_messages:
+        match msg:
+            case SystemMessage():
+                system_messages.append(msg.content)
+            case UserMessage():
+                parts = []
+                if msg.content:
+                    parts.append(GoogleMessagePart.from_text(text=msg.content))
+
+                content = GoogleMessageContent(
+                    role="user",
+                    parts=parts
+                )
+                contents.append(content)
+            case AssistantMessage():
+                # Assistant messages (model role in Google)
+                parts = []
+
+                # Add text content if present
+                if msg.content:
+                    parts.append(GoogleMessagePart.from_text(text=msg.content))
+
+                # Add function calls if present
+                if msg.tool_calls:
+                    for tc in msg.tool_calls:
+                        # function_call = GoogleFunctionCall(
+                        #     id=tc.id,
+                        #     name=tc.function.name,
+                        #     args=tc.function.arguments
+                        # )
+                        parts.append(GoogleMessagePart.from_function_call(
+                            name=tc.function.name,
+                            args=tc.function.arguments
+                        ))
+
+                content = GoogleMessageContent(
+                    role="model",
+                    parts=parts
+                )
+                contents.append(content)
+            case ToolResultMessage():
+                # Tool results become function_response parts in user messages
+                # Need to find the corresponding function name from tool_call_id
+                # For now, we'll need to track function names separately or get from context
+                if msg.tool_call_id and msg.content:
+                    # TODO: We need the function name from the original tool call
+                    # This requires tracking the function name when processing assistant messages
+                    # function_response = GoogleFunctionResponse(
+                    #     id=msg.tool_call_id,
+                    #     name=msg.name or "unknown_function",  # Name is required
+                    #     response={"output": msg.content}
+                    # )
+
+                    content = GoogleMessageContent(
+                        role="user",
+                        parts=[GoogleMessagePart.from_function_response(
+                            name=msg.name or "unknown_function",
+                            response={"output": msg.content}
+                        )]
+                    )
+                    contents.append(content)
+
+    # Combine system messages with newlines
+    system_instruction: Optional[str] = "\n".join(system_messages) if system_messages else None
+
+    return contents, system_instruction
+
+
+def denormalize_tools(normalized_tools: Optional[list[ToolDefinition]]) -> Optional[list[GoogleToolDefinition]]:
+    """Convert normalized Tool objects to Google Tool format."""
+
+    function_defs: Optional[list[GoogleFunctionDefinition]] = None
+    if normalized_tools:
+        function_defs = []
+        for tool in normalized_tools:
+            function_declaration = GoogleFunctionDefinition(
+                name=tool.function.name,
+                description=tool.function.description,
+                parameters=tool.function.parameters
+            )
+            function_defs.append(function_declaration)
+
+    # All google function calling tools are included in a single Google Tool
+    return [GoogleToolDefinition(function_declarations=function_defs)] if function_defs else None
+
+
+def denormalize_tool_choice(normalized_tool_choice: Optional[ToolChoice]) -> Optional[GoogleToolChoice]:
+    """Convert normalized ToolChoice to Google GoogleToolChoice format."""
+    if not normalized_tool_choice:
+        return None
+
+    # Google uses ToolConfig with FunctionCallingConfig
+    if normalized_tool_choice == "auto":
+        return GoogleToolChoice(
+            function_calling_config=GoogleFunctionChoice(mode="AUTO")
+        )
+    elif normalized_tool_choice == "none":
+        return GoogleToolChoice(
+            function_calling_config=GoogleFunctionChoice(mode="NONE")
+        )
+    elif normalized_tool_choice == "required":
+        return GoogleToolChoice(
+            function_calling_config=GoogleFunctionChoice(mode="ANY")
+        )
+    else:
+        # Specific tool name - use allowed_function_names
+        return GoogleToolChoice(
+            function_calling_config=GoogleFunctionChoice(
+                mode="ANY",
+                allowed_function_names=[normalized_tool_choice]
+            )
+        )

voicerun_completions/providers/openai/openai_client.py

@@ -0,0 +1,159 @@
+from typing import Any, Optional, AsyncIterable
+from openai import AsyncOpenAI
+from openai.types.chat import (
+  ChatCompletion,
+  ChatCompletionMessageParam,
+  ChatCompletionFunctionToolParam,
+  ChatCompletionToolChoiceOptionParam,
+)
+from openai.types.chat.chat_completion import (
+    Choice as OpenAiChoice,
+    ChatCompletionMessage as OpenAiChatCompletionMessage,
+)
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk as OpenAiCompletionChunk
+from primfunctions.completions.messages import AssistantMessage
+from primfunctions.completions.response import ChatCompletionResponse
+from primfunctions.completions.request import ChatCompletionRequest, StreamOptions
+
+from .streaming import OpenAiStreamProcessor
+from ..base import CompletionClient
+from .utils import (
+  denormalize_conversation_history,
+  denormalize_tools,
+  denormalize_tool_choice,
+  normalize_tool_calls,
+)
+
+
+class OpenAiCompletionClient(CompletionClient):
+
+    def _denormalize_request(
+        self,
+        request: ChatCompletionRequest,
+    ) -> dict[str, Any]:
+        """Convert ChatCompletionRequest to kwargs for _get_completion."""
+
+        kwargs = {
+            "api_key": request.api_key,
+            "model": request.model,
+            "messages": denormalize_conversation_history(request.messages),
+            "tools": denormalize_tools(request.tools),
+            "tool_choice": denormalize_tool_choice(request.tool_choice),
+            "temperature": request.temperature if request.temperature else None,
+        }
+
+        if request.max_tokens is not None:
+            kwargs["max_tokens"] = request.max_tokens
+
+        if request.timeout is not None:
+            kwargs["timeout"] = request.timeout
+
+        return kwargs
+
+
+    def _normalize_response(
+        self,
+        response: ChatCompletion,
+    ) -> ChatCompletionResponse:
+        """Convert OpenAI ChatCompletion to normalized ChatCompletionResponse."""
+        # Take only first choice
+        choice: OpenAiChoice = response.choices[0]
+        openai_message: OpenAiChatCompletionMessage = choice.message
+
+        normalized_message = AssistantMessage(
+            content=openai_message.content,
+            tool_calls=normalize_tool_calls(openai_message.tool_calls)
+        )
+
+        return ChatCompletionResponse(
+            message=normalized_message,
+            finish_reason=choice.finish_reason,
+            usage=response.usage.model_dump() if response.usage else None
+        )
+
+
+    async def _get_completion(
+        self,
+        api_key: str,
+        model: str,
+        messages: list[ChatCompletionMessageParam],
+        tools: Optional[list[ChatCompletionFunctionToolParam]] = None,
+        tool_choice: Optional[ChatCompletionToolChoiceOptionParam] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        timeout: Optional[float] = None,
+    ) -> ChatCompletion:
+        """TODO.
+
+        [Client](https://github.com/openai/openai-python)
+        """
+        async with AsyncOpenAI(api_key=api_key) as client:
+            # Build kwargs dict with only non-None values
+            kwargs = {
+                "model": model,
+                "messages": messages,
+                "stream": False,
+                # TODO: support reasoning by model
+                # "reasoning_effort": "none", # Disable reasoning
+            }
+
+            # Only add optional parameters if they're provided
+            if tools is not None:
+                kwargs["tools"] = tools
+            if tool_choice is not None:
+                kwargs["tool_choice"] = tool_choice
+            if temperature is not None:
+                kwargs["temperature"] = temperature
+            if max_tokens is not None:
+                kwargs["max_tokens"] = max_tokens
+            if timeout is not None:
+                kwargs["timeout"] = timeout
+
+            return await client.chat.completions.create(**kwargs)
+
+
+    def _get_stream_processor(
+        self,
+        stream_options: Optional[StreamOptions] = None,
+    ) -> OpenAiStreamProcessor:
+        """Get openai-specific StreamProcessor."""
+        return OpenAiStreamProcessor(stream_options=stream_options)
+
+
+    async def _get_completion_stream(
+        self,
+        api_key: str,
+        model: str,
+        messages: list[ChatCompletionMessageParam],
+        tools: Optional[list[ChatCompletionFunctionToolParam]] = None,
+        tool_choice: Optional[ChatCompletionToolChoiceOptionParam] = None,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        timeout: Optional[float] = None,
+    ) -> AsyncIterable[OpenAiCompletionChunk]:
+        """Stream chat completion chunks from OpenAI."""
+        client = AsyncOpenAI(api_key=api_key)
+
+        # Build kwargs dict with only non-None values
+        kwargs = {
+            "model": model,
+            "messages": messages,
+            "stream": True,  # Enable streaming
+            "stream_options": {"include_usage": True},  # Include usage information in stream
+            # TODO: support reasoning by model
+            # "reasoning_effort": "none", # Disable reasoning
+        }
+
+        # Only add optional parameters if they're provided
+        if tools is not None:
+            kwargs["tools"] = tools
+        if tool_choice is not None:
+            kwargs["tool_choice"] = tool_choice
+        if temperature is not None:
+            kwargs["temperature"] = temperature
+        if max_tokens is not None:
+            kwargs["max_tokens"] = max_tokens
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+
+        return await client.chat.completions.create(**kwargs)

voicerun_completions/providers/openai/streaming.py

@@ -0,0 +1,182 @@
+from typing import  Any, AsyncIterable, Dict, List, Optional
+from openai.types.chat.chat_completion_chunk import (
+    Choice as OpenAiChunkChoice,
+    ChoiceDelta as OpenAiChoiceDelta,
+    ChatCompletionChunk as OpenAiCompletionChunk,
+    ChoiceDeltaToolCall as OpenAiToolDelta,
+)
+from primfunctions.completions.messages import ToolCall, AssistantMessage
+from primfunctions.completions.response import ChatCompletionResponse
+from primfunctions.completions.streaming import (
+    ChatCompletionChunk,
+    AssistantMessageDeltaChunk,
+    AssistantMessageSentenceChunk,
+    FinishReasonChunk,
+    ToolCallChunk,
+    UsageChunk,
+    FinalResponseChunk,
+)
+from primfunctions.utils.streaming import update_sentence_buffer, clean_text_for_speech
+from primfunctions.completions.request import StreamOptions
+
+from ..base import StreamProcessor, PartialToolCall
+
+
+class OpenAiStreamProcessor(StreamProcessor):
+    """Processes OpenAI chat completion stream yielding normalized chunks."""
+
+
+    def __init__(
+        self,
+        stream_options: Optional[StreamOptions] = None,
+    ):
+        self.stream_sentences: bool = False
+        self.clean_sentences: bool = True
+        self.min_sentence_length: int = 6
+        self.punctuation_marks: Optional[list[str]] = None
+        self.punctuation_language: Optional[str] = None
+
+        # Override stream options defaults
+        if stream_options:
+            self.stream_sentences = stream_options.stream_sentences
+            self.clean_sentences = stream_options.clean_sentences
+            self.min_sentence_length = stream_options.min_sentence_length
+            self.punctuation_marks = stream_options.punctuation_marks
+            self.punctuation_language = stream_options.punctuation_language
+
+        self.active_calls: Dict[int, PartialToolCall] = {}
+        self.content: str = ""
+        self.tool_calls: List[ToolCall] = []
+        self.finish_reason: str = ""
+        self.usage: Dict[str, Any] = {}
+        self.sentence_buffer = ""
+
+
+    def _process_tool_deltas(self, tool_call_deltas: List[OpenAiToolDelta]) -> List[ToolCallChunk]:
+        """Process a tool call delta and return any completed tool call chunks."""
+        chunks: List[ToolCall] = []
+
+        for delta in tool_call_deltas:
+            # Tool call already in buffer
+            if delta.index in self.active_calls:
+                partial_call = self.active_calls[delta.index]
+                if delta.function and delta.function.arguments:
+                    partial_call.arguments_buffer += delta.function.arguments
+
+                    # Check if tool call complete
+                    if partial_call.is_complete():
+                        # Complete tool call, remove from active calls and return
+                        completed_call = partial_call.to_tool_call()
+                        del self.active_calls[delta.index]
+
+                        # Append full tool call to chunks to stream
+                        chunks.append(ToolCallChunk(
+                            tool_call=completed_call
+                        ))
+
+                        # Add tool call to accumulated response
+                        self.tool_calls.append(completed_call)
+
+            # New tool call
+            else:
+                self.active_calls[delta.index] = PartialToolCall(
+                    id=delta.id,
+                    type=delta.type,
+                    function_name=delta.function.name,
+                    arguments_buffer=delta.function.arguments or "",
+                    index=delta.index,
+                )
+
+        return chunks
+
+
+    def _process_chunk(
+        self,
+        chunk: OpenAiCompletionChunk,
+    ) -> List[ChatCompletionChunk]:
+        """Convert OpenAI ChatCompletionChunk to individual typed chunks."""
+        chunks = []
+
+        # Handle usage chunk
+        if chunk.usage:
+            self.usage = chunk.usage.model_dump()
+
+        # Handle no choices
+        if not chunk.choices:
+            return chunks
+
+        # Take only first choice (OpenAI pattern)
+        choice: OpenAiChunkChoice = chunk.choices[0]
+        delta: OpenAiChoiceDelta = choice.delta
+
+        # Handle content
+        if delta.content:
+            if self.stream_sentences:
+                # Append delta to sentence buffer
+                sentence_buffer, complete_sentence = update_sentence_buffer(
+                    content=delta.content,
+                    sentence_buffer=self.sentence_buffer,
+                    punctuation_marks=self.punctuation_marks,
+                    clean_text=self.clean_sentences,
+                    # TODO: this completely drops messages like "Sure."
+                    min_sentence_length=self.min_sentence_length,
+                )
+                self.sentence_buffer = sentence_buffer
+
+                if complete_sentence:
+                    chunks.append(AssistantMessageSentenceChunk(
+                        sentence=complete_sentence
+                    ))
+
+            else:
+                # Otherwise stream content delta directly
+                chunks.append(AssistantMessageDeltaChunk(
+                    content=delta.content
+                ))
+
+            # Add content delta to accumulated response
+            self.content += delta.content
+
+        # Handle tool calls
+        if delta.tool_calls:
+            chunks.extend(self._process_tool_deltas(delta.tool_calls))
+
+        # Capture finish reason
+        if choice.finish_reason:
+            self.finish_reason = choice.finish_reason
+
+        return chunks
+    
+    async def process_stream(
+        self,
+        stream: AsyncIterable[OpenAiCompletionChunk],
+    ) -> AsyncIterable[ChatCompletionChunk]:
+        async for chunk in stream:
+            for normalized_chunk in self._process_chunk(chunk):
+                yield normalized_chunk
+
+        if self.stream_sentences and self.sentence_buffer:
+            # Clean text for speech if requested
+            complete_sentence = clean_text_for_speech(self.sentence_buffer) if self.clean_sentences else self.sentence_buffer
+            # Handle any remaining text in sentence buffer
+            yield AssistantMessageSentenceChunk(
+                sentence=complete_sentence
+            )
+
+        # Yield the finish chunk (or default)
+        yield FinishReasonChunk(finish_reason=self.finish_reason or "stop")
+
+        # Yield the usage chunk
+        yield UsageChunk(usage=self.usage)
+
+        # Yield aggregated chat completion response as final chunk
+        yield FinalResponseChunk(
+            response = ChatCompletionResponse(
+                message=AssistantMessage(
+                    content=self.content or None,
+                    tool_calls=self.tool_calls or None
+                ),
+                usage=self.usage,
+                finish_reason=self.finish_reason,
+            )
+        )

voicerun_completions/providers/openai/utils.py

@@ -0,0 +1,135 @@
+import json
+from typing import List, Optional
+from openai.types.chat import (
+    ChatCompletionToolChoiceOptionParam as OpenAiToolChoice,
+    ChatCompletionNamedToolChoiceParam as OpenAiNamedToolChoice,
+    ChatCompletionFunctionToolParam as OpenAiToolDefinition,
+    ChatCompletionMessageParam as OpenAiMessage,
+    ChatCompletionUserMessageParam as OpenAiUserMessage,
+    ChatCompletionAssistantMessageParam as OpenAiAssistantMessage,
+    ChatCompletionSystemMessageParam as OpenAiSystemMessage,
+    ChatCompletionToolMessageParam as OpenAiToolResultMessage,
+    ChatCompletionMessageFunctionToolCallParam as OpenAiToolCall,
+)
+from openai.types.shared_params import FunctionDefinition as OpenAiFunctionDefinition
+from openai.types.chat.chat_completion_message_function_tool_call_param import Function as OpenAiFunctionCall
+from primfunctions.completions.messages import (
+    ConversationHistory,
+    UserMessage,
+    AssistantMessage,
+    SystemMessage,
+    ToolResultMessage,
+    ToolCall,
+    FunctionCall,
+)
+from primfunctions.completions.request import ToolChoice, ToolDefinition
+
+
+def denormalize_tool_calls(normalized_tool_calls: Optional[List[ToolCall]]) -> list[OpenAiToolCall]:
+    """TODO"""
+    tool_calls: Optional[list[OpenAiToolCall]] = None
+    if normalized_tool_calls:
+        tool_calls = []
+        for tc in normalized_tool_calls:
+            function_call: OpenAiFunctionCall = {
+                "name": tc.function.name,
+                "arguments": json.dumps(tc.function.arguments),
+            }
+            tool_call: OpenAiToolCall = {
+                "id": tc.id,
+                "type": tc.type,
+                "function": function_call
+            }
+            tool_calls.append(tool_call)
+
+    return tool_calls
+
+
+def denormalize_conversation_history(normalized_messages: ConversationHistory) -> list[OpenAiMessage]:
+    # Convert conversation history to ChatCompletionMessageParams
+    messages: list[OpenAiMessage] = []
+    for msg in normalized_messages:
+        match msg:
+            case UserMessage():
+                messages.append(OpenAiUserMessage(
+                    role="user",
+                    content=msg.content,
+                ))
+            case AssistantMessage():
+                messages.append(OpenAiAssistantMessage(
+                    role="assistant",
+                    content=msg.content,
+                    tool_calls=denormalize_tool_calls(msg.tool_calls),
+                ))
+            case SystemMessage():
+                messages.append(OpenAiSystemMessage(
+                    role="system",
+                    content=msg.content,
+                ))
+            case ToolResultMessage():
+                tool_result: OpenAiToolResultMessage = {
+                    "role": "tool",
+                    "content": json.dumps(msg.content),
+                    "tool_call_id": msg.tool_call_id,
+                }
+                messages.append(tool_result)
+
+    return messages
+
+
+def denormalize_tools(normalized_tools: Optional[list[ToolDefinition]]) -> Optional[list[OpenAiToolDefinition]]:
+    # Convert tools to ChatCompletionFunctionToolParam format if provided
+    tools: Optional[list[OpenAiToolDefinition]] = None
+    if normalized_tools:
+        tools = []
+        for tool in normalized_tools:
+            function_def: OpenAiFunctionDefinition = {
+                "name": tool.function.name,
+                "description": tool.function.description,
+                "parameters": tool.function.parameters,
+                "strict": tool.function.strict,
+            }
+            tool_def: OpenAiToolDefinition = {
+                "type": tool.type,
+                "function": function_def,
+            }
+            tools.append(tool_def)
+
+    return tools
+
+
+def denormalize_tool_choice(normalized_tool_choice: Optional[ToolChoice]) -> Optional[OpenAiToolChoice]:
+    """Convert normalized ToolChoice to OpenAI ChatCompletionToolChoiceOptionParam format."""
+    tool_choice: Optional[OpenAiToolChoice] = None
+    if normalized_tool_choice:
+        # Handle literal values that are directly compatible
+        if normalized_tool_choice in ["none", "auto", "required"]:
+            tool_choice = normalized_tool_choice
+        else:
+            # TODO: support ChatCompletionNamedToolChoiceCustomParam
+            # Assume tool name
+            tool_choice = OpenAiNamedToolChoice(
+                type="function",
+                function={"name": normalized_tool_choice}
+            )
+
+    return tool_choice
+
+
+def normalize_tool_calls(denormalized_tool_calls: Optional[List[OpenAiToolCall]]) -> list[ToolCall]:
+    """Convert denormalized ChatCompletionMessageFunctionToolCallParam to ToolCall format."""
+    tool_calls: Optional[list[ToolCall]] = None
+    if denormalized_tool_calls:
+        tool_calls = []
+        for index, tc in enumerate(denormalized_tool_calls):
+            tool_calls.append(ToolCall(
+                id=tc.id,
+                type=tc.type,
+                function=FunctionCall(
+                    name=tc.function.name,
+                    arguments=json.loads(tc.function.arguments)
+                ),
+                index=index,
+            ))
+
+    return tool_calls

voicerun_completions-0.1.2.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: voicerun_completions
+Version: 0.1.2
+Summary: VoiceRun Completions
+Author: VoiceRun
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: primfunctions
+Requires-Dist: black>=23.3.0
+Requires-Dist: openai==2.8.0
+Requires-Dist: anthropic==0.74.0
+Requires-Dist: google-genai==1.52.0
+
+# voicerun_completions
+
+A comprehensive SDK for using with the VoiceRun Completions functionality.
+
+## Table of Contents
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+
+## Prerequisites
+
+- Python 3.12+
+- [uv](https://docs.astral.sh/uv/)
+
+If you do not have a uv virtual environment, you can create one with:
+```bash
+uv venv --python 3.12
+```
+
+**Note:** We recommend using uv to install the package due to the incredible speed of the package manager. The package can still be installed via pip directly, but it will be slower.
+
+## Installation
+
+### From PyPI
+
+```bash
+pip install voicerun_completions
+```
+
+### From Source
+
+```bash
+uv pip install .
+```

voicerun_completions-0.1.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+voicerun_completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+voicerun_completions/client.py,sha256=SyYXcByOiqFkhVn9HkMgNJNjsH3ERXiy3uI1fylA5jw,5827
+voicerun_completions/providers/base.py,sha256=XCkWBXmvsXcDcMS6akksPNhPkKQXwpxNqJYkteT9RnM,4080
+voicerun_completions/providers/anthropic/anthropic_client.py,sha256=bBb3_bAO1qSDo_onVL3M7H1ak97We6Y0-24ImAzxMZ0,6659
+voicerun_completions/providers/anthropic/streaming.py,sha256=qGYOAqgmqeKzoj4vNw7-2TCFQU6IsmFpdUVWlx4xznw,7754
+voicerun_completions/providers/anthropic/utils.py,sha256=Xwk7nv6N4LXseqU6r0Qh6k5Fna7kZY4QfKm7cTCq93U,7467
+voicerun_completions/providers/google/google_client.py,sha256=XljdWabr-K8THUDDhC4YQ4HII6ElZJNrUeyRSCPJ8gw,5641
+voicerun_completions/providers/google/streaming.py,sha256=VLcMKvDRVmGd8G95xJfw_rwFvElssFINoai-v26a7w0,6630
+voicerun_completions/providers/google/utils.py,sha256=jfumtF2H-wp6pUDQpidOyqWcG68IFuyebb-Wr6BWYuo,5787
+voicerun_completions/providers/openai/openai_client.py,sha256=uu3jdNl9WcLDkABhI68FI9xd_igF8CyLT91JLuHPzu4,5659
+voicerun_completions/providers/openai/streaming.py,sha256=TwxGYxoyplmTrA5U5Pg3GRhm9d8Q1CApmDbo5g3v_aY,6824
+voicerun_completions/providers/openai/utils.py,sha256=VU3WYXF-bhanbQQnzzKrkH3jslvEhZYa3RTJCJCNwG4,5193
+voicerun_completions-0.1.2.dist-info/METADATA,sha256=7-evbAWVPbRBJz5BRCO1_qK_WvWQR7ZR4x7451hVWGI,1002
+voicerun_completions-0.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+voicerun_completions-0.1.2.dist-info/top_level.txt,sha256=R9R2ek4izV-Jznppy4FVlmBAZs6VEQo-PeqpkaI4xzg,21
+voicerun_completions-0.1.2.dist-info/RECORD,,

voicerun_completions-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

voicerun_completions-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+voicerun_completions