ommlds 0.0.0.dev331__py3-none-any.whl → 0.0.0.dev332__py3-none-any.whl

ommlds/.manifests.json

@@ -95,7 +95,7 @@
     "module": ".minichain.backends.llamacpp.streaming",
     "attr": null,
     "file": "ommlds/minichain/backends/llamacpp/streaming.py",
-    "line": 26,
+    "line": 28,
     "value": {
       "$.minichain.registry.RegistryManifest": {
         "mod_name": "ommlds.minichain.backends.llamacpp.streaming",
@@ -185,7 +185,7 @@
     "module": ".minichain.backends.openai.streaming",
     "attr": null,
     "file": "ommlds/minichain/backends/openai/streaming.py",
-    "line": 27,
+    "line": 28,
     "value": {
       "$.minichain.registry.RegistryManifest": {
         "mod_name": "ommlds.minichain.backends.openai.streaming",
@@ -278,7 +278,7 @@
     "module": ".minichain.chat.streaming",
     "attr": null,
     "file": "ommlds/minichain/chat/streaming.py",
-    "line": 21,
+    "line": 27,
     "value": {
       "$.minichain.registry.RegistryTypeManifest": {
         "mod_name": "ommlds.minichain.chat.streaming",

ommlds/backends/openai/protocol/__init__.py

@@ -0,0 +1,110 @@
+"""
+https://platform.openai.com/docs/api-reference/introduction
+https://github.com/openai/openai-openapi/blob/master/openapi.yaml
+"""
+# ruff: noqa: I001
+
+from .chatcompletion.chunk import (  # noqa
+    ChatCompletionChunkChoiceDeltaToolCallFunction,
+    ChatCompletionChunkChoiceDeltaToolCall,
+    ChatCompletionChunkChoiceDelta,
+
+    ChatCompletionChunkChoiceLogprobs,
+    ChatCompletionChunkChoice,
+
+    ChatCompletionChunk,
+)
+
+from .chatcompletion.contentpart import (  # noqa
+    TextChatCompletionContentPart,
+
+    ImageChatCompletionContentPartImageUrl,
+    ImageChatCompletionContentPart,
+
+    FileChatCompletionContentPartFileInfo,
+    FileChatCompletionContentPart,
+
+    InputAudioChatCompletionContentPartInputAudio,
+    InputAudioChatCompletionContentPart,
+
+    RefusalChatCompletionContentPart,
+
+    ChatCompletionContentPart,
+)
+
+from .chatcompletion.message import (  # noqa
+    DeveloperChatCompletionMessage,
+
+    SystemChatCompletionMessage,
+
+    UserChatCompletionMessage,
+
+    AssistantChatCompletionMessageAudio,
+    AssistantChatCompletionMessageToolCallFunction,
+    AssistantChatCompletionMessageToolCall,
+    AssistantChatCompletionMessage,
+
+    ToolChatCompletionMessage,
+
+    FunctionChatCompletionMessage,
+
+    ChatCompletionMessage,
+)
+
+from .chatcompletion.request import (  # noqa
+    ChatCompletionRequestWebSearchOptionsUserLocationApproximate,
+    ChatCompletionRequestWebSearchOptionsUserLocation,
+    ChatCompletionRequestWebSearchOptions,
+
+    ChatCompletionRequestPrediction,
+
+    ChatCompletionRequestToolFunction,
+    ChatCompletionRequestTool,
+
+    ChatCompletionRequestStreamOptions,
+
+    ChatCompletionRequestNamedToolChoiceFunction,
+    ChatCompletionRequestNamedToolChoice,
+
+    ChatCompletionRequestAudio,
+
+    ChatCompletionRequest,
+)
+
+from .chatcompletion.response import (  # noqa
+    ChatCompletionResponseAnnotationUrlCitation,
+    ChatCompletionResponseAnnotation,
+
+    ChatCompletionResponseAudio,
+
+    ChatCompletionResponseMessageToolCallFunction,
+    ChatCompletionResponseMessageToolCall,
+    ChatCompletionResponseMessage,
+
+    ChatCompletionResponseChoiceLogprobs,
+    ChatCompletionResponseChoice,
+
+    ChatCompletionResponse,
+)
+
+from .chatcompletion.responseformat import (  # noqa
+    TextChatCompletionResponseFormat,
+
+    JsonSchemaChatCompletionResponseFormatJsonSchema,
+    JsonSchemaChatCompletionResponseFormat,
+
+    JsonObjectChatCompletionResponseFormat,
+
+    ChatCompletionResponseFormat,
+)
+
+from .chatcompletion.tokenlogprob import (  # noqa
+    ChatCompletionTokenLogprobTopLogprob,
+    ChatCompletionTokenLogprob,
+)
+
+from .completionusage import (  # noqa
+    CompletionUsageCompletionTokensDetails,
+    CompletionUsagePromptTokensDetails,
+    CompletionUsage,
+)

ommlds/backends/openai/protocol/chatcompletion/chunk.py

@@ -0,0 +1,71 @@
+import typing as ta
+
+from .tokenlogprob import ChatCompletionTokenLogprob
+
+
+##
+
+
+class ChatCompletionChunkChoiceDeltaToolCallFunction(ta.TypedDict, total=False):
+    arguments: str
+    name: str
+
+
+class ChatCompletionChunkChoiceDeltaToolCall(ta.TypedDict):
+    index: int
+    id: ta.NotRequired[str]
+    function: ta.NotRequired[ChatCompletionChunkChoiceDeltaToolCallFunction]
+    type: ta.Literal['function']
+
+
+#
+
+
+class ChatCompletionChunkChoiceDelta(ta.TypedDict, total=False):
+    content: str
+    refusal: str
+    role: ta.Literal[
+        'developer',
+        'system',
+        'user',
+        'assistant',
+        'tool',
+    ]
+    tool_calls: ta.Sequence[ChatCompletionChunkChoiceDeltaToolCall]
+
+
+#
+
+
+class ChatCompletionChunkChoiceLogprobs(ta.TypedDict, total=False):
+    content: ta.Sequence[ChatCompletionTokenLogprob]
+    refusal: ta.Sequence[ChatCompletionTokenLogprob]
+
+
+class ChatCompletionChunkChoice(ta.TypedDict):
+    delta: ChatCompletionChunkChoiceDelta
+    finish_reason: ta.NotRequired[ta.Literal[
+        'stop',
+        'length',
+        'tool_calls',
+        'content_filter',
+    ]]
+    index: int
+    logprobs: ta.NotRequired[ChatCompletionChunkChoiceLogprobs]
+
+
+#
+
+
+class ChatCompletionChunk(ta.TypedDict):
+    id: str
+    choices: ta.Sequence[ChatCompletionChunkChoice]
+    created: int
+    model: str
+    object: ta.Literal['chat.completion.chunk']
+    service_tier: ta.NotRequired[ta.Literal[
+        'auto',
+        'default',
+        'flex',
+    ]]
+    system_fingerprint: ta.NotRequired[str]

ommlds/backends/openai/protocol/chatcompletion/contentpart.py

@@ -0,0 +1,77 @@
+# ruff: noqa: UP007
+import typing as ta
+
+
+##
+
+
+class TextChatCompletionContentPart(ta.TypedDict):
+    text: str
+    type: ta.Literal['text']
+
+
+#
+
+
+class ImageChatCompletionContentPartImageUrl(ta.TypedDict):
+    url: ta.Required[str]
+    detail: ta.NotRequired[ta.Literal[
+        'auto',
+        'low',
+        'high',
+    ]]
+
+
+class ImageChatCompletionContentPart(ta.TypedDict):
+    image_url: ImageChatCompletionContentPartImageUrl
+    type: ta.Literal['image_url']
+
+
+#
+
+
+class FileChatCompletionContentPartFileInfo(ta.TypedDict, total=False):
+    file_data: str
+    file_id: str
+    filename: str
+
+
+class FileChatCompletionContentPart(ta.TypedDict):
+    file: FileChatCompletionContentPartFileInfo
+    type: ta.Literal['file']
+
+
+#
+
+
+class InputAudioChatCompletionContentPartInputAudio(ta.TypedDict):
+    data: str
+    format: ta.Literal[
+        'wav',
+        'mp3',
+    ]
+
+
+class InputAudioChatCompletionContentPart(ta.TypedDict):
+    input_audio: InputAudioChatCompletionContentPartInputAudio
+    type: ta.Literal['input_audio']
+
+
+#
+
+
+class RefusalChatCompletionContentPart(ta.TypedDict):
+    refusal: str
+    type: ta.Literal['refusal']
+
+
+#
+
+
+ChatCompletionContentPart: ta.TypeAlias = ta.Union[
+    TextChatCompletionContentPart,
+    ImageChatCompletionContentPart,
+    FileChatCompletionContentPart,
+    InputAudioChatCompletionContentPart,
+    RefusalChatCompletionContentPart,
+]

ommlds/backends/openai/protocol/chatcompletion/message.py

@@ -0,0 +1,91 @@
+# ruff: noqa: UP007
+import typing as ta
+
+from .contentpart import ChatCompletionContentPart
+from .contentpart import RefusalChatCompletionContentPart
+from .contentpart import TextChatCompletionContentPart
+
+
+##
+
+
+class DeveloperChatCompletionMessage(ta.TypedDict):
+    content: str | ta.Iterable[TextChatCompletionContentPart]
+    role: ta.Literal['developer']
+    name: ta.NotRequired[str]
+
+
+#
+
+
+class SystemChatCompletionMessage(ta.TypedDict):
+    content: str | ta.Iterable[TextChatCompletionContentPart]
+    role: ta.Literal['system']
+    name: ta.NotRequired[str]
+
+
+#
+
+
+class UserChatCompletionMessage(ta.TypedDict):
+    content: str | ta.Iterable[ChatCompletionContentPart]
+    role: ta.Literal['user']
+    name: ta.NotRequired[str]
+
+
+#
+
+
+class AssistantChatCompletionMessageAudio(ta.TypedDict):
+    id: str
+
+
+class AssistantChatCompletionMessageToolCallFunction(ta.TypedDict):
+    arguments: str
+    name: str
+
+
+class AssistantChatCompletionMessageToolCall(ta.TypedDict):
+    id: str
+    function: AssistantChatCompletionMessageToolCallFunction
+    type: ta.Literal['function']
+
+
+class AssistantChatCompletionMessage(ta.TypedDict, total=False):
+    role: ta.Required[ta.Literal['assistant']]
+    audio: AssistantChatCompletionMessageAudio
+    content: str | ta.Iterable[TextChatCompletionContentPart | RefusalChatCompletionContentPart]
+    name: str
+    refusal: str
+    tool_calls: ta.Iterable[AssistantChatCompletionMessageToolCall]
+
+
+#
+
+
+class ToolChatCompletionMessage(ta.TypedDict):
+    content: str | ta.Iterable[TextChatCompletionContentPart]
+    role: ta.Literal['tool']
+    tool_call_id: str
+
+
+#
+
+
+class FunctionChatCompletionMessage(ta.TypedDict):
+    content: str | None
+    name: str
+    role: ta.Literal['function']
+
+
+#
+
+
+ChatCompletionMessage: ta.TypeAlias = ta.Union[
+    DeveloperChatCompletionMessage,
+    SystemChatCompletionMessage,
+    UserChatCompletionMessage,
+    AssistantChatCompletionMessage,
+    ToolChatCompletionMessage,
+    FunctionChatCompletionMessage,
+]

ommlds/backends/openai/protocol/chatcompletion/request.py

@@ -0,0 +1,140 @@
+# ruff: noqa: UP007
+import typing as ta
+
+from .contentpart import TextChatCompletionContentPart
+from .message import ChatCompletionMessage
+from .responseformat import ChatCompletionResponseFormat
+
+
+##
+
+
+class ChatCompletionRequestWebSearchOptionsUserLocationApproximate(ta.TypedDict, total=False):
+    city: str
+    country: str
+    region: str
+    timezone: str
+
+
+class ChatCompletionRequestWebSearchOptionsUserLocation(ta.TypedDict):
+    approximate: ChatCompletionRequestWebSearchOptionsUserLocationApproximate
+    type: ta.Literal['approximate']
+
+
+class ChatCompletionRequestWebSearchOptions(ta.TypedDict, total=False):
+    search_context_size: ta.Literal[
+        'low',
+        'medium',
+        'high',
+    ]
+    user_location: ChatCompletionRequestWebSearchOptionsUserLocation
+
+
+#
+
+
+class ChatCompletionRequestPrediction(ta.TypedDict):
+    content: str | ta.Iterable[TextChatCompletionContentPart]
+    type: ta.Literal['content']
+
+
+#
+
+
+class ChatCompletionRequestToolFunction(ta.TypedDict, total=False):
+    name: ta.Required[str]
+    description: str
+    parameters: ta.Mapping[str, ta.Any]
+    strict: bool
+
+
+class ChatCompletionRequestTool(ta.TypedDict):
+    function: ChatCompletionRequestToolFunction
+    type: ta.Literal['function']
+
+
+#
+
+
+class ChatCompletionRequestStreamOptions(ta.TypedDict, total=False):
+    include_usage: bool
+
+
+#
+
+
+class ChatCompletionRequestNamedToolChoiceFunction(ta.TypedDict):
+    name: str
+
+
+class ChatCompletionRequestNamedToolChoice(ta.TypedDict):
+    function: ChatCompletionRequestNamedToolChoiceFunction
+    type: ta.Literal['function']
+
+
+#
+
+
+class ChatCompletionRequestAudio(ta.TypedDict):
+    format: ta.Literal[
+        'wav',
+        'aac',
+        'mp3',
+        'flac',
+        'opus',
+        'pcm16',
+    ]
+
+    voice: str
+
+
+#
+
+
+class ChatCompletionRequest(ta.TypedDict, total=False):
+    messages: ta.Required[ta.Iterable[ChatCompletionMessage]]
+    model: ta.Required[str]
+    audio: ChatCompletionRequestAudio
+    frequency_penalty: float
+    logit_bias: ta.Mapping[str, int]
+    logprobs: bool
+    max_completion_tokens: int
+    max_tokens: int
+    metadata: ta.Mapping[str, str]
+    modalities: ta.Sequence[ta.Literal[
+        'text',
+        'audio',
+    ]]
+    n: int
+    parallel_tool_calls: bool
+    prediction: ChatCompletionRequestPrediction
+    presence_penalty: float
+    reasoning_effort: ta.Literal[
+        'low',
+        'medium',
+        'high',
+    ]
+    response_format: ChatCompletionResponseFormat
+    seed: int
+    service_tier: ta.Literal[
+        'auto',
+        'default',
+        'flex',
+    ]
+    stop: ta.Union[str, ta.Sequence[str], None]
+    store: bool
+    stream_options: ChatCompletionRequestStreamOptions
+    temperature: float
+    tool_choice: ta.Union[
+        ta.Literal[
+            'none',
+            'auto',
+            'required',
+        ],
+        ChatCompletionRequestNamedToolChoice,
+    ]
+    tools: ta.Iterable[ChatCompletionRequestTool]
+    top_logprobs: int
+    top_p: float
+    user: str
+    web_search_options: ChatCompletionRequestWebSearchOptions

ommlds/backends/openai/protocol/chatcompletion/response.py

@@ -0,0 +1,90 @@
+import typing as ta
+
+from ..completionusage import CompletionUsage
+from .tokenlogprob import ChatCompletionTokenLogprob
+
+
+##
+
+
+class ChatCompletionResponseAnnotationUrlCitation(ta.TypedDict):
+    end_index: int
+    start_index: int
+    title: str
+    url: str
+
+
+class ChatCompletionResponseAnnotation(ta.TypedDict):
+    type: ta.Literal['url_citation']
+    url_citation: ChatCompletionResponseAnnotationUrlCitation
+
+
+#
+
+
+class ChatCompletionResponseAudio(ta.TypedDict):
+    id: str
+    data: str
+    expires_at: int
+    transcript: str
+
+
+#
+
+
+class ChatCompletionResponseMessageToolCallFunction(ta.TypedDict):
+    arguments: str
+    name: str
+
+
+class ChatCompletionResponseMessageToolCall(ta.TypedDict):
+    id: str
+    function: ChatCompletionResponseMessageToolCallFunction
+    type: ta.Literal['function']
+
+
+class ChatCompletionResponseMessage(ta.TypedDict, total=False):
+    content: str
+    refusal: str
+    role: ta.Required[ta.Literal['assistant']]
+    annotations: ta.Sequence[ChatCompletionResponseAnnotation]
+    audio: ChatCompletionResponseAudio
+    tool_calls: ta.Sequence[ChatCompletionResponseMessageToolCall]
+
+
+#
+
+
+class ChatCompletionResponseChoiceLogprobs(ta.TypedDict, total=False):
+    content: ta.Sequence[ChatCompletionTokenLogprob]
+    refusal: ta.Sequence[ChatCompletionTokenLogprob]
+
+
+class ChatCompletionResponseChoice(ta.TypedDict):
+    finish_reason: ta.Literal[
+        'stop',
+        'length',
+        'tool_calls',
+        'content_filter',
+    ]
+    index: int
+    logprobs: ta.NotRequired[ChatCompletionResponseChoiceLogprobs]
+    message: ChatCompletionResponseMessage
+
+
+#
+
+
+class ChatCompletionResponse(ta.TypedDict):
+    id: str
+    choices: ta.Sequence[ChatCompletionResponseChoice]
+    created: int
+    model: str
+    object: ta.Literal['chat.completion']
+    service_tier: ta.NotRequired[ta.Literal[
+        'auto',
+        'default',
+        'flex',
+    ]]
+    system_fingerprint: ta.NotRequired[str]
+    usage: ta.NotRequired[CompletionUsage]

ommlds/backends/openai/protocol/chatcompletion/responseformat.py

@@ -0,0 +1,41 @@
+# ruff: noqa: UP007
+import typing as ta
+
+
+##
+
+
+class TextChatCompletionResponseFormat(ta.TypedDict):
+    type: ta.Literal['text']
+
+
+#
+
+
+class JsonSchemaChatCompletionResponseFormatJsonSchema(ta.TypedDict, total=False):
+    name: ta.Required[str]
+    description: str
+    schema: ta.Mapping[str, ta.Any]
+    strict: bool
+
+
+class JsonSchemaChatCompletionResponseFormat(ta.TypedDict):
+    json_schema: JsonSchemaChatCompletionResponseFormatJsonSchema
+    type: ta.Literal['json_schema']
+
+
+#
+
+
+class JsonObjectChatCompletionResponseFormat(ta.TypedDict):
+    type: ta.Literal['json_object']
+
+
+#
+
+
+ChatCompletionResponseFormat: ta.TypeAlias = ta.Union[
+    TextChatCompletionResponseFormat,
+    JsonSchemaChatCompletionResponseFormat,
+    JsonObjectChatCompletionResponseFormat,
+]

ommlds/backends/openai/protocol/chatcompletion/tokenlogprob.py

@@ -0,0 +1,17 @@
+import typing as ta
+
+
+##
+
+
+class ChatCompletionTokenLogprobTopLogprob(ta.TypedDict):
+    token: str
+    bytes: ta.NotRequired[ta.Sequence[int]]
+    logprob: float
+
+
+class ChatCompletionTokenLogprob(ta.TypedDict):
+    token: str
+    bytes: ta.NotRequired[ta.Sequence[int]]
+    logprob: float
+    top_logprobs: ta.Sequence[ChatCompletionTokenLogprobTopLogprob]

ommlds/backends/openai/protocol/completionusage.py

@@ -0,0 +1,24 @@
+import typing as ta
+
+
+##
+
+
+class CompletionUsageCompletionTokensDetails(ta.TypedDict, total=False):
+    accepted_prediction_tokens: int
+    audio_tokens: int
+    reasoning_tokens: int
+    rejected_prediction_tokens: int
+
+
+class CompletionUsagePromptTokensDetails(ta.TypedDict, total=False):
+    audio_tokens: int
+    cached_tokens: int
+
+
+class CompletionUsage(ta.TypedDict):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int
+    completion_tokens_details: ta.NotRequired[CompletionUsageCompletionTokensDetails]
+    prompt_tokens_details: ta.NotRequired[CompletionUsagePromptTokensDetails]