ocai-openai 0.1.1__tar.gz

ocai_openai-0.1.1/.gitignore

@@ -0,0 +1,60 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+*.so
+
+# uv / venv
+.venv/
+uv.lock.bak
+
+# Tooling caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.import_linter_cache/
+.coverage
+htmlcov/
+
+# Docs site build output and page cache (zensical build)
+/site/
+/.cache/
+
+# Node (future typescript/)
+node_modules/
+*.tsbuildinfo
+
+# Go (future go/)
+/go/bin/
+
+# Editors / OS. Shared editor settings ARE committed: the multi-root workspace
+# (ocai.code-workspace) and each folder's .vscode/settings.json + extensions.json
+# give Pylance/Ruff the right interpreter per project. Personal files stay local.
+.idea/
+.vscode/*
+!.vscode/settings.json
+!.vscode/extensions.json
+.DS_Store
+
+# Per-user agent settings (never commit personal permissions)
+.claude/settings.local.json
+.codex/config.toml
+
+# Platform build and browser-test artifacts
+.nuxt/
+.output/
+platform/test-results/
+platform/playwright-report/
+
+# Local environment files: the root .env is the active one, .envs/ holds the
+# per-environment variants (`task env -- <ENV>` copies .envs/.env.<ENV> to .env).
+# Never committed: they hold credentials.
+/.env
+/.envs/
+.local/
+
+# Task execution fingerprints
+.task/

ocai_openai-0.1.1/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog — ocai-openai
+
+All notable changes to the `ocai-openai` distribution. Generated from the change files in
+`.changeset/` by the release workflow (ADR 0010); do not edit released sections by hand.
+## 0.1.1 (2026-11-11)
+
+### Features
+
+#### Admit provider-executed server-tool definitions with honest support reports
+
+Admit provider-executed server-tool definitions with honest support reports. (WU-41, #80)
+
+#### Preserve scoped request and replay anchors
+
+Preserve scoped request and replay anchors. (WU-42, #83)
+
+#### Qualify independent DeepSeek unary conversion
+
+Share compatible mapping through explicit variant configuration while preserving
+DeepSeek identity, mandatory reasoning replay, honest parameter effects and
+measured usage. Add independently censused request encode/audit and response
+decode edges with recoverable unknown-field evidence. (WU-44b, #91)
+
+### Fixes
+
+#### Package metadata points at the real repository and the DeepSeek plugin has an extra
+
+Homepage, Source, Documentation and Changelog URLs now point at `github.com/ocarinow/ocai` and the docs site. `ocai[deepseek]` installs the DeepSeek plugin and `ocai[all]` includes it. No runtime behavior changed.

ocai_openai-0.1.1/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.5
+Name: ocai-openai
+Version: 0.1.1
+Summary: OpenAI adapter plugin for ocai (ships ocai.openai into the shared namespace).
+Project-URL: Homepage, https://github.com/ocarinow/ocai
+Project-URL: Source, https://github.com/ocarinow/ocai
+Project-URL: Documentation, https://ocarinow.github.io/ocai/
+Project-URL: Changelog, https://github.com/ocarinow/ocai/blob/main/python/packages/ocai-openai/CHANGELOG.md
+Author: ocai maintainers
+License-Expression: FSL-1.1-ALv2
+Requires-Python: >=3.13
+Requires-Dist: msgspec>=0.18
+Requires-Dist: ocai<0.2,>=0.1
+Description-Content-Type: text/markdown
+
+# `ocai-openai`
+
+The OpenAI **plugin distribution** for [ocai](https://github.com/ocarinow/ocai).
+Distribution name: **`ocai-openai`**; `pip install ocai[openai]` resolves to the
+same wheel. Requires Python 3.13+ and `ocai>=0.1,<0.2`.
+
+It ships only `ocai/openai/` into the shared `ocai` PEP 420 namespace,
+organized one subpackage per wire interface:
+
+- `ocai.openai.chat_completions` — the `/v1/chat/completions` interface:
+  typed wire structs, the codec, contract-censused conversion edges, the
+  capability profile, and the chat component. Unary and streaming calls are
+  implemented and certified against recorded fixtures.
+- `ocai.openai.responses` — the `/v1/responses` interface. A **stub**: its
+  nodes are declared so the interface exists in the graph, but it has no
+  edges, codec, or chat component yet. The front door never auto-selects it,
+  and pinning `interface="responses"` raises `LookupError` until it lands.
+
+The two are sibling interfaces of the one chat capability, not versions of
+each other.
+
+## What installing it does
+
+Exactly one structural thing: the frozen `ocai.openai.FRAGMENT`
+(a `CatalogFragment`) becomes discoverable through the `ocai.fragments`
+entry-point group, so `ocai.chat.model("openai/<model>", ...)` can resolve the
+provider and the conversion graph gains OpenAI's nodes and edges. Importing
+`ocai.openai` is inert; there is no import-time registration. Applications
+that want an explicit catalog compose it themselves with
+`Catalog.of(ocai.openai.FRAGMENT)`.
+
+```python
+from ocai.openai import chat_model
+from ocai.core import ApiKey
+
+model = chat_model("gpt-4o", credentials=ApiKey.from_env("OPENAI_API_KEY"))
+result = model.chat(...)   # needs ocai[http] and a real key
+```
+
+`chat_model` is sugar over `ocai.chat.model("openai/<model>", ...)` on a
+catalog built from this fragment, never a separate code path.
+
+## Boundaries
+
+- No `openai` SDK: ocai owns the wire through `ocai.wire`. This plugin depends
+  on `ocai.core` + `ocai.convert` + `ocai.chat` only, never on `ocai.wire` or
+  `httpx`, so archived traffic can be re-converted by tooling with no ability
+  to make network calls.
+- `msgspec` is used only at the wire-decode boundary.
+- Every conversion edge declares an `EdgeContract` and ships golden fixtures
+  in the repository's `spec/`.
+
+## License
+
+Source-available under FSL-1.1-ALv2 (converting to Apache-2.0 two years after
+each release). ocai is not open source.

ocai_openai-0.1.1/README.md

@@ -0,0 +1,56 @@
+# `ocai-openai`
+
+The OpenAI **plugin distribution** for [ocai](https://github.com/ocarinow/ocai).
+Distribution name: **`ocai-openai`**; `pip install ocai[openai]` resolves to the
+same wheel. Requires Python 3.13+ and `ocai>=0.1,<0.2`.
+
+It ships only `ocai/openai/` into the shared `ocai` PEP 420 namespace,
+organized one subpackage per wire interface:
+
+- `ocai.openai.chat_completions` — the `/v1/chat/completions` interface:
+  typed wire structs, the codec, contract-censused conversion edges, the
+  capability profile, and the chat component. Unary and streaming calls are
+  implemented and certified against recorded fixtures.
+- `ocai.openai.responses` — the `/v1/responses` interface. A **stub**: its
+  nodes are declared so the interface exists in the graph, but it has no
+  edges, codec, or chat component yet. The front door never auto-selects it,
+  and pinning `interface="responses"` raises `LookupError` until it lands.
+
+The two are sibling interfaces of the one chat capability, not versions of
+each other.
+
+## What installing it does
+
+Exactly one structural thing: the frozen `ocai.openai.FRAGMENT`
+(a `CatalogFragment`) becomes discoverable through the `ocai.fragments`
+entry-point group, so `ocai.chat.model("openai/<model>", ...)` can resolve the
+provider and the conversion graph gains OpenAI's nodes and edges. Importing
+`ocai.openai` is inert; there is no import-time registration. Applications
+that want an explicit catalog compose it themselves with
+`Catalog.of(ocai.openai.FRAGMENT)`.
+
+```python
+from ocai.openai import chat_model
+from ocai.core import ApiKey
+
+model = chat_model("gpt-4o", credentials=ApiKey.from_env("OPENAI_API_KEY"))
+result = model.chat(...)   # needs ocai[http] and a real key
+```
+
+`chat_model` is sugar over `ocai.chat.model("openai/<model>", ...)` on a
+catalog built from this fragment, never a separate code path.
+
+## Boundaries
+
+- No `openai` SDK: ocai owns the wire through `ocai.wire`. This plugin depends
+  on `ocai.core` + `ocai.convert` + `ocai.chat` only, never on `ocai.wire` or
+  `httpx`, so archived traffic can be re-converted by tooling with no ability
+  to make network calls.
+- `msgspec` is used only at the wire-decode boundary.
+- Every conversion edge declares an `EdgeContract` and ships golden fixtures
+  in the repository's `spec/`.
+
+## License
+
+Source-available under FSL-1.1-ALv2 (converting to Apache-2.0 two years after
+each release). ocai is not open source.

ocai_openai-0.1.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ocai-openai"
+version = "0.1.1"
+description = "OpenAI adapter plugin for ocai (ships ocai.openai into the shared namespace)."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "FSL-1.1-ALv2"     # source-available (FSL → Apache-2.0 after 2 years)
+authors = [{ name = "ocai maintainers" }]
+# Pin a COMPATIBLE CORE RANGE: every wheel merges into one runtime namespace, so
+# a plugin must match the core public-API (semver) it was built against. The
+# plugin depends on core+convert ONLY — never on ocai.wire or httpx, and it
+# imports NO openai SDK (rule 12). msgspec is the sanctioned decode-boundary
+# tool (rule 11): it decodes the OpenAI wire into typed dialect structs. It
+# stays in the PLUGIN — never in ocai.core.
+dependencies = ["ocai>=0.1,<0.2", "msgspec>=0.18"]
+
+# The fragment entry point (`ocai.convert.catalog.ENTRY_POINT_GROUP`): names
+# DATA — the frozen CatalogFragment — never a register() callable that would
+# mutate globals at import time. `Catalog.discover()` composes it opt-in.
+[project.entry-points."ocai.fragments"]
+openai = "ocai.openai:FRAGMENT"
+
+[project.urls]
+Homepage = "https://github.com/ocarinow/ocai"
+Source = "https://github.com/ocarinow/ocai"
+Documentation = "https://ocarinow.github.io/ocai/"
+Changelog = "https://github.com/ocarinow/ocai/blob/main/python/packages/ocai-openai/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+# Ship ONLY ocai/openai/ into the shared `ocai` namespace. Again: no
+# src/ocai/__init__.py (PEP 420).
+packages = ["src/ocai"]
+
+[tool.hatch.build]
+dev-mode-dirs = ["src"]

ocai_openai-0.1.1/src/ocai/openai/__init__.py

@@ -0,0 +1,53 @@
+"""`ocai.openai` — the OpenAI plugin distribution (`ocai-openai`).
+
+Ships in the same `ocai` PEP 420 namespace as the core distribution but as a
+separate dist, organized **one subpackage per interface** (§7):
+
+- `ocai.openai.chat_completions` — the `/v1/chat/completions` wire protocol,
+- `ocai.openai.responses` — the `/v1/responses` wire protocol [stub],
+
+which are *concurrent sibling interfaces* of the one chat capability, not
+versions of each other. Each subpackage carries its own wire models, codec,
+contract-censused edges, and per-interface `FRAGMENT`.
+
+This module composes them into the distribution-level `FRAGMENT` an
+application opts into — `Catalog.of(ocai.openai.FRAGMENT)` — with **no
+import-time registration** anywhere (rule 14; the old process-global
+`register()` side effect is gone). Importing this package is inert. The
+plugin depends on `ocai.core` + `ocai.convert` + `ocai.chat` only — never on
+`ocai.wire` or httpx — so archived traffic can be re-converted by tooling
+with no ability to make network calls.
+
+It also re-exports `chat_model`, the sanctioned §3.4 sugar door
+(`from ocai.openai import chat_model; chat_model("gpt-5", credentials=key)`)
+— a thin wrapper over the same fragment + facade machinery as the core
+string door, targeting the `chat_completions` interface today.
+"""
+
+from __future__ import annotations
+
+from ocai.convert.catalog import CatalogFragment
+from ocai.openai import chat_completions
+from ocai.openai import responses
+from ocai.openai.chat_completions import chat_model
+from ocai.openai.chat_completions.edges import ORIGIN
+
+__all__ = [
+    "FRAGMENT",
+    "chat_completions",
+    "chat_model",
+    "responses",
+]
+
+# The composed distribution fragment: everything both interfaces publish,
+# under one provenance stamp. Compose the per-interface fragments instead
+# when an application wants only one wire protocol in its catalog.
+FRAGMENT = CatalogFragment(
+    origin=ORIGIN,
+    nodes=chat_completions.FRAGMENT.nodes + responses.FRAGMENT.nodes,
+    edges=chat_completions.FRAGMENT.edges + responses.FRAGMENT.edges,
+    transducers=chat_completions.FRAGMENT.transducers + responses.FRAGMENT.transducers,
+    profiles=chat_completions.FRAGMENT.profiles + responses.FRAGMENT.profiles,
+    traits=chat_completions.FRAGMENT.traits + responses.FRAGMENT.traits,
+    components=chat_completions.FRAGMENT.components + responses.FRAGMENT.components,
+)

ocai_openai-0.1.1/src/ocai/openai/chat_completions/__init__.py

@@ -0,0 +1,110 @@
+"""`ocai.openai.chat_completions` — the OpenAI Chat Completions interface.
+
+One subpackage per interface (§7): this package is everything ocai knows about
+`POST /v1/chat/completions` as a wire protocol — its msgspec decode-boundary
+models (`wire`), its identity + mapping codec (`codec`), and its declarative
+catalog material (`edges`). The sibling `ocai.openai.responses` package is a
+*concurrent interface* of the same chat capability, not a version of this one.
+
+The public surface is `FRAGMENT`: a frozen, provenance-stamped
+`CatalogFragment` an application composes explicitly —
+`Catalog.of(ocai.openai.chat_completions.FRAGMENT, ...)` — with **no
+import-time registration** into any global (rule 14). This package depends on
+`ocai.core` + `ocai.convert` + `ocai.chat` only, never on `ocai.wire`/httpx,
+so offline audit tooling can re-convert archived traffic without the ability
+to make a network call.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ocai.convert.catalog import Catalog
+from ocai.convert.catalog import CatalogFragment
+from ocai.convert.catalog import Component
+from ocai.core.identity import CHAT
+from ocai.openai.chat_completions.codec import CHAT_COMPLETIONS_CHUNK
+from ocai.openai.chat_completions.codec import CHAT_COMPLETIONS_REQUEST
+from ocai.openai.chat_completions.codec import CHAT_COMPLETIONS_RESPONSE
+from ocai.openai.chat_completions.codec import ChatCompletionsCodec
+from ocai.openai.chat_completions.codec import dialect_traits
+from ocai.openai.chat_completions.edges import EDGES
+from ocai.openai.chat_completions.edges import NODES
+from ocai.openai.chat_completions.edges import ORIGIN
+from ocai.openai.chat_completions.edges import PROFILES
+from ocai.openai.chat_completions.edges import TRANSDUCERS
+
+if TYPE_CHECKING:
+    from ocai.chat.protocol import ChatModel
+    from ocai.core.credentials import Credential
+
+__all__ = [
+    "CHAT_COMPLETIONS_CHUNK",
+    "CHAT_COMPLETIONS_REQUEST",
+    "CHAT_COMPLETIONS_RESPONSE",
+    "FRAGMENT",
+    "ChatCompletionsCodec",
+    "chat_model",
+]
+
+# The frozen declarative fragment this interface contributes to a Catalog:
+# its three nodes, its contract-censused edges, its chunk transducer, its
+# capability profile, its hosting traits, and its codec factory (the
+# component the §3.4 front door builds the serving codec from) — all stamped
+# with this distribution's Origin.
+FRAGMENT = CatalogFragment(
+    origin=ORIGIN,
+    nodes=NODES,
+    edges=EDGES,
+    transducers=TRANSDUCERS,
+    profiles=PROFILES,
+    traits=(dialect_traits(),),
+    components=(
+        Component(
+            provider=ChatCompletionsCodec.provider,
+            interface=ChatCompletionsCodec.interface,
+            capability=CHAT,
+            factory=ChatCompletionsCodec,
+        ),
+    ),
+)
+
+
+def chat_model(
+    model_name: str,
+    *,
+    credentials: Credential,
+) -> ChatModel:
+    """Sanctioned sugar (§3.4 door 2): a first-party OpenAI chat model.
+
+    A THIN wrapper over the exact same fragment + facade machinery as the
+    core string door — never a separate code path: it *is* a call to
+    `ocai.chat.model(f"openai/{model_name}", ...)` over a minimal catalog
+    built from this interface's `FRAGMENT` (so the front door composes a
+    `Direct` host at the OpenAI origin from the fragment's declared traits,
+    the `ChatCompletionsCodec` from the fragment's component factory, and an
+    `HttpxTransport`). The model name binds to the returned model object
+    here, at construction; `ChatRequest`s stay pure conversation and never
+    carry it. Power users compose the pieces themselves (any host, any
+    transport, richer catalogs); this factory adds nothing they cannot
+    reach.
+
+    Args:
+        model_name: The OpenAI model name bound to the returned model
+            object (the facade's `EndpointSpec.resource`).
+        credentials: The credential applied per request at the driver leaf.
+            Required — there is no ambient discovery (rule 13).
+
+    Returns:
+        A `ChatModel` implementation backed by this interface.
+    """
+    # Deferred import (the documented door-2 seam): the plugin stays inert at
+    # import time and reaches the wire only through the core front door, at
+    # call time — the same composition path, one frame deeper.
+    from ocai.chat import model
+
+    return model(
+        f"{ChatCompletionsCodec.provider}/{model_name}",
+        credentials=credentials,
+        catalog=Catalog.of(FRAGMENT),
+    )

ocai_openai-0.1.1/src/ocai/openai/chat_completions/client.py

@@ -0,0 +1,210 @@
+"""Pure client-facing Chat Completions mappings; serving and framing stay outside."""
+
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import Any
+
+from ocai.chat.types import ChatResponse
+from ocai.chat.types import Part
+from ocai.chat.types import PartRefusal
+from ocai.chat.types import PartText
+from ocai.chat.types import PartToolCall
+from ocai.convert.graph import EdgeOutput
+from ocai.core.fidelity import Disposition
+from ocai.core.fidelity import FieldLoss
+from ocai.core.fidelity import SemanticShift
+from ocai.core.finish import FinishInfo
+from ocai.core.ir import IRObject
+from ocai.core.refs import ProviderRef
+from ocai.core.refs import RefScope
+from ocai.core.usage import Usage
+
+_FINISH = {
+    "complete": "stop",
+    "stop_sequence": "stop",
+    "max_tokens": "length",
+    "tool_call": "tool_calls",
+    "content_filter": "content_filter",
+}
+
+
+@dataclass(frozen=True)
+class ClientMetadata:
+    """Explicit gateway serving identity, never invented provider provenance."""
+
+    id: str
+    model: str
+    created: int
+
+    def bind(self, payload: dict[str, Any]) -> dict[str, Any]:
+        """Bind serving metadata to a detached response or chunk document."""
+        return {**deepcopy(payload), "id": self.id, "model": self.model, "created": self.created}
+
+
+def _loss(
+    losses: list[FieldLoss],
+    path: str,
+    disposition: Disposition = Disposition.DROPPED,
+    note: str = "no lane in the qualified client contract",
+) -> None:
+    losses.append(FieldLoss(path=path, disposition=disposition, note=note))
+
+
+def _extras(value: IRObject, path: str, losses: list[FieldLoss]) -> None:
+    if value.extensions:
+        _loss(losses, f"{path}.extensions")
+
+
+def _ref_valid(ref: ProviderRef) -> bool:
+    return (
+        ref.provider == "openai"
+        and ref.scope != RefScope.MODEL
+        and (ref.interface == "chat_completions" or ref.scope == RefScope.PROVIDER)
+    )
+
+
+def part_evidence(
+    part: Part, path: str, losses: list[FieldLoss], *, streaming: bool = False
+) -> None:
+    """Report part metadata with no client lane, including scoped anchors."""
+    _extras(part, path, losses)
+    if part.anchor is not None:
+        _loss(
+            losses,
+            f"{path}.anchor",
+            Disposition.DROPPED if _ref_valid(part.anchor) else Disposition.UNSUPPORTED,
+        )
+    if part.id is not None:
+        _loss(losses, f"{path}.id")
+    if part.cache_hint is not None:
+        _loss(losses, f"{path}.cache_hint")
+    if isinstance(part, PartText) and part.annotations:
+        _loss(losses, f"{path}.annotations")
+    if isinstance(part, PartToolCall):
+        if part.status != "input_complete" and not (streaming and part.status == "input_streaming"):
+            _loss(losses, f"{path}.status", Disposition.UNSUPPORTED)
+        if part.executed_by != "client":
+            _loss(losses, f"{path}.executed_by", Disposition.UNSUPPORTED)
+
+
+def client_finish(finish: FinishInfo | None, losses: list[FieldLoss]) -> str | None:
+    """Map finish semantics while retaining unknown native values with findings."""
+    if finish is None:
+        return None
+    _extras(finish, "finish", losses)
+    if finish.detail:
+        _loss(losses, "finish.detail")
+    reason = _FINISH.get(finish.reason)
+    if reason is None:
+        _loss(losses, "finish.reason", Disposition.UNSUPPORTED)
+        return finish.native or finish.reason
+    if finish.native is not None and finish.native != reason:
+        _loss(losses, "finish.native", Disposition.RENAMED, "mapped by canonical finish meaning")
+    return reason
+
+
+def client_usage(usage: Usage | None, losses: list[FieldLoss]) -> dict[str, Any] | None:
+    """Invert disjoint token buckets without inventing missing measurements."""
+    if usage is None:
+        return None
+    _extras(usage, "usage", losses)
+    buckets: dict[str, int] = {}
+    for i, item in enumerate(usage.consumptions):
+        if (
+            item.unit != "tokens"
+            or item.modality != "text"
+            or item.source not in {"input", "output", "cached", "reasoning"}
+            or not isinstance(item.value, int)
+            or isinstance(item.value, bool)
+        ):
+            _loss(losses, f"usage.consumptions[{i}]", Disposition.UNSUPPORTED)
+            continue
+        buckets[item.source] = buckets.get(item.source, 0) + item.value
+    result: dict[str, Any] = {}
+    if "input" in buckets:
+        result["prompt_tokens"] = buckets["input"] + buckets.get("cached", 0)
+    if "output" in buckets:
+        result["completion_tokens"] = buckets["output"] + buckets.get("reasoning", 0)
+    if "prompt_tokens" in result and "completion_tokens" in result:
+        result["total_tokens"] = result["prompt_tokens"] + result["completion_tokens"]
+    if "cached" in buckets:
+        result["prompt_tokens_details"] = {"cached_tokens": buckets["cached"]}
+    if "reasoning" in buckets:
+        result["completion_tokens_details"] = {"reasoning_tokens": buckets["reasoning"]}
+    return result or None
+
+
+def encode_response(response: ChatResponse) -> EdgeOutput:
+    """Convert canonical response semantics; callers explicitly bind serving metadata."""
+    losses: list[FieldLoss] = []
+    shifts: list[SemanticShift] = []
+    message: dict[str, Any] = {"role": "assistant", "content": None}
+    text: list[str] = []
+    refusal: list[str] = []
+    calls: list[dict[str, Any]] = []
+    if response.message.role not in {"model", "assistant"}:
+        _loss(losses, "message.role", Disposition.UNSUPPORTED)
+    for i, part in enumerate(response.message.parts):
+        path = f"message.parts[{i}]"
+        part_evidence(part, path, losses)
+        if isinstance(part, PartText):
+            text.append(part.text)
+        elif isinstance(part, PartRefusal):
+            refusal.append(part.text)
+        elif isinstance(part, PartToolCall):
+            calls.append(
+                {
+                    "id": part.call_id,
+                    "type": "function",
+                    "function": {"name": part.name, "arguments": part.args_json},
+                }
+            )
+        else:
+            _loss(losses, path, Disposition.UNSUPPORTED)
+    if text:
+        message["content"] = "".join(text)
+    if refusal:
+        message["refusal"] = "".join(refusal)
+    if calls:
+        message["tool_calls"] = calls
+    if len(response.message.parts) > 1 and (text or refusal):
+        shifts.append(
+            SemanticShift(
+                kind="relocation",
+                path="message.parts",
+                note="ordered parts grouped into client message lanes",
+            )
+        )
+    _extras(response.message, "message", losses)
+    _extras(response, "response", losses)
+    result: dict[str, Any] = {
+        "object": "chat.completion",
+        "choices": [
+            {
+                "index": 0,
+                "message": message,
+                "finish_reason": client_finish(response.finish, losses),
+            }
+        ],
+    }
+    usage = client_usage(response.usage, losses)
+    if usage is not None:
+        result["usage"] = usage
+    info = response.info
+    if info is not None:
+        _extras(info, "info", losses)
+        if info.id is not None:
+            if _ref_valid(info.id):
+                result["id"] = info.id.id
+            else:
+                _loss(losses, "info.id", Disposition.UNSUPPORTED)
+        if info.model is not None:
+            result["model"] = info.model
+        if info.created is not None:
+            if info.created.tzinfo is None or info.created.microsecond:
+                _loss(losses, "info.created", Disposition.UNSUPPORTED)
+            else:
+                result["created"] = int(info.created.timestamp())
+    return EdgeOutput(result, tuple(losses), tuple(shifts))