llm-babel 0.1.0__tar.gz

llm_babel-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 - present Pydantic Services inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

llm_babel-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: llm-babel
+Version: 0.1.0
+Summary: One transform spec, compiled to Python/Rust/TypeScript, translating LLM requests between provider formats.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: pydantic>=2 ; extra == 'validation'
+Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/pydantic/babel
+Provides-Extra: validation
+Description-Content-Type: text/markdown
+
+# llm-babel
+
+Translate an LLM request, response, error, or stream between provider wire formats, and get the
+exact same result whether it runs in Python, Rust, or TypeScript.
+
+Every provider speaks a slightly different dialect on the wire. `llm-babel` routes everything
+through one neutral intermediate representation, so a format is one decoder plus one encoder
+rather than a converter per pair. The transforms are authored once as a small pure spec and
+compiled to plain Python, Rust, and TypeScript, proven byte-identical against a shared golden
+corpus that ships in this package.
+
+Formats: `openai-chat`, `openai-responses`, `anthropic-messages`, `bedrock-converse`, `gemini`,
+`mistral`, `deepseek`, `cohere`, plus the OpenAI-compatible providers (Groq, Cerebras, xAI,
+Z.AI, OpenRouter, HuggingFace) as routes over the `openai-chat` codec.
+
+## Install
+
+```bash
+pip install llm-babel                # the runtime: pure stdlib, no dependencies
+pip install "llm-babel[validation]"  # adds Pydantic for the typed, validating IR surface
+```
+
+The import name is `llm_transform`.
+
+## Use
+
+```python
+from llm_transform.registry import translate, decode, encode
+
+translate("openai-chat", "anthropic-messages", openai_request)  # source wire -> target wire
+decode("gemini", gemini_request)                                # any wire -> IR
+encode("bedrock-converse", ir)                                  # IR -> any wire
+```
+
+Responses, errors, and streams have the same shape of API (`translate_response`,
+`translate_error`, `fold_stream`), and `reconcile` fits a request to a target's declared
+capabilities before encoding.
+
+Re-run the proof against the corpus shipped in the wheel:
+
+```bash
+python -m llm_transform.corpus.runner
+```
+
+The same transforms are published for TypeScript as `@pydantic/llm-babel` on npm.

llm_babel-0.1.0/docs/pypi.md

@@ -0,0 +1,45 @@
+# llm-babel
+
+Translate an LLM request, response, error, or stream between provider wire formats, and get the
+exact same result whether it runs in Python, Rust, or TypeScript.
+
+Every provider speaks a slightly different dialect on the wire. `llm-babel` routes everything
+through one neutral intermediate representation, so a format is one decoder plus one encoder
+rather than a converter per pair. The transforms are authored once as a small pure spec and
+compiled to plain Python, Rust, and TypeScript, proven byte-identical against a shared golden
+corpus that ships in this package.
+
+Formats: `openai-chat`, `openai-responses`, `anthropic-messages`, `bedrock-converse`, `gemini`,
+`mistral`, `deepseek`, `cohere`, plus the OpenAI-compatible providers (Groq, Cerebras, xAI,
+Z.AI, OpenRouter, HuggingFace) as routes over the `openai-chat` codec.
+
+## Install
+
+```bash
+pip install llm-babel                # the runtime: pure stdlib, no dependencies
+pip install "llm-babel[validation]"  # adds Pydantic for the typed, validating IR surface
+```
+
+The import name is `llm_transform`.
+
+## Use
+
+```python
+from llm_transform.registry import translate, decode, encode
+
+translate("openai-chat", "anthropic-messages", openai_request)  # source wire -> target wire
+decode("gemini", gemini_request)                                # any wire -> IR
+encode("bedrock-converse", ir)                                  # IR -> any wire
+```
+
+Responses, errors, and streams have the same shape of API (`translate_response`,
+`translate_error`, `fold_stream`), and `reconcile` fits a request to a target's declared
+capabilities before encoding.
+
+Re-run the proof against the corpus shipped in the wheel:
+
+```bash
+python -m llm_transform.corpus.runner
+```
+
+The same transforms are published for TypeScript as `@pydantic/llm-babel` on npm.

llm_babel-0.1.0/llm_transform/capabilities.py

