ocai-deepseek 0.1.1__tar.gz

ocai_deepseek-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_deepseek-0.1.1/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog — ocai-deepseek
+
+All notable changes to the `ocai-deepseek` 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
+
+#### Declare the independently attributable DeepSeek interface package
+
+Declare the independently attributable DeepSeek interface package. (WU-44a, #89)
+
+#### 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_deepseek-0.1.1/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.5
+Name: ocai-deepseek
+Version: 0.1.1
+Summary: DeepSeek interface descriptors for ocai; execution qualification pending.
+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-deepseek/CHANGELOG.md
+Author: ocai maintainers
+License-Expression: FSL-1.1-ALv2
+Requires-Python: >=3.13
+Requires-Dist: ocai-openai<0.2,>=0.1
+Requires-Dist: ocai<0.2,>=0.1
+Description-Content-Type: text/markdown
+
+# ocai-deepseek
+
+DeepSeek's separately attributable Chat Completions interface for ocai.
+This source-available package uses FSL-1.1-ALv2.
+
+The catalog publishes independently censused unary request encode, request audit
+and response decode edges. Text, function tools, JSON-object output, reasoning
+replay, native finish state and measured usage are qualified by golden fixtures.
+Unknown native data remains recoverable in registered extension banks.
+
+There is no registered serving component or streaming edge yet: public chat
+execution fails before provider I/O. Compatible mapping code and wire DTOs reuse
+ocai-openai, while DeepSeek retains its own identity, profiles and contracts.
+
+```python
+from ocai.convert import Catalog
+from ocai.deepseek import FRAGMENT
+
+catalog = Catalog.of(FRAGMENT)
+lock = catalog.lock()
+```
+
+`deepseek/chat_completions@2026-11` names ocai's documented-wire observation
+snapshot dated 2026-11-11. It is neither a vendor version header nor a model
+release. Model facts and exclusions are recorded in `docs/providers/deepseek.md`.
+WU-45 enables public unary execution; WU-46 qualifies streaming.
+
+Tool histories require original reasoning text for every assistant turn. Missing
+reasoning and unqualified model-dependent top_p are reported UNSUPPORTED. Media,
+beta strict tools, FIM, prefix completion, JSON-schema output, Responses and
+Anthropic-compatible endpoints are outside this initial surface.

ocai_deepseek-0.1.1/README.md

@@ -0,0 +1,31 @@
+# ocai-deepseek
+
+DeepSeek's separately attributable Chat Completions interface for ocai.
+This source-available package uses FSL-1.1-ALv2.
+
+The catalog publishes independently censused unary request encode, request audit
+and response decode edges. Text, function tools, JSON-object output, reasoning
+replay, native finish state and measured usage are qualified by golden fixtures.
+Unknown native data remains recoverable in registered extension banks.
+
+There is no registered serving component or streaming edge yet: public chat
+execution fails before provider I/O. Compatible mapping code and wire DTOs reuse
+ocai-openai, while DeepSeek retains its own identity, profiles and contracts.
+
+```python
+from ocai.convert import Catalog
+from ocai.deepseek import FRAGMENT
+
+catalog = Catalog.of(FRAGMENT)
+lock = catalog.lock()
+```
+
+`deepseek/chat_completions@2026-11` names ocai's documented-wire observation
+snapshot dated 2026-11-11. It is neither a vendor version header nor a model
+release. Model facts and exclusions are recorded in `docs/providers/deepseek.md`.
+WU-45 enables public unary execution; WU-46 qualifies streaming.
+
+Tool histories require original reasoning text for every assistant turn. Missing
+reasoning and unqualified model-dependent top_p are reported UNSUPPORTED. Media,
+beta strict tools, FIM, prefix completion, JSON-schema output, Responses and
+Anthropic-compatible endpoints are outside this initial surface.

ocai_deepseek-0.1.1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ocai-deepseek"
+version = "0.1.1"
+description = "DeepSeek interface descriptors for ocai; execution qualification pending."
+readme = "README.md"
+requires-python = ">=3.13"
+license = "FSL-1.1-ALv2"
+authors = [{ name = "ocai maintainers" }]
+dependencies = ["ocai>=0.1,<0.2", "ocai-openai>=0.1,<0.2"]
+
+[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-deepseek/CHANGELOG.md"
+
+[project.entry-points."ocai.fragments"]
+deepseek = "ocai.deepseek:FRAGMENT"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ocai"]
+
+[tool.hatch.build]
+dev-mode-dirs = ["src"]

ocai_deepseek-0.1.1/src/ocai/deepseek/__init__.py

@@ -0,0 +1,5 @@
+"""DeepSeek descriptor distribution; imports publish data without enabling execution."""
+
+from ocai.deepseek.chat_completions import FRAGMENT
+
+__all__ = ["FRAGMENT"]

ocai_deepseek-0.1.1/src/ocai/deepseek/chat_completions/__init__.py

@@ -0,0 +1,14 @@
+"""Independently qualified unary DeepSeek Chat Completions interface; no serveable component yet."""
+
+from ocai.convert.catalog import CatalogFragment
+from ocai.deepseek.chat_completions.descriptor import NODES
+from ocai.deepseek.chat_completions.descriptor import ORIGIN
+from ocai.deepseek.chat_completions.descriptor import PROFILES
+from ocai.deepseek.chat_completions.descriptor import TRAITS
+from ocai.deepseek.chat_completions.edges import EDGES
+
+__all__ = ["FRAGMENT"]
+
+FRAGMENT = CatalogFragment(
+    origin=ORIGIN, nodes=NODES, profiles=PROFILES, traits=(TRAITS,), edges=EDGES
+)

ocai_deepseek-0.1.1/src/ocai/deepseek/chat_completions/codec.py

@@ -0,0 +1,168 @@
+"""DeepSeek unary semantics over the shared, explicitly configured compatible codec."""
+
+from copy import deepcopy
+from dataclasses import replace
+from typing import Any
+
+from ocai.chat.types import ChatRequest
+from ocai.chat.types import Part
+from ocai.chat.types import PartText
+from ocai.chat.types import PartUnknown
+from ocai.convert.graph import EdgeOutput
+from ocai.core.fidelity import Disposition
+from ocai.core.fidelity import FieldLoss
+from ocai.core.ir import is_json_array
+from ocai.core.ir import is_json_object
+from ocai.deepseek.chat_completions import descriptor
+from ocai.deepseek.chat_completions.evidence import Evidence
+from ocai.deepseek.chat_completions.evidence import fields
+from ocai.deepseek.chat_completions.evidence import response_payload
+from ocai.deepseek.chat_completions.evidence import retain
+from ocai.deepseek.chat_completions.evidence import tool_calls
+from ocai.deepseek.chat_completions.policy import NAMESPACE
+from ocai.deepseek.chat_completions.policy import inspect_request
+from ocai.deepseek.chat_completions.usage import decode_usage
+from ocai.openai.chat_completions.codec import ChatCompletionsCodec
+from ocai.openai.chat_completions.variant import ChatCompletionsVariant
+
+VARIANT = ChatCompletionsVariant(
+    request_node=descriptor.CHAT_COMPLETIONS_REQUEST,
+    response_node=descriptor.CHAT_COMPLETIONS_RESPONSE,
+    chunk_node=descriptor.CHAT_COMPLETIONS_CHUNK,
+    traits=descriptor.TRAITS,
+    path=descriptor.PATH,
+    reasoning_field="reasoning_content",
+    max_tokens_field="max_tokens",
+    knob_ranges=(("temperature", 0.0, 2.0),),
+    finish_reasons=(("insufficient_system_resource", "error"), ("aborted", "error")),
+)
+_REQUEST_FIELDS = {
+    "model",
+    "messages",
+    "tools",
+    "tool_choice",
+    "temperature",
+    "top_p",
+    "seed",
+    "frequency_penalty",
+    "presence_penalty",
+    "parallel_tool_calls",
+    "logprobs",
+    "max_completion_tokens",
+    "max_tokens",
+    "stop",
+    "reasoning_effort",
+    "response_format",
+    "thinking",
+}
+
+
+def _bank(extensions: dict[str, Any], evidence: Evidence, key: str) -> dict[str, Any]:
+    """Collect native extension values without minting unregistered tomorrow-keys."""
+    for name, value in extensions.items():
+        retain(evidence, name.removeprefix("deepseek."), value)
+    evidence.sort(key=lambda record: record["path"])
+    return {key: evidence} if evidence else {}
+
+
+def _notes(losses: list[FieldLoss]) -> tuple[FieldLoss, ...]:
+    return tuple(replace(loss, note=loss.note.replace("openai.", "deepseek.")) for loss in losses)
+
+
+class DeepSeekCodec(ChatCompletionsCodec):
+    """Qualify text, tools, JSON-object and reasoning without enabling execution yet."""
+
+    def __init__(self) -> None:
+        """Use DeepSeek coordinates and field lanes, never OpenAI routing identity."""
+        super().__init__(VARIANT)
+
+    def encode_request(self, request: ChatRequest) -> EdgeOutput:
+        """Apply semantic findings to the effective shared-codec output before provider I/O."""
+        out = super().encode_request(request)
+        losses, shifts = list(out.losses), list(out.shifts)
+        inspect_request(request, out.value, losses, shifts)
+        return EdgeOutput(out.value, _notes(losses), tuple(shifts))
+
+    def decode_request(self, payload: dict[str, Any]) -> EdgeOutput:
+        """Decode compatible request data and retain unknown native fields by source path."""
+        evidence: Evidence = []
+        raw: Any = payload
+        if not is_json_object(raw):
+            retain(evidence, "$", raw)
+            raw = {}
+        safe = fields(raw, _REQUEST_FIELDS, "", evidence)
+        thinking = safe.pop("thinking", None)
+        messages = safe.get("messages")
+        if is_json_array(messages):
+            for index, message in enumerate(messages):
+                if not is_json_object(message):
+                    continue  # shared tolerant reader retains the malformed entry
+                role = message.get("role")
+                if not isinstance(role, str):
+                    retain(evidence, f"messages[{index}].role", role)
+                    message["role"] = "unknown"
+                if "tool_calls" in message:
+                    message["tool_calls"] = tool_calls(
+                        message["tool_calls"], f"messages[{index}].tool_calls", evidence
+                    )
+        out = super().decode_request(safe)
+        request = out.value
+        additional_evidence = bool(evidence)
+        request.extensions = _bank(request.extensions, evidence, "deepseek.request_unmapped")
+        if "thinking" in raw:
+            request.provider_options[NAMESPACE] = {"thinking": deepcopy(thinking)}
+        losses = list(out.losses)
+        if additional_evidence and not any(loss.path == "unmapped" for loss in losses):
+            losses.append(
+                FieldLoss(
+                    "unmapped",
+                    Disposition.EXTENSIONS,
+                    note="unknown native request data retained by source path",
+                )
+            )
+        return EdgeOutput(request, _notes(losses), out.shifts)
+
+    def _decode_request_content(
+        self, index: int, wire_msg: dict[str, Any], losses: list[FieldLoss]
+    ) -> list[Part]:
+        """Keep future native content tags as unknown parts, without inventing media support."""
+        content = wire_msg.get("content")
+        if not is_json_array(content):
+            return super()._decode_request_content(index, wire_msg, losses)
+        parts: list[Part] = []
+        for position, item in enumerate(content):
+            if not is_json_object(item):
+                continue  # the shared request evidence sweep retains malformed scalar entries
+            if item.get("type") == "text" and isinstance(item.get("text"), str):
+                parts.append(PartText(text=item["text"]))
+            else:
+                parts.append(PartUnknown.from_dict(deepcopy(item)))
+                losses.append(
+                    FieldLoss(
+                        f"messages[{index}].content[{position}]",
+                        Disposition.EXTENSIONS,
+                        note="unqualified native content preserved as PartUnknown",
+                    )
+                )
+        return parts
+
+    def decode_response(self, payload: dict[str, Any]) -> EdgeOutput:
+        """Preserve reasoning, native identity and disjoint measured usage through total decode."""
+        safe, evidence = response_payload(payload)
+        native_usage = safe.pop("usage", None)
+        out = super().decode_response(safe)
+        response = out.value
+        losses = list(out.losses)
+        response.usage = decode_usage(native_usage, losses)
+        response.raw = deepcopy(payload)
+        additional_evidence = bool(evidence)
+        response.extensions = _bank(response.extensions, evidence, "deepseek.response_unmapped")
+        if additional_evidence:
+            losses.append(
+                FieldLoss(
+                    "unmapped",
+                    Disposition.EXTENSIONS,
+                    note="unknown native response data retained by source path",
+                )
+            )
+        return EdgeOutput(response, _notes(losses), out.shifts)

ocai_deepseek-0.1.1/src/ocai/deepseek/chat_completions/descriptor.py

@@ -0,0 +1,43 @@
+"""DeepSeek identity and hosting facts, distinct from conversion qualification."""
+
+from datetime import date
+
+from ocai.core.identity import CHAT_CHUNK
+from ocai.core.identity import CHAT_REQUEST
+from ocai.core.identity import CHAT_RESPONSE
+from ocai.core.identity import NodeId
+from ocai.core.identity import Origin
+from ocai.core.identity import Status
+from ocai.core.profile import CapabilityProfile
+from ocai.core.profile import Support
+from ocai.core.traits import DialectTraits
+
+PROVIDER = "deepseek"
+INTERFACE = "chat_completions"
+# Observation snapshot, not a vendor API version or model release.
+TAG = "2026-11"
+RELEASED = date(2026, 11, 11)
+BASE_URL = "https://api.deepseek.com"
+PATH = "/chat/completions"
+MODEL_IDS = ("deepseek-flash", "deepseek-v4-pro")
+ORIGIN = Origin(distribution="ocai-deepseek", version="0.1.0")
+
+CHAT_COMPLETIONS_REQUEST = NodeId(PROVIDER, INTERFACE, TAG, CHAT_REQUEST, RELEASED, Status.STABLE)
+CHAT_COMPLETIONS_RESPONSE = NodeId(PROVIDER, INTERFACE, TAG, CHAT_RESPONSE, RELEASED, Status.STABLE)
+CHAT_COMPLETIONS_CHUNK = NodeId(PROVIDER, INTERFACE, TAG, CHAT_CHUNK, RELEASED, Status.STABLE)
+NODES = (CHAT_COMPLETIONS_REQUEST, CHAT_COMPLETIONS_RESPONSE, CHAT_COMPLETIONS_CHUNK)
+TRAITS = DialectTraits(vendor=PROVIDER, first_party_base_url=BASE_URL)
+# Only independently qualified features are declared; media remains unknown.
+PROFILES = tuple(
+    CapabilityProfile(
+        provider=PROVIDER,
+        interface=INTERFACE,
+        model_pattern=model,
+        features={
+            "chat.config.output.json_schema": Support.ABSENT,
+            "chat.config.output.json": Support.NATIVE,
+            "chat.parts.reasoning.replay": Support.NATIVE,
+        },
+    )
+    for model in MODEL_IDS
+)

ocai_deepseek-0.1.1/src/ocai/deepseek/chat_completions/edges.py

@@ -0,0 +1,221 @@
+"""Independently censused DeepSeek unary edges; no serving or stream registration."""
+
+from ocai.convert.contract import DeclaredDisposition
+from ocai.convert.contract import EdgeContract
+from ocai.convert.graph import Edge
+from ocai.core.fidelity import Disposition
+from ocai.core.fidelity import SemanticShift
+from ocai.core.identity import CHAT_REQUEST
+from ocai.core.identity import CHAT_RESPONSE
+from ocai.core.identity import canonical_node
+from ocai.deepseek.chat_completions.codec import DeepSeekCodec
+from ocai.deepseek.chat_completions.descriptor import CHAT_COMPLETIONS_REQUEST
+from ocai.deepseek.chat_completions.descriptor import CHAT_COMPLETIONS_RESPONSE
+from ocai.deepseek.chat_completions.descriptor import ORIGIN
+
+_CODEC = DeepSeekCodec()
+
+ENCODE_REQUEST_CONTRACT = EdgeContract(
+    census={
+        **{
+            f"{path}.{lane}": DeclaredDisposition(Disposition.UNSUPPORTED)
+            for path in (
+                "config",
+                "config.reasoning",
+                "config.output",
+                "config.audio",
+                "config.cache",
+                "messages[]",
+                "messages[].parts[]",
+                "messages[].parts[].parts[]",
+                "messages[].parts[].annotations[]",
+                "tools[]",
+                "tool_choice",
+            )
+            for lane in ("extensions[]", "provider_options[deepseek.chat_completions]")
+        },
+        "messages[].role": DeclaredDisposition(Disposition.EXACT),
+        "messages[].parts[text]": DeclaredDisposition(Disposition.EXACT),
+        "messages[].parts[tool_call]": DeclaredDisposition(Disposition.EXACT),
+        "messages[].parts[reasoning]": DeclaredDisposition(
+            Disposition.UNSUPPORTED,
+            "required history must be present; plain text replay otherwise maps exactly",
+        ),
+        "messages[].parts[]": DeclaredDisposition(
+            Disposition.DROPPED, "media, server tools and unqualified parts have no mapped lane"
+        ),
+        "config.stop_sequences": DeclaredDisposition(Disposition.RENAMED),
+        "messages[].parts[].text": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].annotations": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].anchor": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].signature": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].opaque": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].source": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].annotations[].opaque": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[].is_error": DeclaredDisposition(Disposition.DROPPED),
+        "messages[].parts[].parts[]": DeclaredDisposition(Disposition.DROPPED),
+        "messages": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "tools": DeclaredDisposition(Disposition.EXACT),
+        "tools[]": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "tool_choice": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "anchors[]": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "extensions[]": DeclaredDisposition(Disposition.DROPPED),
+        "extensions[ocai.request_unparsed_anchors]": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.temperature": DeclaredDisposition(Disposition.APPROXIMATED),
+        "config.top_p": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.seed": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.frequency_penalty": DeclaredDisposition(Disposition.EXACT),
+        "config.presence_penalty": DeclaredDisposition(Disposition.EXACT),
+        "config.parallel_tool_calls": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.max_output_tokens": DeclaredDisposition(Disposition.APPROXIMATED),
+        "config.reasoning.budget_tokens": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.reasoning.include_thoughts": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "messages[].parts[refusal]": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "provider_options[deepseek.chat_completions].tools": DeclaredDisposition(
+            Disposition.UNSUPPORTED
+        ),
+        "config.reasoning.effort": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.output": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.top_k": DeclaredDisposition(Disposition.UNSUPPORTED),
+        "config.logprobs": DeclaredDisposition(Disposition.EXACT),
+        "config.modalities": DeclaredDisposition(Disposition.DROPPED),
+        "config.audio": DeclaredDisposition(Disposition.DROPPED),
+        "config.cache": DeclaredDisposition(Disposition.DROPPED),
+        **{
+            f"provider_options[deepseek.chat_completions].{key}": DeclaredDisposition(
+                Disposition.UNSUPPORTED
+            )
+            for key in (
+                "thinking",
+                "reasoning_effort",
+                "top_p",
+                "seed",
+                "parallel_tool_calls",
+                "max_completion_tokens",
+                "n",
+                "tool_choice",
+                "response_format",
+            )
+        },
+        "provider_options[deepseek.chat_completions].max_tokens": DeclaredDisposition(
+            Disposition.APPROXIMATED
+        ),
+        (
+            "provider_options[deepseek.chat_completions].messages[].reasoning_content"
+        ): DeclaredDisposition(Disposition.UNSUPPORTED),
+    },
+    semantic_shifts=(
+        *(
+            SemanticShift(
+                kind="deepseek.thinking_override",
+                path=path,
+                note="thinking selector overrides effort",
+            )
+            for path in (
+                "config.reasoning.effort",
+                "provider_options[deepseek.chat_completions].reasoning_effort",
+            )
+        ),
+        SemanticShift(
+            kind="relocation",
+            path="messages[].parts[]",
+            note="tool results relocate into sibling tool messages",
+        ),
+        *(
+            SemanticShift(
+                kind="deepseek.ignored_parameter",
+                path=path,
+                note="provider accepts but ignores the supplied parameter",
+            )
+            for key in ("temperature", "frequency_penalty", "presence_penalty")
+            for path in (f"config.{key}", f"provider_options[deepseek.chat_completions].{key}")
+        ),
+        *(
+            SemanticShift(
+                kind="deepseek.effort_alias",
+                path=path,
+                note="provider interprets an effort alias; supplied value stays verbatim",
+            )
+            for path in (
+                "config.reasoning.effort",
+                "provider_options[deepseek.chat_completions].reasoning_effort",
+            )
+        ),
+        SemanticShift(
+            kind="deepseek.reasoning_ignored",
+            path="messages[].parts[reasoning]",
+            note="provider ignores reasoning replay without tools",
+        ),
+        SemanticShift(
+            kind="deepseek.reasoning_ignored",
+            path="provider_options[deepseek.chat_completions].messages[].reasoning_content",
+            note="provider ignores reasoning replay without tools",
+        ),
+        SemanticShift(
+            kind="deepseek.reasoning_concatenated",
+            path="messages[].parts[reasoning]",
+            note="multiple reasoning parts concatenate into the native text lane",
+        ),
+    ),
+    note="canonical request to independently qualified DeepSeek compatible wire",
+)
+DECODE_REQUEST_CONTRACT = EdgeContract(
+    census={
+        "model": DeclaredDisposition(Disposition.EXTENSIONS),
+        "unmapped": DeclaredDisposition(Disposition.EXTENSIONS),
+        "tools[]": DeclaredDisposition(Disposition.EXTENSIONS),
+        "tool_choice": DeclaredDisposition(Disposition.EXTENSIONS),
+        "response_format": DeclaredDisposition(Disposition.EXTENSIONS),
+        "messages[].content[]": DeclaredDisposition(Disposition.EXTENSIONS),
+        "n": DeclaredDisposition(Disposition.UNSUPPORTED),
+    },
+    semantic_shifts=(
+        SemanticShift(
+            kind="relocation",
+            path="messages[]",
+            note="native tool message rethreads into a canonical tool turn",
+        ),
+    ),
+    note="DeepSeek request audit with exact native reasoning and unknown evidence",
+)
+DECODE_RESPONSE_CONTRACT = EdgeContract(
+    census={
+        "choices[0].message.content": DeclaredDisposition(Disposition.EXACT),
+        "choices[0].message.reasoning_content": DeclaredDisposition(Disposition.EXACT),
+        "choices[0].message.tool_calls[]": DeclaredDisposition(Disposition.EXACT),
+        "choices[0].finish_reason": DeclaredDisposition(Disposition.EXACT),
+        "choices[0].logprobs": DeclaredDisposition(Disposition.EXTENSIONS),
+        "unmapped": DeclaredDisposition(Disposition.EXTENSIONS),
+        "usage": DeclaredDisposition(
+            Disposition.EXTENSIONS,
+            "known disjoint counters map exactly; uncertain measurements remain evidence",
+        ),
+        "id": DeclaredDisposition(Disposition.EXACT),
+        "model": DeclaredDisposition(Disposition.EXACT),
+        "created": DeclaredDisposition(Disposition.RENAMED),
+    },
+    note="DeepSeek response to canonical text, reasoning, tools and measured usage",
+)
+EDGES = (
+    Edge(
+        canonical_node(CHAT_REQUEST),
+        CHAT_COMPLETIONS_REQUEST,
+        _CODEC.encode_request,
+        ENCODE_REQUEST_CONTRACT,
+        ORIGIN,
+    ),
+    Edge(
+        CHAT_COMPLETIONS_REQUEST,
+        canonical_node(CHAT_REQUEST),
+        _CODEC.decode_request,
+        DECODE_REQUEST_CONTRACT,
+        ORIGIN,
+    ),
+    Edge(
+        CHAT_COMPLETIONS_RESPONSE,
+        canonical_node(CHAT_RESPONSE),
+        _CODEC.decode_response,
+        DECODE_RESPONSE_CONTRACT,
+        ORIGIN,
+    ),
+)