@@ -0,0 +1,199 @@
+"""Model/format capability matrix, data, not code.
+
+The research's clearest lesson (LiteLLM's `"claude-3-7-sonnet" in model`
+substring branching is its drift engine): keep per-model support facts in a data
+table that *gates* transforms and reconciliation, never as inline conditionals in
+the transform logic. A transform asks the matrix "does this target support X?"
+and applies the drop/error/emulate policy accordingly.
+
+Per-format defaults live in `CAPABILITIES`; per-model quirks that override a
+default (e.g. DeepSeek's reasoner silently ignoring sampling params and rejecting
+`logprobs`) live in `MODEL_CAPABILITIES`, and `capabilities_for(fmt, model)` prefers
+a model row over the format default.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+
+from llm_transform.router import ROUTES
+
+
+@dataclass(frozen=True)
+class Capabilities:
+    """What a target format/model can represent. Absence -> reconcile (drop/error/emulate)."""
+
+    system_prompt: bool = True
+    tools: bool = True
+    parallel_tools: bool = True
+    streaming: bool = True
+    # Media-input support, per kind. Default True (permissive, like a modern chat model);
+    # reconcile fails fast on a media kind the target can't accept rather than sending a
+    # doomed request. Set False only where a target is known not to accept that kind.
+    multimodal_image: bool = True
+    multimodal_audio: bool = True
+    multimodal_document: bool = True
+    multimodal_video: bool = True
+    image_url_source: bool = True  # Vertex-Anthropic: base64 only
+    reasoning: bool = False
+    prompt_caching: bool = False
+    structured_output_native: bool = False
+    multiple_candidates: bool = False  # OpenAI n>1; Anthropic/Converse cannot
+    tool_call_ids: bool = True  # Gemini has no tool-call id (matches by name)
+    logprobs: bool = False
+    max_tools: int | None = None
+    # provider_defined (server-side) tool ids this target can execute, web search,
+    # code interpreter, etc. Reconcile errors on a requested provider_defined tool whose
+    # id isn't listed (the target's API would reject it). Ids are provider-specific wire
+    # ids (`web_search_20250305`, `web_search_preview`), not a canonical taxonomy.
+    builtin_tools: frozenset[str] = field(default_factory=frozenset)
+    # params the target silently ignores (DeepSeek reasoner: temperature/top_p/penalties)
+    silently_ignored_params: frozenset[str] = field(default_factory=frozenset)
+    # params the target hard-errors on (DeepSeek reasoner: logprobs)
+    rejected_params: frozenset[str] = field(default_factory=frozenset)
+
+
+# The per-format defaults, keyed by format name. Per-model quirks that override a
+# format default live in `MODEL_CAPABILITIES` below; `capabilities_for(fmt, model)`
+# prefers a model row when one exists, else falls back to this table.
+CAPABILITIES: dict[str, Capabilities] = {
+    'openai-chat': Capabilities(
+        reasoning=True,
+        structured_output_native=True,
+        multiple_candidates=True,
+        logprobs=True,
+        multimodal_video=False,  # image / audio (gpt-4o-audio) / file, no video in chat completions
+    ),
+    'anthropic-messages': Capabilities(
+        reasoning=True,
+        prompt_caching=True,
+        image_url_source=True,
+        multiple_candidates=False,
+        multimodal_audio=False,  # image + PDF document only, no audio/video input
+        multimodal_video=False,
+        builtin_tools=frozenset({'web_search_20250305', 'memory_20250818', 'code_execution_20250522'}),
+        # No OpenAI-style sampling extras, reconciling to Anthropic drops them.
+        silently_ignored_params=frozenset({'seed', 'presence_penalty', 'frequency_penalty', 'logit_bias'}),
+    ),
+    'bedrock-converse': Capabilities(
+        prompt_caching=True,
+        image_url_source=False,  # Converse takes bytes, not image URLs
+        multiple_candidates=False,  # Converse cannot do n>1
+        multimodal_audio=False,  # Converse: image / document / video blocks, no audio
+        silently_ignored_params=frozenset({'seed', 'presence_penalty', 'frequency_penalty', 'logit_bias', 'top_p'}),
+    ),
+    'gemini': Capabilities(
+        reasoning=True,
+        structured_output_native=True,
+        image_url_source=False,  # inlineData is base64 bytes
+        multiple_candidates=True,  # candidateCount > 1
+        tool_call_ids=False,  # no tool-call id; correlated by name
+    ),
+    'cohere': Capabilities(
+        reasoning=True,  # v2 `thinking` content chunks
+        structured_output_native=True,  # response_format json_object/json_schema
+        multiple_candidates=False,  # a single `message`, no n>1
+        silently_ignored_params=frozenset({'logit_bias', 'service_tier', 'parallel_tool_calls'}),
+    ),
+    'mistral': Capabilities(
+        structured_output_native=True,  # response_format json_schema (custom structured output)
+        multiple_candidates=True,  # `n` > 1
+        multimodal_audio=False,  # Pixtral image + document OCR, no audio/video input
+        multimodal_video=False,
+        # Mistral has no logit_bias / service_tier / parallel_tool_calls / top_k,
+        # reconciling to Mistral drops them.
+        silently_ignored_params=frozenset({'top_k', 'logit_bias', 'service_tier', 'parallel_tool_calls'}),
+    ),
+    'deepseek': Capabilities(
+        reasoning=True,  # reasoner surfaces chain-of-thought in `reasoning_content`
+        multimodal_image=False,  # text-only
+        multimodal_audio=False,
+        multimodal_document=False,
+        multimodal_video=False,
+        structured_output_native=False,  # JSON mode only (json_object); schema -> emulate
+        multiple_candidates=False,
+        logprobs=True,
+        # No seed / logit_bias / service_tier / parallel_tool_calls / top_k on the wire.
+        silently_ignored_params=frozenset({'seed', 'logit_bias', 'service_tier', 'parallel_tool_calls', 'top_k'}),
+    ),
+    'openai-responses': Capabilities(
+        reasoning=True,  # `reasoning` output items (o-series), decoded/encoded
+        structured_output_native=True,  # native via `text.format` (encode/decode round-trip)
+        prompt_caching=True,  # usage.input_tokens_details.cached_tokens
+        multiple_candidates=False,  # one `output` list, no n>1
+        multimodal_audio=False,  # input_image + input_file, no audio/video input
+        multimodal_video=False,
+        builtin_tools=frozenset({'web_search_preview', 'file_search', 'code_interpreter'}),
+    ),
+    # --- OpenAI-compatible providers (share the openai-chat codec via router body_format) -----------
+    # Conservative baselines: each supports function tools + JSON structured output and hosts reasoning
+    # models (CoT in `reasoning`/`reasoning_content`, both now decoded by openai-chat). `n>1` and
+    # `logprobs` are left off (default) so reconcile fails safe rather than sending a param the target
+    # may reject; per-model precision (a text-only or non-reasoning model) is a MODEL_CAPABILITIES row.
+    'groq': Capabilities(reasoning=True, structured_output_native=True),
+    'cerebras': Capabilities(reasoning=True, structured_output_native=True),
+    'xai': Capabilities(reasoning=True, structured_output_native=True, prompt_caching=True),
+    'zai': Capabilities(reasoning=True, structured_output_native=True),  # GLM thinking -> reasoning_content
+    'openrouter': Capabilities(reasoning=True, structured_output_native=True),  # aggregator; caps vary by routed model
+    'huggingface': Capabilities(reasoning=True, structured_output_native=True),  # HF router; caps vary by model
+}
+
+
+# Per-model overrides, keyed by model id. The "models explode" axis: a model that
+# shares a format's wire but differs in what it accepts lands as ONE data row
+# here, no transform code changes. DeepSeek's reasoner speaks the OpenAI wire but
+# silently ignores sampling params and hard-errors on logprobs; that is data, not
+# a `"deepseek" in model` branch (LiteLLM's drift engine).
+# A model row REPLACES the format row wholesale (see `capabilities_for`), so build
+# each from its format's caps with `replace(...)`, otherwise it silently reverts every
+# unspecified field to the dataclass default (e.g. `multimodal_image=True`), losing the
+# format's own facts (DeepSeek is text-only, JSON-mode-only, and ignores several params).
+# Deployment variants (gemini-vertex -> gemini, openai-azure -> openai-chat) serve an existing
+# codec's *body* at a different endpoint/auth, so their support facts ARE that codec's. Fill a caps
+# row for any route whose body_format differs and lacks an explicit row of its own (the
+# OpenAI-compatible providers customize theirs, so they keep their rows), instead of falling back to
+# the permissive default and mis-gating reconcile. Generated to every backend via CAPABILITIES.
+for _name, _route in ROUTES.items():
+    if _route.body_format and _route.body_format != _name and _name not in CAPABILITIES:
+        _codec_caps = CAPABILITIES.get(_route.body_format)
+        if _codec_caps is not None:
+            CAPABILITIES[_name] = _codec_caps
+
+
+_DEEPSEEK = CAPABILITIES['deepseek']
+MODEL_CAPABILITIES: dict[str, Capabilities] = {
+    # The reasoner additionally silently-ignores sampling params and hard-errors on
+    # `logprobs`; everything else (text-only, no schema, etc.) inherits the format.
+    'deepseek-reasoner': replace(
+        _DEEPSEEK,
+        tools=False,  # the reasoner has no function calling (per DeepSeek reasoning-model docs)
+        silently_ignored_params=_DEEPSEEK.silently_ignored_params | {'temperature', 'top_p'},
+        rejected_params=frozenset({'logprobs'}),
+    ),
+    # deepseek-chat matches the format facts (text-only, JSON-mode-only, no json_schema,
+    # so structured output is emulated); kept explicit for discoverability.
+    'deepseek-chat': replace(_DEEPSEEK),
+}
+
+
+def capabilities_for(fmt: str, model: str | None = None) -> Capabilities:
+    """Capabilities of a translation *target*. A per-model row (if any) wins over
+    the format default; unknown models fall back to the format's capabilities."""
+    if model is not None and model in MODEL_CAPABILITIES:
+        return MODEL_CAPABILITIES[model]
+    return CAPABILITIES.get(fmt, Capabilities())
+
+
+# The canonical `IRError` kinds worth retrying, the cross-library consensus (HTTP 408/409/429/≥500):
+# transient rate-limit / overload / server / transport failures. Everything else (bad request, auth,
+# context-length, content-filter, quota) is terminal. Lives here so it ships to every backend as data
+# alongside the capability facts (`error_is_retryable`), rather than being re-hand-written per language.
+RETRYABLE_ERROR_KINDS: frozenset[str] = frozenset(
+    {'rate_limit', 'overloaded', 'server_error', 'timeout', 'connection'}
+)
+
+
+def error_is_retryable(kind: str) -> bool:
+    """Whether a canonical error `kind` is worth retrying, a pure, total fact over
+    `RETRYABLE_ERROR_KINDS`. `retryable` is *derived* from `kind`, never stored on the error."""
+    return kind in RETRYABLE_ERROR_KINDS

llm_babel-0.1.0/llm_transform/conformance.py

@@ -0,0 +1,100 @@
+"""Conformance oracle, is a host's native provider mapping equivalent to babel's?
+
+Pure and host-agnostic. Give it two wire values (a host's *native* mapper output and
+babel's `encode()` output) and it reports whether they're equivalent, normalizing the
+differences that are serialization *convention*, not mapping *semantics*:
+
+  - tool-call `arguments` re-serialized key-sorted (a host that forwards the raw JSON
+    string vs babel canonicalizing the parsed value, same object),
+  - optionally camelCase<->snake_case (a vendor SDK's dict types vs the REST wire).
+
+This is the conformance wedge: a **test-only** dependency. A host, pydantic-ai,
+a gateway, runs its own mapper and babel's over the same inputs and asserts
+`conforms(...).identical`, catching drift in either, with zero runtime dependency and no
+DSL. The oracle reports the raw structured deltas; whether a given delta is *acceptable*
+(a documented valid-form / SDK-convention difference) is the host's policy to apply.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+_ARG_KEYS = ('arguments', 'args')  # tool-call argument payloads (values kept opaque)
+
+
+def _camel_to_snake(k: str) -> str:
+    return re.sub(r'([A-Z])', r'_\1', k).lower()
+
+
+def normalize(value: Any, *, snake_case: bool = False) -> Any:
+    """A canonical, comparable form of a wire `value`: tool-call `arguments`/`args`
+    re-serialized key-sorted, and (optionally) every structural key lowered to snake_case.
+    Argument *values* stay opaque, only their own serialization is canonicalized, so
+    user data (a tool arg `{cityName: ...}`) is never mangled."""
+    def walk(v: Any, *, in_args: bool = False) -> Any:
+        if isinstance(v, dict):
+            out = {}
+            for k, val in v.items():
+                key = _camel_to_snake(k) if (snake_case and not in_args) else k
+                if k in _ARG_KEYS and isinstance(val, str):
+                    try:
+                        val = json.dumps(json.loads(val), sort_keys=True)
+                    except (ValueError, TypeError):
+                        pass
+                    out[key] = val
+                else:
+                    out[key] = walk(val, in_args=in_args or k in _ARG_KEYS)
+            return out
+        if isinstance(v, list):
+            return [walk(i, in_args=in_args) for i in v]
+        return v
+
+    return walk(json.loads(json.dumps(value, default=str)))
+
+
+@dataclass(frozen=True)
+class Delta:
+    """One structural difference, located by a JSON-ish path."""
+    path: str
+    ours: Any
+    native: Any
+
+
+@dataclass
+class ConformanceResult:
+    identical: bool
+    deltas: list[Delta] = field(default_factory=list)
+
+    def __bool__(self) -> bool:
+        return self.identical
+
+
+def _diff(ours: Any, native: Any, path: str, out: list[Delta]) -> None:
+    if isinstance(ours, dict) and isinstance(native, dict):
+        for k in sorted(set(ours) | set(native)):
+            _diff(ours.get(k, _MISSING), native.get(k, _MISSING), f'{path}.{k}' if path else k, out)
+    elif isinstance(ours, list) and isinstance(native, list):
+        if len(ours) != len(native):
+            out.append(Delta(f'{path}[len]', len(ours), len(native)))
+        for i in range(min(len(ours), len(native))):
+            _diff(ours[i], native[i], f'{path}[{i}]', out)
+    elif ours != native:
+        out.append(Delta(path or '<root>', ours, native))
+
+
+_MISSING = object()
+
+
+def conforms(ours: Any, native: Any, *, snake_case: bool = False) -> ConformanceResult:
+    """Compare babel's wire output (`ours`) to a native mapper's (`native`), normalizing
+    serialization convention. Returns `identical` plus the structured deltas that remain,
+    the host decides which of those are acceptable (documented valid-form / SDK deltas)."""
+    a, b = normalize(ours, snake_case=snake_case), normalize(native, snake_case=snake_case)
+    if a == b:
+        return ConformanceResult(identical=True)
+    deltas: list[Delta] = []
+    _diff(a, b, '', deltas)
+    return ConformanceResult(identical=False, deltas=deltas)

llm_babel-0.1.0/llm_transform/corpus/cases/anthropic_encode__empty_text_block_stripped.json

@@ -0,0 +1,66 @@
+{
+  "name": "anthropic_encode__empty_text_block_stripped",
+  "tags": [
+    "text",
+    "empty",
+    "filter",
+    "encode"
+  ],
+  "source": "anthropic-messages",
+  "target": "anthropic-messages",
+  "input_wire": {
+    "model": "claude-haiku-4-5",
+    "max_tokens": 64,
+    "messages": [
+      {
+        "role": "user",
+        "content": [
+          {
+            "type": "text",
+            "text": "Hello"
+          },
+          {
+            "type": "text",
+            "text": ""
+          }
+        ]
+      }
+    ]
+  },
+  "expected_ir": {
+    "messages": [
+      {
+        "content": [
+          {
+            "kind": "text",
+            "text": "Hello"
+          },
+          {
+            "kind": "text",
+            "text": ""
+          }
+        ],
+        "role": "user"
+      }
+    ],
+    "model": "claude-haiku-4-5",
+    "params": {
+      "max_tokens": 64
+    }
+  },
+  "expected_out_wire": {
+    "max_tokens": 64,
+    "messages": [
+      {
+        "content": [
+          {
+            "text": "Hello",
+            "type": "text"
+          }
+        ],
+        "role": "user"
+      }
+    ],
+    "model": "claude-haiku-4-5"
+  }
+}

llm_babel-0.1.0/llm_transform/corpus/cases/anthropic_encode__multimodal_image_document.json

@@ -0,0 +1,124 @@
+{
+  "name": "anthropic_encode__multimodal_image_document",
+  "tags": [
+    "anthropic",
+    "multimodal",
+    "encode",
+    "roundtrip"
+  ],
+  "source": "anthropic-messages",
+  "target": "anthropic-messages",
+  "input_wire": {
+    "max_tokens": 1024,
+    "messages": [
+      {
+        "content": [
+          {
+            "text": "look at these",
+            "type": "text"
+          },
+          {
+            "source": {
+              "data": "aW1n",
+              "media_type": "image/png",
+              "type": "base64"
+            },
+            "type": "image"
+          },
+          {
+            "source": {
+              "type": "url",
+              "url": "https://ex.com/a.png"
+            },
+            "type": "image"
+          },
+          {
+            "source": {
+              "data": "ZG9j",
+              "media_type": "application/pdf",
+              "type": "base64"
+            },
+            "type": "document"
+          }
+        ],
+        "role": "user"
+      }
+    ],
+    "model": "m"
+  },
+  "expected_ir": {
+    "messages": [
+      {
+        "content": [
+          {
+            "kind": "text",
+            "text": "look at these"
+          },
+          {
+            "data": "aW1n",
+            "kind": "file",
+            "media_kind": "image",
+            "media_type": "image/png",
+            "source": "base64"
+          },
+          {
+            "data": "https://ex.com/a.png",
+            "kind": "file",
+            "media_kind": "image",
+            "source": "url"
+          },
+          {
+            "data": "ZG9j",
+            "kind": "file",
+            "media_kind": "document",
+            "media_type": "application/pdf",
+            "source": "base64"
+          }
+        ],
+        "role": "user"
+      }
+    ],
+    "model": "m",
+    "params": {
+      "max_tokens": 1024
+    }
+  },
+  "expected_out_wire": {
+    "max_tokens": 1024,
+    "messages": [
+      {
+        "content": [
+          {
+            "text": "look at these",
+            "type": "text"
+          },
+          {
+            "source": {
+              "data": "aW1n",
+              "media_type": "image/png",
+              "type": "base64"
+            },
+            "type": "image"
+          },
+          {
+            "source": {
+              "type": "url",
+              "url": "https://ex.com/a.png"
+            },
+            "type": "image"
+          },
+          {
+            "source": {
+              "data": "ZG9j",
+              "media_type": "application/pdf",
+              "type": "base64"
+            },
+            "type": "document"
+          }
+        ],
+        "role": "user"
+      }
+    ],
+    "model": "m"
+  }
+}

llm_babel-0.1.0/llm_transform/corpus/cases/anthropic_messages_error__authentication.json

@@ -0,0 +1,30 @@
+{
+  "name": "anthropic_messages_error__authentication",
+  "kind": "error",
+  "tags": [
+    "anthropic",
+    "error",
+    "auth"
+  ],
+  "source": "anthropic-messages",
+  "target": "anthropic-messages",
+  "input_wire": {
+    "type": "error",
+    "error": {
+      "type": "authentication_error",
+      "message": "invalid x-api-key"
+    }
+  },
+  "expected_ir": {
+    "kind": "authentication",
+    "message": "invalid x-api-key",
+    "provider_code": "authentication_error"
+  },
+  "expected_out_wire": {
+    "type": "error",
+    "error": {
+      "type": "authentication_error",
+      "message": "invalid x-api-key"
+    }
+  }
+}

llm_babel-0.1.0/llm_transform/corpus/cases/anthropic_messages_error__overloaded.json

@@ -0,0 +1,30 @@
+{
+  "name": "anthropic_messages_error__overloaded",
+  "kind": "error",
+  "tags": [
+    "anthropic",
+    "error",
+    "overloaded"
+  ],
+  "source": "anthropic-messages",
+  "target": "anthropic-messages",
+  "input_wire": {
+    "type": "error",
+    "error": {
+      "type": "overloaded_error",
+      "message": "Overloaded"
+    }
+  },
+  "expected_ir": {
+    "kind": "overloaded",
+    "message": "Overloaded",
+    "provider_code": "overloaded_error"
+  },
+  "expected_out_wire": {
+    "type": "error",
+    "error": {
+      "type": "overloaded_error",
+      "message": "Overloaded"
+    }
+  }
+}