Skip to content

armgit / dspy

Public Imported from GitHub
0

DSPy: The framework for programming—not prompting—language models

Python

chore: sync vendored lm15 with upstream (#10469)

Isaac Miller43599957b6bb
diff --git a/dspy/_vendor/lm15-provenance.txt b/dspy/_vendor/lm15-provenance.txt
index 6e978af9f..fe0e7f89b 100644
--- a/dspy/_vendor/lm15-provenance.txt
+++ b/dspy/_vendor/lm15-provenance.txt
@@ -1,5 +1,5 @@
source=https://github.com/cmpnd-ai/lm15-python.git
version=1.0.0rc3
-commit=a550dab27333a1cb6a4a163c20577edab9fa872e
-contract=7677980e36c8bd0b14ae9bfc79e49446f403ad22
-split=8c8b885e05738b141cbc4a2691f0772966927f0c
+commit=55fce2e61a04ed3193acfeb8797b7c58d1b55398
+contract=b721ce4f03877d72a91431b3a5ce653ffc0b3e38
+split=63b6bb319f38ad1d31060138da54cb8ac8718711
diff --git a/dspy/_vendor/lm15/__init__.py b/dspy/_vendor/lm15/__init__.py
index cf26a5b51..63287be3b 100644
--- a/dspy/_vendor/lm15/__init__.py
+++ b/dspy/_vendor/lm15/__init__.py
@@ -88,6 +88,7 @@ from .types import (
BinaryPart,
ToolCallPart,
ToolResultPart,
+ DataPart,
# tools
FunctionTool,
BuiltinTool,
@@ -177,6 +178,7 @@ from .providers import (
ClaudeCodeLM,
OpenAICodexLM,
XaiLM,
+ TypeSafeLM,
)
from .providers.openai_chat import request_from_openai_chat, response_from_openai_chat
from .protocols import ProviderLM
@@ -188,6 +190,7 @@ from .providers.async_base import (
AsyncClaudeCodeLM,
AsyncOpenAICodexLM,
AsyncXaiLM,
+ AsyncTypeSafeLM,
)
# ── Stream assembly ──────────────────────────────────────────────────
@@ -229,13 +232,17 @@ from .tools import (
)
from .tools import derive as derive_tool
+# ── Judgments (changes/2026-09-17-judgments.md) ─────────────────────
+from .judgments import choice, judgments, score, yes_no
+from .types import data
+
__all__ = [
"__version__",
# core
"Request", "Response", "Message", "Usage", "Config", "CacheConfig",
"Reasoning", "ToolChoice", "ErrorDetail", "ContinuationState",
# parts
- "TextPart", "ThinkingPart", "RefusalPart", "CitationPart", "ImagePart",
+ "TextPart", "ThinkingPart", "RefusalPart", "CitationPart", "DataPart", "ImagePart",
"AudioPart", "VideoPart", "DocumentPart", "BinaryPart", "ToolCallPart",
"ToolResultPart",
# tools
@@ -266,7 +273,8 @@ __all__ = [
"NotConfiguredError", "RETRYABLE_ERRORS",
"AccessPolicy", "EndpointSupport",
# providers
- "OpenAILM", "OpenAIChatLM", "AnthropicLM", "GeminiLM", "ClaudeCodeLM", "OpenAICodexLM", "XaiLM",
+ "choice", "judgments", "score", "yes_no", "data",
+ "OpenAILM", "OpenAIChatLM", "AnthropicLM", "GeminiLM", "ClaudeCodeLM", "OpenAICodexLM", "XaiLM", "TypeSafeLM", "AsyncTypeSafeLM",
"ProviderLM",
# the Chat Completions dialect read in: a request body -> Request (MAP-12), a response body -> Response
"request_from_openai_chat", "response_from_openai_chat",
diff --git a/dspy/_vendor/lm15/_authlock.py b/dspy/_vendor/lm15/_authlock.py
index 63b49a53c..243508a76 100644
--- a/dspy/_vendor/lm15/_authlock.py
+++ b/dspy/_vendor/lm15/_authlock.py
@@ -27,11 +27,15 @@ Stated limitations (these are trade-offs, not oversights):
from __future__ import annotations
+import errno
+import errno
import hashlib
import json
import os
+import stat
import tempfile
import time
+from collections import deque
from contextlib import contextmanager
from pathlib import Path
from typing import Any, Iterator
@@ -71,14 +75,125 @@ def _lock_dir() -> Path:
return base / "lm15" / "locks"
-def lock_path_for(path: Path) -> Path:
- """Deterministic lock-file path for a guarded credential file.
+def _strip_windows_verbatim(path: str) -> str:
+ path = path.replace("/", "\\")
+ if path[:8].lower() == "\\\\?\\unc\\":
+ return "\\\\" + path[8:]
+ if path.startswith("\\\\?\\"):
+ rest = path[4:]
+ if len(rest) < 3 or not rest[0].isascii() or not rest[0].isalpha() or rest[1:3] != ":\\":
+ raise ValueError("Unsupported Windows credential path namespace")
+ return rest
+ return path
- Keyed by the guarded file's absolute (not resolved-through-symlink
- ``strict``) path so all lm15 processes agree on the same lock file even
- before the credential file exists.
+
+def _windows_identity_key(canonical: str) -> str:
+ """Pure key spelling, also testable on POSIX; no lexical path resolution.
+
+ Windows migration: old and new SDK processes MUST NOT overlap. Removing
+ verbatim prefixes and lowercasing changes previously published lock names.
+ Like normcase, lowercase deliberately overlocks case-sensitive directories.
+ Use Unicode string lowercase (not casefold or locale-sensitive lowercase)
+ in all SDKs, including Rust's str::to_lowercase.
+ """
+ return _strip_windows_verbatim(canonical).lower()
+
+
+def _real_path_allow_missing(target: str) -> str:
+ """Resolve components in filesystem order; only ENOENT is recoverable.
+
+ Unlike abspath/normpath, never collapse symlink/.. before reading the
+ link. A missing component does not stop the walk: later .. can return
+ to an existing ancestor. Forty link expansions bound loops in every SDK.
+ """
+ windows = os.name == "nt"
+
+ def parts(value: str, base: str) -> tuple[str, deque[str]]:
+ if "\0" in value:
+ raise ValueError("NUL in credential path")
+ # Refuse unpaired surrogates rather than hash a lossy encoding.
+ value.encode("utf-8")
+ if windows:
+ value = _strip_windows_verbatim(value)
+ drive, tail = os.path.splitdrive(value)
+ unc = drive.startswith("\\\\")
+ if value.startswith("\\\\.\\") or (drive and not unc and not tail.startswith("\\")):
+ raise ValueError("Unsupported Windows credential path namespace or drive-relative path")
+ if unc:
+ roots = drive[2:].split("\\")
+ if len(roots) != 2 or any(not p or not p.isascii() or p in (".", "..") or "?" in p or ":" in p or p.endswith((".", " ")) for p in roots):
+ raise ValueError("Unsupported Windows credential path root")
+ elif drive and not (len(drive) == 2 and drive[1] == ":" and drive[0].isascii() and drive[0].isalpha()):
+ raise ValueError("Unsupported Windows credential path root")
+ if tail.startswith("\\") or unc:
+ base = (drive or os.path.splitdrive(base)[0]) + "\\"
+ base = _strip_windows_verbatim(os.path.realpath(base, strict=True))
+ names = deque(p for p in tail.split("\\") if p)
+ for name in names:
+ if name in (".", ".."):
+ continue
+ stem = name.split(".", 1)[0].upper()
+ if (name.endswith((".", " ")) or ":" in name
+ or stem in {"CON", "PRN", "AUX", "NUL", "CONIN$", "CONOUT$"}
+ or (len(stem) == 4 and stem[:3] in {"COM", "LPT"}
+ and stem[3] in "123456789¹²³")):
+ raise ValueError("Unsupported Windows credential path component")
+ else:
+ if value.startswith("/"):
+ base = "/"
+ names = deque(p for p in value.split("/") if p)
+ return base, names
+
+ if target.startswith("~") and target != "~" and not target.startswith(("~/", "~\\") if windows else ("~/",)):
+ raise ValueError("Named-user home expansion is unsupported for credential locks")
+ target = os.path.expanduser(target)
+ if target == "~" or target.startswith("~/") or (windows and target.startswith("~\\")):
+ raise ValueError("No home directory for credential lock path")
+ cwd = os.path.realpath(os.getcwd(), strict=True)
+ resolved, pending = parts(target, _strip_windows_verbatim(cwd) if windows else cwd)
+ links = 0
+ while pending:
+ name = pending.popleft()
+ if name == ".":
+ continue
+ if name == "..":
+ resolved = os.path.dirname(resolved)
+ continue
+ candidate = os.path.join(resolved, name)
+ try:
+ info = os.lstat(candidate)
+ except FileNotFoundError:
+ # Windows compares with filesystem upcase tables, not Unicode
+ # lowercase (e.g. sigma/final sigma). With no on-disk spelling
+ # to canonicalize, refuse non-ASCII rather than risk underlocking.
+ if windows and not name.isascii():
+ raise ValueError("Missing non-ASCII Windows credential path component is unsupported") from None
+ resolved = candidate
+ continue
+ if stat.S_ISLNK(info.st_mode) or (windows and getattr(info, "st_reparse_tag", 0) == 0xA0000003):
+ links += 1
+ if links > 40:
+ raise OSError(errno.ELOOP, "Too many credential path symlinks", target)
+ resolved, linked = parts(os.readlink(candidate), resolved)
+ linked.extend(pending)
+ pending = linked
+ else:
+ if pending and not stat.S_ISDIR(info.st_mode):
+ raise NotADirectoryError(errno.ENOTDIR, "Credential path ancestor is not a directory", candidate)
+ resolved = _strip_windows_verbatim(os.path.realpath(candidate, strict=True)) if windows else candidate
+ return resolved
+
+
+def lock_path_for(path: str | os.PathLike[str]) -> Path:
+ """AUTH-4 lock identity, including missing leaves and dangling symlinks.
+
+ Ordinary POSIX realpath hashes are unchanged. Resolution errors fail
+ closed; a guessed identity must never allow concurrent credential refresh.
+ Windows old/new processes must not overlap (see _windows_identity_key).
"""
- canonical = os.path.realpath(os.path.expanduser(str(path)))
+ canonical = _real_path_allow_missing(os.fspath(path))
+ if os.name == "nt":
+ canonical = _windows_identity_key(canonical)
digest = hashlib.sha256(canonical.encode("utf-8")).hexdigest()[:32]
return _lock_dir() / f"{digest}.lock"
@@ -102,8 +217,10 @@ if fcntl is not None:
try:
fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
return True
- except OSError:
- return False
+ except OSError as exc:
+ if exc.errno in (errno.EACCES, errno.EAGAIN):
+ return False
+ raise NotConfiguredError("The filesystem could not acquire a credential lock; use a local locking-capable filesystem or an explicit credential") from exc
def _unlock(fd: int) -> None:
fcntl.flock(fd, fcntl.LOCK_UN)
@@ -114,8 +231,10 @@ elif msvcrt is not None: # pragma: no cover - exercised only on Windows
try:
msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
return True
- except OSError:
- return False
+ except OSError as exc:
+ if exc.errno in (errno.EACCES, errno.EAGAIN, errno.EDEADLK):
+ return False
+ raise NotConfiguredError("The filesystem could not acquire a credential lock; use a local locking-capable filesystem or an explicit credential") from exc
def _unlock(fd: int) -> None:
try:
@@ -152,7 +271,7 @@ def hold_file_lock(
that already holds the lock must not re-enter; internal callers use the
``*_unlocked`` write variants for that reason.
"""
- lock_file = lock_path_for(Path(path))
+ lock_file = lock_path_for(path)
lock_file.parent.mkdir(parents=True, exist_ok=True)
fd = os.open(lock_file, os.O_RDWR | os.O_CREAT, 0o600)
try:
@@ -162,8 +281,8 @@ def hold_file_lock(
raise CredentialLockTimeout(
f"Could not lock credential file {path} within {timeout_s:.0f}s "
f"(lock file: {lock_file}). Another process may be refreshing "
- "the same credential; retry, or remove a stale lock only if "
- "you are certain no other process holds it.",
+ "the same credential; retry after it finishes or stop the holder. "
+ "Never delete a lock file while processes may be using it.",
path=str(path),
lock_path=str(lock_file),
)
diff --git a/dspy/_vendor/lm15/access.py b/dspy/_vendor/lm15/access.py
index e28570453..7539efbef 100644
--- a/dspy/_vendor/lm15/access.py
+++ b/dspy/_vendor/lm15/access.py
@@ -76,6 +76,17 @@ ANTHROPIC_API = AccessPolicy(
auth_scheme=("x-api-key",),
)
+# TypeSafe System One (Jev): one judgment call per request, no stream, a
+# models list (changes/2026-09-17-judgments.md D1/D10/D11; receipts
+# 2026-09-17). Bearer key from the console (console.typesafe.ai/keys).
+TYPESAFE_API = AccessPolicy(
+ provider="typesafe",
+ supports=EndpointSupport(complete=True, stream=False, models=True),
+ auth_modes=("bearer",),
+ env_keys=("TYPESAFE_API_KEY",),
+ auth_scheme=("bearer",),
+)
+
DEFAULT_CLAUDE_CODE_VERSION = "2.1.170"
DEFAULT_CLAUDE_CODE_SYSTEM_PROMPT = "You are Claude Code, Anthropic's official CLI for Claude."
@@ -340,6 +351,23 @@ MOONSHOTAI_ANTHROPIC = AccessPolicy(
# use of the ``backend`` seam: the dialect is unchanged; the door changes
# the URL, the signing, a closed set of rewrites, and the stream framing.
+# Endpoint overrides (AUTH-10, amended 2026-09-19): the vendor's own
+# variables naming a full URL root for a door, consulted by the router
+# after an explicit ``base_urls`` entry and before the ``{resource}`` /
+# ``{region}`` template. AWS: ``AWS_ENDPOINT_URL_<SERVICE_ID>`` then the
+# generic ``AWS_ENDPOINT_URL`` (aws-sdkref-endpoints.md; the service id is
+# the SigV4 service name upper-cased with ``-`` → ``_``, the SDK's rule —
+# ``BEDROCK_MANTLE`` and ``AWS_EXTERNAL_ANTHROPIC`` follow the rule, not a
+# cited page). Azure OpenAI: ``AZURE_OPENAI_ENDPOINT`` (the OpenAI SDK's
+# ``AzureOpenAI`` reads it). Foundry Claude: ``ANTHROPIC_FOUNDRY_BASE_URL``
+# (anthropic-on-foundry.md:180-182). Vertex: no vendor variable is cited;
+# ``base_urls`` only.
+_AWS_ENDPOINT = ("AWS_ENDPOINT_URL_BEDROCK_RUNTIME", "AWS_ENDPOINT_URL")
+_AWS_MANTLE_ENDPOINT = ("AWS_ENDPOINT_URL_BEDROCK_MANTLE", "AWS_ENDPOINT_URL")
+_AWS_ANTHROPIC_ENDPOINT = ("AWS_ENDPOINT_URL_AWS_EXTERNAL_ANTHROPIC", "AWS_ENDPOINT_URL")
+_AZURE_OPENAI_ENDPOINT = ("AZURE_OPENAI_ENDPOINT",)
+_AZURE_FOUNDRY_ENDPOINT = ("ANTHROPIC_FOUNDRY_BASE_URL",)
+
_AWS_REGION = HostSetting("region", env=("AWS_REGION", "AWS_DEFAULT_REGION")) # no default: a wrong region is a residency bug
_AWS_WORKSPACE = HostSetting("workspace", env=("ANTHROPIC_AWS_WORKSPACE_ID",))
_GCP_PROJECT = HostSetting("project", env=("GOOGLE_CLOUD_PROJECT", "GCLOUD_PROJECT"))
@@ -366,6 +394,7 @@ AWS_ANTHROPIC = AccessPolicy(
settings=(_AWS_REGION, _AWS_WORKSPACE),
required_headers=(("anthropic-workspace-id", "workspace"),),
sigv4_service="aws-external-anthropic",
+ endpoint_env=_AWS_ANTHROPIC_ENDPOINT,
),
)
@@ -386,6 +415,7 @@ BEDROCK_ANTHROPIC = AccessPolicy(
base_url="https://bedrock-mantle.{region}.api.aws/anthropic/v1",
settings=(_AWS_REGION,),
sigv4_service="bedrock-mantle",
+ endpoint_env=_AWS_MANTLE_ENDPOINT,
),
)
@@ -410,6 +440,7 @@ BEDROCK_CHAT = AccessPolicy(
base_url="https://bedrock-runtime.{region}.amazonaws.com/openai/v1",
settings=(_AWS_REGION,),
sigv4_service="bedrock",
+ endpoint_env=_AWS_ENDPOINT,
),
)
@@ -433,6 +464,7 @@ BEDROCK_MANTLE_CHAT = AccessPolicy(
base_url="https://bedrock-mantle.{region}.api.aws/v1",
settings=(_AWS_REGION,),
sigv4_service="bedrock-mantle",
+ endpoint_env=_AWS_MANTLE_ENDPOINT,
),
)
@@ -443,6 +475,18 @@ BEDROCK_MANTLE_CHAT = AccessPolicy(
# listing control-plane only, but GET /openai/v1/models answers 200 with the
# api-key — the resource's whole catalog (dall-e, whisper, gpt-*), not just its
# deployments (receipts/2026-09-04-azure/models.json; cases/azure/models.json).
+#
+# Host, decided 2026-09-19 (changes/2026-09-19-cloud-identity-and-endpoints.md
+# D5): the template stays `{resource}.openai.azure.com` because it is the
+# one host every resource kind answers on — a classic `OpenAI`-kind
+# resource has no `services.ai.azure.com` name at all (DNS: NXDOMAIN for
+# the lab's lm15-oai-* resource, 2026-09-19), while a Foundry
+# (`AIServices`) resource answers on both. The Foundry console shows
+# `https://{account}.services.ai.azure.com`: paste it as
+# AZURE_OPENAI_ENDPOINT (or base_urls={"azure": ...}) and the door appends
+# /openai/v1. That endpoint serves OpenAI and non-OpenAI deployments
+# alike; the alias saves one internal hop for OpenAI models today
+# (issue #10, Pamela Fox, 2026-09-18).
AZURE = AccessPolicy(
provider="azure",
# Live 2026-09-04 on an OpenAI-kind Azure resource: Files and Batches
@@ -458,6 +502,7 @@ AZURE = AccessPolicy(
host=HostSpec(
base_url="https://{resource}.openai.azure.com/openai/v1",
settings=(_AZURE_OPENAI_RESOURCE, _AZURE_AUTHORITY, _AZURE_SCOPE),
+ endpoint_env=_AZURE_OPENAI_ENDPOINT,
),
)
@@ -472,6 +517,7 @@ AZURE_CHAT = AccessPolicy(
host=HostSpec(
base_url="https://{resource}.openai.azure.com/openai/v1",
settings=(_AZURE_OPENAI_RESOURCE, _AZURE_AUTHORITY, _AZURE_SCOPE),
+ endpoint_env=_AZURE_OPENAI_ENDPOINT,
),
)
@@ -492,6 +538,7 @@ AZURE_ANTHROPIC = AccessPolicy(
host=HostSpec(
base_url="https://{resource}.services.ai.azure.com/anthropic/v1",
settings=(_AZURE_FOUNDRY_RESOURCE, _AZURE_AUTHORITY, _AZURE_SCOPE),
+ endpoint_env=_AZURE_FOUNDRY_ENDPOINT,
),
)
@@ -721,19 +768,17 @@ def auth_header(
scheme = select_scheme(policy, value)
if scheme in ("api-key", "x-api-key") and "bearer" in policy.auth_scheme and _looks_like_jwt(value.value):
# A plain string reads as an API key, and on this door the key header
- # comes before bearer. A JWT is never an API key on these doors: it
- # is an Entra/OAuth access token that a token-provider callable
- # (azure-identity's get_bearer_token_provider returns a str) handed
- # over as a string. Sent as a key it is a bare 401 ("invalid
- # subscription key", live 2026-09-04); name the fix instead.
- raise NotConfiguredError(
- f"{policy.provider}: the credential is a JWT (a bearer token), but a plain string travels as an"
- f" API key here (`{'x-api-key' if scheme == 'x-api-key' else 'api-key'}` header); wrap it:"
- " lm15.credentials.BearerToken(token)",
- provider=policy.provider,
- env_keys=policy.env_keys,
- credential_hint="api_key=lambda: BearerToken(provider())",
- )
+ # comes before bearer. A JWT is never an API key on any door lm15
+ # has: it is an Entra/OAuth access token that a token-provider
+ # callable (azure-identity's get_bearer_token_provider returns a
+ # str) handed over as a string. Sent as a key it is a bare 401
+ # ("invalid subscription key", live 2026-09-04). AUTH-2, amended
+ # 2026-09-19: it travels as a bearer token — the only reading under
+ # which the request can succeed — and the doctor says so. Before
+ # that date this was a refusal naming the BearerToken wrap; the
+ # wrap is still accepted and still the form to use when nothing
+ # should be read from a token's shape.
+ scheme = "bearer"
if scheme == "bearer":
return ("Authorization", f"Bearer {value.value}")
if scheme == "x-api-key":
diff --git a/dspy/_vendor/lm15/cloud/chains.py b/dspy/_vendor/lm15/cloud/chains.py
index e86ed7caa..e21724e20 100644
--- a/dspy/_vendor/lm15/cloud/chains.py
+++ b/dspy/_vendor/lm15/cloud/chains.py
@@ -14,9 +14,18 @@ Two entry points:
its configuration is present. The first offline-usable rung is
``selected``; an ``unprobed`` rung that precedes it may still win at
request time, and the report says so.
-- ``credential_provider(policy, ctx)`` — the AUTH-2 provider callable:
- resolves once, caches until the AUTH-3 skew window, re-resolves after.
- Cache key = provider id + the identity-selecting settings.
+- ``credential_provider(policy, ctx, named=None)`` — the AUTH-2 provider
+ callable: resolves once, caches until the AUTH-3 skew window,
+ re-resolves after. Cache key = provider id + the identity-selecting
+ settings. Its ``source`` is the ``CredentialSource`` of the rung that
+ won (AUTH-1 provenance, amended 2026-09-19): every auth error names it.
+
+Named credentials (AUTH-1, amended 2026-09-19): ``named`` is one of
+``platform`` / ``workload`` / ``environment`` / ``cli``. It selects the
+rungs that mean that one thing on this cloud (``NAMED_RUNGS``) and the
+chain is not walked: a named credential that is absent is a
+``NotConfiguredError`` naming what was probed, never a fall-through to
+another identity.
Rungs that are declared but not implemented raise ``NotConfiguredError``
naming the gap and the fix; they never fall through silently
@@ -45,11 +54,11 @@ from xml.etree import ElementTree
from ..credentials import ApiKey, AwsCredentials, BearerToken, CredentialValue, parse_rfc3339
from ..errors import AuthError, NotConfiguredError
-from ..features import RUNG_KINDS, AccessPolicy
+from ..features import NAMED_CREDENTIALS, RUNG_KINDS, AccessPolicy
from . import rs256, sigv4
-__all__ = ["ChainContext", "Rung", "Step", "chain_for", "explain", "credential_provider",
- "token_exchange_build", "token_exchange_parse", "RUNG_KINDS"]
+__all__ = ["ChainContext", "Rung", "Step", "CredentialSource", "chain_for", "named_rungs", "explain",
+ "credential_provider", "token_exchange_build", "token_exchange_parse", "RUNG_KINDS", "NAMED_RUNGS"]
_SKEW = timedelta(seconds=300) # AUTH-3
@@ -178,6 +187,33 @@ class Step:
state: str # selected | shadowed | absent | unprobed
+@dataclass(frozen=True, slots=True)
+class CredentialSource:
+ """Where a resolved credential came from (AUTH-1 provenance). Never
+ the value: the rung's fixture kind, its human label, the name that
+ selected it (``platform`` …) when one did, and the expiry if known."""
+
+ rung: str
+ label: str
+ named: str | None = None
+ expires_at: datetime | None = None
+
+ def describe(self, now: datetime | None = None) -> str:
+ text = self.label
+ if self.named:
+ text += f' (named credential "{self.named}")'
+ if self.expires_at is not None:
+ current = now if now is not None else datetime.now(timezone.utc)
+ left = int((self.expires_at - current).total_seconds())
+ if left <= 0:
+ text += ", expired"
+ elif left < 3600:
+ text += f", expires in {max(left // 60, 1)} min"
+ else:
+ text += f", expires in {left // 3600} h {(left % 3600) // 60} min"
+ return text
+
+
# ─── Helpers ─────────────────────────────────────────────────────────
@@ -1143,6 +1179,60 @@ def profile_settings(policy: AccessPolicy, ctx: ChainContext) -> Callable[[str],
_CHAINS = {"aws-chain": _aws_chain, "azure-chain": _azure_chain, "gcp-chain": _gcp_chain}
+# AUTH-1 named credentials (amended 2026-09-19): the rungs each name
+# covers on each cloud. One word, the same on every cloud; the doctor and
+# every auth error print the concrete mechanism, never just the word.
+# ``platform`` on AWS covers two rungs (the container endpoint, then IMDS):
+# both are the machine's own identity, boto3 tries them in this order, and
+# the doctor says which answered. ``workload`` and ``environment`` on GCP
+# are the same file rung told apart by the file's ``type``
+# (``external_account`` vs ``service_account``); the wrong type is refused
+# by name, never read as the other.
+NAMED_RUNGS: dict[str, dict[str, tuple[str, ...]]] = {
+ "aws-chain": {
+ "platform": ("container", "imds"),
+ "workload": ("web-identity",),
+ "environment": ("env:AWS_ACCESS_KEY_ID",),
+ "cli": ("assume-role", "sso", "shared-credentials-file", "login", "credential_process", "config-file"),
+ },
+ "azure-chain": {
+ "platform": ("managed-identity",),
+ "workload": ("workload-identity",),
+ "environment": ("environment",),
+ "cli": ("az", "pwsh", "azd"),
+ },
+ "gcp-chain": {
+ "platform": ("metadata",),
+ "workload": ("adc-env",),
+ "environment": ("adc-env",),
+ "cli": ("adc-file", "gcloud"),
+ },
+}
+
+_GCP_NAMED_TYPES = {"workload": ("external_account",), "environment": ("service_account", "impersonated_service_account")}
+
+# What each name means on each cloud, for the doctor and for errors.
+NAMED_MEANING: dict[str, dict[str, str]] = {
+ "aws-chain": {
+ "platform": "the ECS/EKS container endpoint, else the EC2 instance role (IMDSv2)",
+ "workload": "web identity (AWS_WEB_IDENTITY_TOKEN_FILE + AWS_ROLE_ARN) via STS",
+ "environment": "AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY",
+ "cli": "the active `aws` profile (assume-role, SSO, shared files, `aws login`, credential_process)",
+ },
+ "azure-chain": {
+ "platform": "Azure managed identity",
+ "workload": "Entra workload identity (AZURE_FEDERATED_TOKEN_FILE)",
+ "environment": "an Entra service principal from AZURE_TENANT_ID / AZURE_CLIENT_ID + secret or certificate",
+ "cli": "`az`, Azure PowerShell or `azd` sign-in",
+ },
+ "gcp-chain": {
+ "platform": "the attached service account (GCE metadata server)",
+ "workload": "workload identity federation (GOOGLE_APPLICATION_CREDENTIALS, type external_account)",
+ "environment": "a service-account file (GOOGLE_APPLICATION_CREDENTIALS, type service_account)",
+ "cli": "`gcloud auth application-default login` (the ADC file) or `gcloud auth print-access-token`",
+ },
+}
+
def chain_for(policy: AccessPolicy) -> list[Rung]:
builder = _CHAINS.get(policy.credential_policy)
@@ -1151,8 +1241,63 @@ def chain_for(policy: AccessPolicy) -> list[Rung]:
return builder(policy)
-def explain(policy: AccessPolicy, ctx: ChainContext, *, explicit: bool) -> tuple[list[Step], bool]:
- """The AUTH-7 walk. ``explicit`` = an api_keys entry exists (rung 0)."""
+def _gcp_typed(rung: Rung, name: str) -> Rung:
+ """The GOOGLE_APPLICATION_CREDENTIALS rung narrowed to the file types the
+ name means; another type is refused naming the name it belongs to."""
+ allowed = _GCP_NAMED_TYPES[name]
+ other = "environment" if name == "workload" else "workload"
+
+ def kind_of(ctx: ChainContext) -> tuple[str | None, str | None]:
+ path = ctx.env.get("GOOGLE_APPLICATION_CREDENTIALS")
+ if not path:
+ return None, None
+ info = _gcp_credential_file(ctx, path)
+ return path, (str(info.get("type")) if info else None)
+
+ def probe(ctx: ChainContext):
+ path, kind = kind_of(ctx)
+ if path and kind and kind not in allowed:
+ return ("absent", f"{path} holds {kind} credentials; that is the named credential \"{other}\", not \"{name}\"")
+ return rung.probe(ctx)
+
+ def acquire(ctx: ChainContext):
+ path, kind = kind_of(ctx)
+ if path and kind and kind not in allowed:
+ raise NotConfiguredError(
+ f"{path} holds {kind} credentials; that is the named credential \"{other}\", not \"{name}\"",
+ credential_hint=f'credentials={{"<provider>": "{other}"}}',
+ )
+ return rung.acquire(ctx)
+
+ return Rung(rung.name, rung.kind, rung.source, rung.needs, probe, acquire)
+
+
+def named_rungs(policy: AccessPolicy, name: str) -> list[Rung]:
+ """The rungs a named credential covers on this door, in chain order."""
+ if name not in NAMED_CREDENTIALS:
+ raise NotConfiguredError(
+ f"{policy.provider}: unknown named credential {name!r}; one of {', '.join(repr(n) for n in NAMED_CREDENTIALS)}",
+ provider=policy.provider,
+ )
+ wanted = NAMED_RUNGS[policy.credential_policy][name]
+ rungs = [rung for rung in chain_for(policy) if rung.name in wanted]
+ if policy.credential_policy == "gcp-chain" and name in _GCP_NAMED_TYPES:
+ rungs = [_gcp_typed(rung, name) for rung in rungs]
+ return rungs
+
+
+def named_meaning(policy: AccessPolicy, name: str) -> str:
+ return NAMED_MEANING[policy.credential_policy][name]
+
+
+def _walk(policy: AccessPolicy, named: str | None) -> list[Rung]:
+ return named_rungs(policy, named) if named else chain_for(policy)
+
+
+def explain(policy: AccessPolicy, ctx: ChainContext, *, explicit: bool, named: str | None = None) -> tuple[list[Step], bool]:
+ """The AUTH-7 walk. ``explicit`` = an api_keys entry exists (rung 0).
+ With ``named``, only the rungs the name covers are walked (the rest
+ are not steps at all: a named credential never falls through)."""
steps: list[Step] = []
selected = False
if explicit:
@@ -1160,7 +1305,7 @@ def explain(policy: AccessPolicy, ctx: ChainContext, *, explicit: bool) -> tuple
selected = True
else:
steps.append(Step("api_keys", "explicit api_keys entry", "not provided", "absent"))
- for rung in chain_for(policy):
+ for rung in _walk(policy, named):
try:
verdict, detail = rung.probe(ctx)
except NotConfiguredError as exc:
@@ -1179,13 +1324,31 @@ def explain(policy: AccessPolicy, ctx: ChainContext, *, explicit: bool) -> tuple
return steps, selected or any(s.state == "unprobed" for s in steps)
-def resolve(policy: AccessPolicy, ctx: ChainContext) -> CredentialValue:
- """Walk the chain online; the first rung that yields wins. A rung that
- is configured and fails raises. Azure developer commands are the
- AUTH-1 exception: try all three before reporting their failure.
- Deployed Azure credentials and AWS/GCP failures never fall through."""
+def _source_of(rung: Rung, value: CredentialValue, named: str | None) -> CredentialSource:
+ return CredentialSource(rung=rung.name, label=rung.source, named=named, expires_at=getattr(value, "expires_at", None))
+
+
+def _probed_summary(policy: AccessPolicy, ctx: ChainContext, rungs: list[Rung]) -> str:
+ parts = []
+ for rung in rungs:
+ try:
+ _, detail = rung.probe(ctx)
+ except NotConfiguredError as exc:
+ detail = str(exc).splitlines()[0]
+ parts.append(f"{rung.source}: {detail}")
+ return "; ".join(parts)
+
+
+def resolve(policy: AccessPolicy, ctx: ChainContext, *, named: str | None = None) -> tuple[CredentialValue, CredentialSource]:
+ """Walk the chain online; the first rung that yields wins, and the
+ result names the rung (AUTH-1 provenance). A rung that is configured
+ and fails raises. Azure developer commands are the AUTH-1 exception:
+ try all three before reporting their failure. Deployed Azure
+ credentials and AWS/GCP failures never fall through. With ``named``,
+ only that name's rungs run and nothing else is tried."""
developer_failed = False
- for rung in chain_for(policy):
+ rungs = _walk(policy, named)
+ for rung in rungs:
try:
got = rung.acquire(ctx)
except AuthError:
@@ -1194,10 +1357,19 @@ def resolve(policy: AccessPolicy, ctx: ChainContext) -> CredentialValue:
continue
raise
if got is not None:
- return got
+ return got, _source_of(rung, got, named)
if developer_failed:
raise AuthError("Azure developer credentials failed; sign in with az, Azure PowerShell, or azd",
provider=policy.provider)
+ if named:
+ raise NotConfiguredError(
+ f'{policy.provider}: named credential "{named}" \u2014 {named_meaning(policy, named)} \u2014 answered nothing '
+ f"({_probed_summary(policy, ctx, rungs)}). This door was told to use that identity only; it will not try "
+ f"the rest of the {policy.credential_policy} chain.",
+ provider=policy.provider,
+ credential_hint=f'credentials={{"{policy.provider}": "<platform|workload|environment|cli>"}} names one identity; '
+ f"omit it to walk the {policy.credential_policy} chain",
+ )
raise NotConfiguredError(
f"{policy.provider}: no credential found in the {policy.credential_policy} chain"
+ (f"; set {policy.env_keys[0]} or configure the cloud SDK" if policy.env_keys else "; configure the cloud SDK"),
@@ -1208,20 +1380,30 @@ def resolve(policy: AccessPolicy, ctx: ChainContext) -> CredentialValue:
class _CachingProvider:
"""AUTH-2/AUTH-3: resolve once, hand out until the skew window, then
- re-resolve. In memory only; never written to a foreign file."""
+ re-resolve. In memory only; never written to a foreign file.
+ ``source`` is where the last resolution came from (AUTH-1 provenance);
+ ``None`` until the first request."""
- def __init__(self, policy: AccessPolicy, ctx: ChainContext) -> None:
+ def __init__(self, policy: AccessPolicy, ctx: ChainContext, named: str | None = None) -> None:
self._policy = policy
self._ctx = ctx
+ self._named = named
self._lock = threading.Lock()
self._value: CredentialValue | None = None
+ self.source: CredentialSource | None = None
+
+ @property
+ def named(self) -> str | None:
+ return self._named
def __call__(self) -> CredentialValue:
with self._lock:
if self._value is None or self._value.is_expired(self._ctx.now()):
- value = resolve(self._policy, self._ctx)
+ value, source = resolve(self._policy, self._ctx, named=self._named)
+ self.source = source
if value.is_expired(self._ctx.now()):
- raise AuthError("cloud credential is expired; renew the configured credential source",
+ raise AuthError("cloud credential is expired; renew the configured credential source"
+ f" (credential came from: {source.describe(self._ctx.now())})",
provider=self._policy.provider)
# CLI output without an expiry cannot safely be cached forever.
self._value = value if isinstance(value, (ApiKey, AwsCredentials)) or value.expires_at is not None else None
@@ -1241,8 +1423,10 @@ def cache_key(policy: AccessPolicy, ctx: ChainContext) -> str:
return hashlib.sha256("\x1f".join(parts).encode()).hexdigest()
-def credential_provider(policy: AccessPolicy, ctx: ChainContext) -> Callable[[], CredentialValue]:
- return _CachingProvider(policy, ctx)
+def credential_provider(policy: AccessPolicy, ctx: ChainContext, named: str | None = None) -> Callable[[], CredentialValue]:
+ if named is not None:
+ named_rungs(policy, named) # an unknown name fails at construction, not on the first request
+ return _CachingProvider(policy, ctx, named)
# ─── Harness ops (PROTOCOL.md token_exchange_build / token_exchange_parse) ──
diff --git a/dspy/_vendor/lm15/cloud/hosts.py b/dspy/_vendor/lm15/cloud/hosts.py
index e59cb5be5..2624c3895 100644
--- a/dspy/_vendor/lm15/cloud/hosts.py
+++ b/dspy/_vendor/lm15/cloud/hosts.py
@@ -8,9 +8,14 @@ Three pure functions, in the order an adapter calls them:
adapter is given its settings explicitly, like its credential), then
defaults. A required setting with no value raises ``NotConfiguredError``
naming the variable: ``region`` and ``resource`` have no default on
- purpose (a wrong-region default is a residency bug).
-2. ``render_base_url(host, settings)`` — the base URL for the settings;
- ``{location_host}`` is derived from ``location``.
+ purpose (a wrong-region default is a residency bug). With an
+ ``endpoint`` (a full URL root) the settings the URL alone needed are
+ not required (``HostSpec.url_only_settings``).
+2. ``render_base_url(host, settings, endpoint=None)`` — the base URL for
+ the settings; ``{location_host}`` is derived from ``location``. An
+ endpoint replaces the template's root; the door's path is appended
+ unless the endpoint already ends with it or with a leading part of it
+ (``join_endpoint``; spec/auth.md AUTH-10, amended 2026-09-19).
3. ``finish_request(...)`` — the dialect built its request against that
base URL; this applies the host's closed set of rewrites (endpoint path
override, model into the path, ``anthropic_version`` into the body,
@@ -23,7 +28,7 @@ from __future__ import annotations
from dataclasses import dataclass
from datetime import datetime, timezone
import re
-from urllib.parse import quote
+from urllib.parse import quote, urlsplit
from typing import Any, Callable, Mapping
from ..credentials import ApiKey, AwsCredentials, CredentialValue
@@ -31,7 +36,8 @@ from ..errors import NotConfiguredError, UnsupportedFeatureError
from ..features import AccessPolicy, HostSpec
from . import sigv4
-__all__ = ["resolve_settings", "render_base_url", "location_host", "finish_request", "Clock", "utc_now"]
+__all__ = ["resolve_settings", "render_base_url", "join_endpoint", "endpoint_from_env", "location_host",
+ "finish_request", "Clock", "utc_now"]
Clock = Callable[[], datetime]
@@ -47,14 +53,17 @@ def resolve_settings(
*,
provider: str = "",
profile: Callable[[str], str | None] | None = None,
+ endpoint: str | None = None,
) -> dict[str, str]:
"""Explicit values, then ``env`` (when given), then the cloud profile
(``profile(name)``: the AWS shared config's ``region`` for the active
- profile, the ADC file's ``quota_project_id`` — AUTH-10), then defaults."""
+ profile, the ADC file's ``quota_project_id`` — AUTH-10), then defaults.
+ With ``endpoint`` the settings only the URL root needed are optional."""
out: dict[str, str] = {}
if host is None:
return dict(given or {})
given = dict(given or {})
+ relaxed = host.url_only_settings if endpoint else frozenset()
for setting in host.settings:
value = given.pop(setting.name, None)
if not value and env is not None:
@@ -68,7 +77,11 @@ def resolve_settings(
if not value:
value = setting.default
if not value:
+ if setting.name in relaxed:
+ continue
hint = f"set {' or '.join(setting.env)}" if setting.env else f"pass settings={{'{setting.name}': ...}}"
+ if setting.name in host.url_only_settings and host.endpoint_env:
+ hint += f", or the endpoint: {' or '.join(host.endpoint_env)}"
raise NotConfiguredError(
f"{provider or 'host'}: setting {setting.name!r} is required and has no default; {hint}",
provider=provider or None,
@@ -90,7 +103,48 @@ def location_host(location: str) -> str:
return f"{location}-aiplatform.googleapis.com"
-def render_base_url(host: HostSpec, settings: Mapping[str, str]) -> str:
+def endpoint_from_env(host: HostSpec | None, env: Mapping[str, str] | None) -> str | None:
+ """The first non-empty vendor endpoint variable this door honours."""
+ if host is None or env is None:
+ return None
+ for var in host.endpoint_env:
+ value = (env.get(var) or "").strip()
+ if value:
+ return value
+ return None
+
+
+def join_endpoint(endpoint: str, path: str, *, provider: str = "") -> str:
+ """``endpoint`` (a URL root the caller or the vendor's variable named)
+ joined with the door's ``path``.
+
+ The door's path is appended unless the endpoint already ends with it,
+ or with a leading part of it: the console shows an account root
+ (``https://acct.services.ai.azure.com``), Microsoft's own examples
+ show ``…/anthropic`` and ``…/openai/v1``, and all three must mean the
+ same door. Stated trade-off: a gateway whose own path happens to end
+ with a leading part of the door's path (``…/openai`` meaning
+ ``…/openai/openai/v1``) cannot be spelled; no such gateway is known.
+ """
+ parts = urlsplit(endpoint.strip())
+ if parts.scheme not in ("http", "https") or not parts.netloc:
+ raise NotConfiguredError(f"{provider or 'host'}: endpoint must be an http(s) URL with a host, got {endpoint!r}",
+ provider=provider or None)
+ if parts.query or parts.fragment or "@" in parts.netloc:
+ raise NotConfiguredError(f"{provider or 'host'}: endpoint must not carry a query, fragment or userinfo",
+ provider=provider or None)
+ given = [segment for segment in parts.path.split("/") if segment]
+ door = [segment for segment in path.split("/") if segment]
+ base = given
+ for k in range(min(len(given), len(door)), 0, -1):
+ if given[-k:] == door[:k]:
+ base = given[:-k]
+ break
+ joined = "/".join(base + door)
+ return f"{parts.scheme}://{parts.netloc}" + (f"/{joined}" if joined else "")
+
+
+def render_base_url(host: HostSpec, settings: Mapping[str, str], endpoint: str | None = None, *, provider: str = "") -> str:
values = dict(settings)
for name in ("region", "resource", "location"):
if name in values and not re.fullmatch(r"[A-Za-z0-9-]+", values[name]):
@@ -99,10 +153,14 @@ def render_base_url(host: HostSpec, settings: Mapping[str, str]) -> str:
values["project"] = quote(values["project"], safe="")
if "location" in values and "location_host" not in values:
values["location_host"] = location_host(values["location"])
+ template = host.base_url if endpoint is None else host.path_template
try:
- return host.base_url.format(**values)
+ rendered = template.format(**values)
except KeyError as exc:
raise NotConfiguredError(f"host base URL needs setting {exc.args[0]!r}") from None
+ if endpoint is None:
+ return rendered
+ return join_endpoint(endpoint, rendered, provider=provider)
@dataclass(frozen=True, slots=True, repr=False)
diff --git a/dspy/_vendor/lm15/compat.py b/dspy/_vendor/lm15/compat.py
index bef3eecb7..7c3a55410 100644
--- a/dspy/_vendor/lm15/compat.py
+++ b/dspy/_vendor/lm15/compat.py
@@ -391,6 +391,11 @@ OpenAIChatForcedToolChoice = Literal["auto", "send", "reject"]
# answers 200 with free-form, fenced JSON that ignores the schema (live
# 2026-09-03) — silent, so the adapter must refuse.
OpenAIChatJsonSchema = Literal["auto", "send", "reject"]
+# MAP-14 §4: can the server score named tokens (``logprob_token_ids`` on
+# the completions endpoint) so lm15 can deliver a distribution over
+# declared keys? Receipted on vLLM 0.29.0 (honoured) and 0.25.1 (200,
+# silently absent) 2026-09-17; the response-side check catches the latter.
+OpenAIChatTokenScoring = Literal["auto", "none", "logprob_token_ids"]
# The server's native reasoning-effort levels, when the server does NOT
# refuse the others. MAP-7 rule 2: a word with no native level raises
# client-side rather than downgrading silently. Most servers answer 400 to
@@ -425,6 +430,7 @@ class OpenAIChatCompat:
user_field: OpenAIChatUserField | None = None
forced_tool_choice: OpenAIChatForcedToolChoice | None = None
json_schema: OpenAIChatJsonSchema | None = None
+ token_scoring: OpenAIChatTokenScoring | None = field(default=None, kw_only=True)
reasoning_efforts: OpenAIChatReasoningEfforts | None = field(default=None, kw_only=True)
routing: JsonObject | None = None
extensions: JsonObject | None = None
@@ -468,6 +474,7 @@ class OpenAIChatCompat:
_check_literal_or_none(self.tool_result_media, ToolResultMedia, "tool_result_media")
_check_literal_or_none(self.cache_control, OpenAICacheControl, "cache_control")
_check_literal_or_none(self.user_field, OpenAIChatUserField, "user_field")
+ _check_literal_or_none(self.token_scoring, OpenAIChatTokenScoring, "token_scoring")
_check_literal_or_none(self.forced_tool_choice, OpenAIChatForcedToolChoice, "forced_tool_choice")
_check_literal_or_none(self.json_schema, OpenAIChatJsonSchema, "json_schema")
if self.reasoning_efforts is not None:
@@ -647,6 +654,9 @@ OPENAI_CHAT_PRESETS: dict[str, OpenAIChatCompat] = {
strict_tools="omit",
cache_control="none",
tool_result_media="reject", # MAP-10: parser carries it; no server reachable in the pass — reject until a receipt
+ # MAP-14 §4, receipts/2026-09-17-judgments/vllm-0.29-lfm-trie.json (honoured)
+ # and vllm-0.25.1-qwen-trie-negative.json (silently absent; caught on parse).
+ token_scoring="logprob_token_ids",
),
"sglang": OpenAIChatCompat(
instruction_role="system",
@@ -872,6 +882,7 @@ class ResolvedOpenAIChatCompat:
user_field: Literal["user", "user_id"] = "user"
forced_tool_choice: Literal["send", "reject"] = "send"
json_schema: Literal["send", "reject"] = "send"
+ token_scoring: Literal["none", "logprob_token_ids"] = field(default="none", kw_only=True)
reasoning_efforts: tuple[str, ...] | None = field(default=None, kw_only=True)
routing: JsonObject | None = None
extensions: JsonObject | None = None
@@ -893,6 +904,7 @@ _CHAT_AUTO_DEFAULTS: dict[str, str] = {
"user_field": "user",
"forced_tool_choice": "send",
"json_schema": "send",
+ "token_scoring": "none",
}
diff --git a/dspy/_vendor/lm15/doctor.py b/dspy/_vendor/lm15/doctor.py
index 4081f86b8..63236e489 100644
--- a/dspy/_vendor/lm15/doctor.py
+++ b/dspy/_vendor/lm15/doctor.py
@@ -86,6 +86,15 @@ class AuthReport:
steps: tuple[AuthStep, ...]
configured: bool
settings: tuple[tuple[str, str], ...] = () # resolved host settings (AUTH-7: printed by name and value)
+ # AUTH-1 named credential (amended 2026-09-19): the name and what it
+ # means on this cloud, when the config pins one; the steps are then
+ # only the rungs it covers.
+ named: str | None = None
+ named_meaning: str | None = None
+ # The base URL the door will send to, and where it came from
+ # (``"base_urls"``, an env variable name, or ``"template"``).
+ base_url: str | None = None
+ base_url_source: str | None = None
@property
def selected(self) -> AuthStep | None:
@@ -96,6 +105,8 @@ class AuthReport:
def describe(self) -> str:
lines = [f"auth for provider {self.provider!r}:"]
+ if self.named:
+ lines.append(f' named credential "{self.named}": {self.named_meaning} — the chain is not walked')
lines += [f" {step.describe()}" for step in self.steps]
unprobed = [step for step in self.steps if step.state == "unprobed"]
if self.configured and self.selected is not None:
@@ -108,6 +119,9 @@ class AuthReport:
lines.append(" configured: no")
for name, value in self.settings:
lines.append(f" setting {name}: {value}")
+ if self.base_url:
+ origin = f" (from {self.base_url_source})" if self.base_url_source else ""
+ lines.append(f" base url: {self.base_url}{origin}")
return "\n".join(lines)
def __str__(self) -> str:
@@ -178,6 +192,8 @@ def explain_auth(
home: str | None = None,
settings: Mapping[str, str] | None = None,
config: RouterConfig | None = None,
+ credential: str | None = None,
+ base_url: str | None = None,
) -> AuthReport:
"""Explain, rung by rung, how ``provider``'s credential resolves.
@@ -191,10 +207,14 @@ def explain_auth(
prints secret values, and performs no network I/O.
``config`` is the router's own ``RouterConfig`` (``router.config``): its
- ``env``, ``api_keys`` and the provider's ``settings`` entry are read, so
- the report describes the router that will send the request. An
- explicit ``env=``/``api_keys=``/``settings=`` argument wins over the
- config's field.
+ ``env``, ``api_keys``, ``credentials``, ``base_urls`` and the provider's
+ ``settings`` entry are read, so the report describes the router that
+ will send the request. An explicit ``env=``/``api_keys=``/``settings=``
+ /``credential=``/``base_url=`` argument wins over the config's field.
+
+ On a cloud door the report also carries the base URL the door will
+ send to and where it came from, and, under a named credential
+ (``credential="platform"`` …), only the rungs that name covers.
"""
import os
@@ -210,6 +230,14 @@ def explain_auth(
api_keys = config.api_keys
if settings is None and config.settings is not None:
settings = config.settings.get(canonical) or config.settings.get(provider)
+ if credential is None:
+ from .router import _credentials_entry
+
+ credential = _credentials_entry(config, canonical)
+ if base_url is None:
+ from .router import _base_url_entry
+
+ base_url = _base_url_entry(config, canonical)
if not _routable(canonical, ADAPTERS):
from .registry import PROVIDERS
@@ -220,7 +248,13 @@ def explain_auth(
if policy in ("aws-chain", "azure-chain", "gcp-chain") or (
_bound_definition(canonical) is not None and _bound_definition(canonical).hosted
):
- return _explain_cloud(canonical, env=env, api_keys=api_keys, files=files, home=home, settings=settings)
+ return _explain_cloud(canonical, env=env, api_keys=api_keys, files=files, home=home, settings=settings,
+ credential=credential, base_url=base_url)
+ if credential is not None:
+ raise NotConfiguredError(
+ f"{canonical}: credential={credential!r} names a cloud identity, and this is not a cloud door",
+ provider=canonical,
+ )
if policy == "oauth":
override = claude_credentials_path if canonical == "claude-code" else codex_auth_path
step = _oauth_step(canonical, override)
@@ -311,19 +345,26 @@ def _explain_cloud(
files: Mapping[str, str] | None,
home: str | None,
settings: Mapping[str, str] | None,
+ credential: str | None = None,
+ base_url: str | None = None,
) -> AuthReport:
"""The cloud-chain walk (AUTH-1 aws/azure/gcp chains) through
``lm15.cloud.chains.explain``: offline, files from ``files`` when the
- harness materialized them, host settings resolved and printed."""
+ harness materialized them, host settings resolved and printed, the
+ base URL and its origin named."""
import os
- from .cloud.chains import ChainContext, explain, profile_settings
- from .cloud.hosts import resolve_settings
+ from .cloud.chains import ChainContext, explain, named_meaning, profile_settings
+ from .cloud.hosts import endpoint_from_env, render_base_url, resolve_settings
definition = _bound_definition(canonical)
policy = definition.access
environment = env if env is not None else os.environ
- config = RouterConfig(env=env, api_keys=api_keys)
+ config = RouterConfig(env=env, api_keys=api_keys, credentials={canonical: credential} if credential else None)
+ if credential is not None:
+ from .router import _check_named_credential
+
+ _check_named_credential(config, canonical, credential, ADAPTERS)
entry = _api_keys_source(config, canonical)
has_entry = entry is not None
resolved: dict[str, str] = {}
@@ -333,13 +374,28 @@ def _explain_cloud(
home=Path(home).expanduser() if home else (Path(environment["HOME"]) if environment.get("HOME") else Path.home()),
files=files,
)
+ endpoint_source: str | None = None
+ if base_url is not None:
+ endpoint_source = "base_urls"
+ elif policy.host is not None:
+ base_url = endpoint_from_env(policy.host, environment)
+ if base_url is not None:
+ endpoint_source = next(var for var in policy.host.endpoint_env if (environment.get(var) or "").strip())
+ endpoint_source = f"env ${endpoint_source}"
try:
- resolved = resolve_settings(policy.host, settings, environment, provider=canonical, profile=profile_settings(policy, ctx))
+ resolved = resolve_settings(policy.host, settings, environment, provider=canonical,
+ profile=profile_settings(policy, ctx), endpoint=base_url)
except NotConfiguredError as exc:
setting_error = str(exc).splitlines()[0]
ctx.settings = resolved
+ rendered: str | None = None
+ if policy.host is not None and setting_error is None:
+ try:
+ rendered = render_base_url(policy.host, resolved, base_url, provider=canonical)
+ except NotConfiguredError as exc:
+ setting_error = str(exc).splitlines()[0]
if policy.cloud_chain:
- steps, configured = explain(policy, ctx, explicit=has_entry)
+ steps, configured = explain(policy, ctx, explicit=has_entry, named=credential)
out = [AuthStep(kind=s.kind, source=_entry_source(canonical, entry) if s.kind == "api_keys" else s.source,
detail=s.detail, state=s.state) for s in steps]
else:
@@ -357,4 +413,8 @@ def _explain_cloud(
shown = tuple(sorted(resolved.items()))
if setting_error:
shown = shown + (("error", setting_error),)
- return AuthReport(provider=canonical, steps=tuple(out), configured=configured, settings=shown)
+ return AuthReport(
+ provider=canonical, steps=tuple(out), configured=configured, settings=shown,
+ named=credential, named_meaning=named_meaning(policy, credential) if credential else None,
+ base_url=rendered, base_url_source=(endpoint_source or "template") if rendered else None,
+ )
diff --git a/dspy/_vendor/lm15/errors.py b/dspy/_vendor/lm15/errors.py
index f7c24c267..ff51751d7 100644
--- a/dspy/_vendor/lm15/errors.py
+++ b/dspy/_vendor/lm15/errors.py
@@ -30,7 +30,9 @@ Hierarchy:
from __future__ import annotations
import builtins
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Mapping, Sequence
+
+from .rate_limits import diagnostics_text, freeze_rate_limits
if TYPE_CHECKING: # pragma: no cover
from .types import Response
@@ -56,7 +58,9 @@ class LM15Error(Exception):
status: int | None = None,
request_id: str | None = None,
retry_after: float | None = None,
+ rate_limit_headers: Mapping[str, Sequence[str]] | None = None,
) -> None:
+ self.rate_limit_headers = freeze_rate_limits(rate_limit_headers)
self.message = message
self.code = code or self.default_code
self.provider = provider
@@ -244,11 +248,10 @@ class ProviderError(LM15Error):
if item
)
base = self.message or self.code
- if not context:
- return base
head, sep, tail = base.partition("\n\n")
- suffix = f" ({context})"
- return f"{head}{suffix}\n\n{tail}" if sep else f"{base}{suffix}"
+ suffix = f" ({context})" if context else ""
+ details = diagnostics_text(self.rate_limit_headers, self.retry_after)
+ return f"{head}{suffix}{details}" + (f"\n\n{tail}" if sep else "")
class AuthError(ProviderError):
@@ -270,6 +273,9 @@ class AuthError(ProviderError):
provider_name = provider or kwargs.get("provider")
self.env_keys = tuple(env_keys)
self.credential_hint = credential_hint
+ # AUTH-1 provenance: where the rejected credential came from (a
+ # label, never the value); set by ``with_credential_origin``.
+ self.credential_origin: str | None = None
if credential_hint:
# Subscription/OAuth adapters: guidance is how to re-login, not
@@ -303,7 +309,7 @@ class RateLimitError(ProviderError):
" To fix:\n"
" - Wait a moment and retry\n"
" - Retry with backoff in your application layer (lm15 never retries for you)\n"
- " - Reduce request rate or upgrade your API plan\n"
+ " - Check the reported limits and deployment capacity; a 429 does not prove the endpoint is unsupported\n"
)
super().__init__(_append_guidance(message, guidance), **kwargs)
@@ -460,6 +466,36 @@ class AmbiguousModelError(ConfigurationError):
_GUIDANCE_MARKER = "\n\n To fix:"
+_ORIGIN_MARKER = "\n\n credential came from: "
+
+
+def with_credential_origin(error: ProviderError, origin: str) -> ProviderError:
+ """Name where an AuthError's credential came from (AUTH-1 provenance,
+ amended 2026-09-19): its own line under the provider's message (a
+ paragraph of its own, so ``__str__`` keeps the provider/HTTP suffix
+ on the provider's line), before the guidance, so a log line at 3 a.m.
+ answers "which identity?" without a second investigation. Non-auth
+ errors pass through."""
+ if not isinstance(error, AuthError) or not origin:
+ return error
+ base = error.message.split(_GUIDANCE_MARKER, 1)[0]
+ if _ORIGIN_MARKER in base:
+ return error
+ out = AuthError(
+ base.rstrip() + _ORIGIN_MARKER + origin,
+ provider=error.provider,
+ env_keys=error.env_keys,
+ credential_hint=error.credential_hint,
+ provider_code=error.provider_code,
+ status=error.status,
+ request_id=error.request_id,
+ retry_after=error.retry_after,
+ rate_limit_headers=error.rate_limit_headers,
+ )
+ out.credential_origin = origin
+ return out
+
+
def with_credential_hint(error: ProviderError, hint: str) -> ProviderError:
"""Rewrite an AuthError's guidance for subscription (OAuth) adapters.
@@ -478,6 +514,7 @@ def with_credential_hint(error: ProviderError, hint: str) -> ProviderError:
status=error.status,
request_id=error.request_id,
retry_after=error.retry_after,
+ rate_limit_headers=error.rate_limit_headers,
)
diff --git a/dspy/_vendor/lm15/features.py b/dspy/_vendor/lm15/features.py
index 0c012d788..a3f0eca20 100644
--- a/dspy/_vendor/lm15/features.py
+++ b/dspy/_vendor/lm15/features.py
@@ -58,6 +58,14 @@ RUNG_KINDS: frozenset[str] = frozenset({
AuthStepState = Literal["selected", "shadowed", "absent", "unprobed"]
AUTH_STEP_STATES: frozenset[str] = frozenset({"selected", "shadowed", "absent", "unprobed"})
+# spec/auth.md AUTH-1 named credentials (amended 2026-09-19,
+# changes/2026-09-19-cloud-identity-and-endpoints.md): the four names a
+# caller may pin a cloud door to instead of walking the chain. One word,
+# the same on every cloud; the chain module maps each to the rungs it
+# covers, and a named credential never falls through to another rung.
+NamedCredential = Literal["platform", "workload", "environment", "cli"]
+NAMED_CREDENTIALS: tuple[str, ...] = ("platform", "workload", "environment", "cli")
+
@dataclass(frozen=True, slots=True)
class EndpointSupport:
@@ -126,6 +134,14 @@ class HostSpec:
``required_headers`` ``(header name, setting name)`` pairs sent on every
request from the resolved settings.
``sigv4_service`` the SigV4 credential-scope service name.
+ ``endpoint_env`` the cloud vendor's own variables, consulted in
+ order by the router, that name a full endpoint
+ root for this door (``AZURE_OPENAI_ENDPOINT``,
+ ``AWS_ENDPOINT_URL_BEDROCK_RUNTIME``). An
+ endpoint replaces the root of ``base_url`` (the
+ part before the first path segment); the door's
+ path is appended unless already present
+ (amended 2026-09-19).
"""
base_url: str
@@ -136,6 +152,7 @@ class HostSpec:
stream_framing: StreamFraming = "sse"
required_headers: tuple[tuple[str, str], ...] = ()
sigv4_service: str | None = None
+ endpoint_env: tuple[str, ...] = ()
def __post_init__(self) -> None:
if self.model_in not in MODEL_PLACEMENTS:
@@ -147,11 +164,51 @@ class HostSpec:
object.__setattr__(self, "settings", tuple(self.settings))
object.__setattr__(self, "paths", dict(self.paths))
object.__setattr__(self, "required_headers", tuple((str(k), str(v)) for k, v in self.required_headers))
+ object.__setattr__(self, "endpoint_env", tuple(str(v) for v in self.endpoint_env))
+ if "://" not in self.base_url:
+ raise ValueError(f"HostSpec.base_url must be an absolute URL template, got {self.base_url!r}")
@property
def setting_names(self) -> tuple[str, ...]:
return tuple(s.name for s in self.settings)
+ @property
+ def root_template(self) -> str:
+ """``base_url`` up to (not including) the first path segment: the
+ part an endpoint override replaces."""
+ scheme, _, rest = self.base_url.partition("://")
+ host, _, _ = rest.partition("/")
+ return f"{scheme}://{host}"
+
+ @property
+ def path_template(self) -> str:
+ """The door's path under the root (``/openai/v1``,
+ ``/v1/projects/{project}/locations/{location}/publishers/google``);
+ ``""`` when the template is a bare host."""
+ _, _, rest = self.base_url.partition("://")
+ _, slash, path = rest.partition("/")
+ return f"/{path}" if slash else ""
+
+ @property
+ def url_only_settings(self) -> frozenset[str]:
+ """Settings an endpoint override makes unnecessary: those that
+ appear in the root of the template and nowhere else — not in the
+ path, not in a required header, and not the SigV4 signing region
+ (AWS's own SDK requires a region even with ``endpoint_url``; the
+ signature's credential scope names it)."""
+ import re
+
+ in_root = set(re.findall(r"{(\w+)}", self.root_template))
+ if "location_host" in in_root:
+ in_root.discard("location_host")
+ in_root.add("location")
+ in_path = set(re.findall(r"{(\w+)}", self.path_template))
+ in_headers = {setting for _, setting in self.required_headers}
+ out = in_root - in_path - in_headers
+ if self.sigv4_service is not None:
+ out.discard("region")
+ return frozenset(out)
+
@dataclass(frozen=True, slots=True, init=False)
class AccessPolicy:
diff --git a/dspy/_vendor/lm15/judgments.py b/dspy/_vendor/lm15/judgments.py
new file mode 100644
index 000000000..8fdf1946e
--- /dev/null
+++ b/dspy/_vendor/lm15/judgments.py
@@ -0,0 +1,312 @@
+"""Judgments: declared keys in, a distribution out (MAP-14).
+
+changes/2026-09-17-judgments.md. A judgment is a top-level property of a
+``json_schema`` ``response_format`` that declares its answer set: a
+boolean, a string ``enum``/``anyOf``-of-``const``, or an ordered integer
+``enum``/``anyOf``-of-``const`` ``0..n-1``. This module reads that
+convention off a schema (§1), rewrites judgment properties for the two
+wires that need it (§2), folds a model's JSON text into a ``DataPart``
+(§3), and offers the sugar that EMITS the convention (``choice``,
+``yes_no``, ``score``, ``judgments``) the way ``tool(fn)`` emits a tool
+schema. Nothing here touches the network.
+"""
+from __future__ import annotations
+
+import copy
+import json
+import math
+from dataclasses import dataclass
+from typing import Any, Literal, Mapping, Sequence
+
+from .adaptation import adapt
+from .errors import UnsupportedFeatureError
+from .types import DataPart, JsonObject, JsonValue, Request, TextPart
+
+JudgmentKind = Literal["boolean", "choice", "ordered"]
+
+MAX_ORDERED_LEVELS = 10 # Jev's Score ceiling (docs.typesafe.ai/primitives/score)
+MAX_CHOICE_KEYS = 255 # Jev's Choice ceiling (docs.typesafe.ai/primitives/choice)
+
+
+@dataclass(frozen=True, slots=True)
+class Judgment:
+ """One declared judgment read off a schema property."""
+
+ name: str
+ kind: JudgmentKind
+ keys: tuple[str, ...]
+ instruction: str | None
+ descriptions: dict[str, str | None]
+ titles: dict[str, str | None]
+
+ @property
+ def ordered(self) -> bool:
+ return self.kind == "ordered"
+
+
+# ─── §1 reading the convention ────────────────────────────────────────
+
+
+def _const_branches(prop: Mapping[str, Any]) -> list[Mapping[str, Any]] | None:
+ branches = prop.get("anyOf")
+ if not isinstance(branches, list) or not branches:
+ return None
+ if not all(isinstance(b, dict) and "const" in b for b in branches):
+ return None
+ return branches
+
+
+def _judgment_of(name: str, prop: Any) -> Judgment | None:
+ if not isinstance(prop, dict):
+ return None
+ instruction = prop.get("description") if isinstance(prop.get("description"), str) and prop.get("description") else None
+ if prop.get("type") == "boolean":
+ return Judgment(name, "boolean", ("true", "false"), instruction, {"true": None, "false": None}, {})
+ enum = prop.get("enum")
+ branches = _const_branches(prop)
+ if isinstance(enum, list) and enum and branches is None:
+ values = enum
+ descs: dict[str, str | None] = {}
+ titles: dict[str, str | None] = {}
+ elif branches is not None and enum is None:
+ values = [b["const"] for b in branches]
+ descs = {str(b["const"]): (b.get("description") if isinstance(b.get("description"), str) else None) for b in branches}
+ titles = {str(b["const"]): (b.get("title") if isinstance(b.get("title"), str) else None) for b in branches}
+ else:
+ return None
+ if all(isinstance(v, str) and v for v in values):
+ if prop.get("type") not in (None, "string"):
+ return None
+ keys = tuple(values)
+ if len(set(keys)) != len(keys):
+ return None
+ return Judgment(name, "choice", keys, instruction, {k: descs.get(k) for k in keys}, {k: titles.get(k) for k in keys})
+ if all(isinstance(v, int) and not isinstance(v, bool) for v in values):
+ if prop.get("type") not in (None, "integer"):
+ return None
+ if list(values) != list(range(len(values))) or len(values) < 2:
+ return None
+ keys = tuple(str(v) for v in values)
+ return Judgment(name, "ordered", keys, instruction, {k: descs.get(k) for k in keys}, {k: titles.get(k) for k in keys})
+ return None
+
+
+def judgments_in_schema(schema: Any) -> dict[str, Judgment]:
+ """The judgments a json_schema declares, in property order (MAP-14 §1).
+
+ Any property that is not one of the three shapes is ordinary
+ structured output and is absent from the result.
+ """
+ if not isinstance(schema, dict) or schema.get("type") not in (None, "object"):
+ return {}
+ props = schema.get("properties")
+ if not isinstance(props, dict):
+ return {}
+ out: dict[str, Judgment] = {}
+ for name, prop in props.items():
+ if not isinstance(name, str):
+ continue
+ j = _judgment_of(name, prop)
+ if j is not None:
+ out[name] = j
+ return out
+
+
+def request_judgments(request: Request) -> dict[str, Judgment]:
+ fmt = request.config.response_format
+ if not isinstance(fmt, dict) or fmt.get("type") != "json_schema":
+ return {}
+ return judgments_in_schema(fmt.get("schema"))
+
+
+def non_judgment_properties(schema: Any, found: Mapping[str, Judgment]) -> tuple[str, ...]:
+ props = schema.get("properties") if isinstance(schema, dict) else None
+ if not isinstance(props, dict):
+ return ()
+ return tuple(name for name in props if name not in found)
+
+
+# ─── §2 what a wire that measures nothing does with ``probabilities`` ──
+
+
+def note_unmeasurable_probabilities(request: Request, provider: str) -> None:
+ """MAP-14 §3 on a wire with no distribution: ``if_available`` records
+ ``dropped``; ``required`` refuses before the wire (MAP-13 b)."""
+ policy = request.config.probabilities
+ if policy in (None, "off") or not request_judgments(request):
+ return
+ if policy == "required":
+ raise UnsupportedFeatureError(
+ f"{provider}: config.probabilities='required' but this wire cannot measure a distribution "
+ "over the declared keys (it returns a pick only); use 'if_available' or a provider that can "
+ "(typesafe, or a vLLM/SGLang server that honours logprob_token_ids)",
+ provider=provider,
+ feature="config.probabilities",
+ )
+ adapt(
+ "config.probabilities",
+ "dropped",
+ "this wire cannot measure a distribution over the declared keys; the answer carries the pick only",
+ asked=policy,
+ provider=provider,
+ )
+
+
+def anthropic_schema(schema: JsonObject, found: Mapping[str, Judgment]) -> JsonObject:
+ """A judgment property carrying both ``type`` and ``anyOf`` has its type
+ moved into every branch: the Messages wire answers 400 "For 'anyOf',
+ 'type' is not supported" otherwise (receipted 2026-09-17). Every other
+ keyword stays verbatim (INV-050 exception)."""
+ if not found:
+ return schema
+ out = copy.deepcopy(schema)
+ for name in found:
+ prop = out["properties"][name]
+ branches = prop.get("anyOf")
+ if "type" in prop and isinstance(branches, list):
+ kind = prop.pop("type")
+ for b in branches:
+ b.setdefault("type", kind)
+ return out
+
+
+def gemini_schema(schema: JsonObject, found: Mapping[str, Judgment]) -> JsonObject:
+ """Judgment properties go as ``enum`` with the per-key descriptions folded
+ into the property description: ``responseJsonSchema`` ignores
+ ``anyOf``/``const`` (it answered "Bordeaux-blend" for a declared set;
+ receipted 2026-09-17) and honours ``enum``."""
+ if not found:
+ return schema
+ out = copy.deepcopy(schema)
+ for name, j in found.items():
+ prop = out["properties"][name]
+ if j.kind == "boolean" or "anyOf" not in prop:
+ continue
+ prop.pop("anyOf")
+ prop["type"] = "integer" if j.ordered else "string"
+ prop["enum"] = [int(k) for k in j.keys] if j.ordered else list(j.keys)
+ lines = []
+ for k in j.keys:
+ label = j.titles.get(k)
+ desc = j.descriptions.get(k)
+ if label is None and desc is None:
+ lines.append(k) # a bare key still tells the model it is an option (receipted wire form)
+ continue
+ lines.append(f"{k} = " + (f"{label}: {desc}" if label and desc else (label or desc or "")))
+ if any(j.titles.get(k) or j.descriptions.get(k) for k in j.keys):
+ head = prop.get("description") or ""
+ prop["description"] = (head + (" " if head else "") + ("Levels: " if j.ordered else "Options: ") + "; ".join(lines)).strip()
+ return out
+
+
+# ─── §3 the answer ────────────────────────────────────────────────────
+
+
+def data_part_from_text(text: str, found: Mapping[str, Judgment]) -> DataPart | None:
+ """The model's JSON object as a DataPart (value only), or None when the
+ text is not a JSON object (a truncated answer stays a TextPart)."""
+ if not found:
+ return None
+ try:
+ value = json.loads(text.strip())
+ except (ValueError, TypeError):
+ return None
+ if not isinstance(value, dict):
+ return None
+ return DataPart(value=value)
+
+
+def replace_text_with_data(parts: Sequence[Any], found: Mapping[str, Judgment]) -> tuple[Any, ...]:
+ """Swap the single text part of a judgment answer for its DataPart."""
+ if not found:
+ return tuple(parts)
+ texts = [p for p in parts if isinstance(p, TextPart)]
+ if len(texts) != 1:
+ return tuple(parts)
+ part = data_part_from_text(texts[0].text, found)
+ if part is None:
+ return tuple(parts)
+ if texts[0].continuation:
+ part = DataPart(value=part.value, continuation=texts[0].continuation)
+ return tuple(part if p is texts[0] else p for p in parts)
+
+
+def normalize_logprobs(scores: Mapping[str, float]) -> dict[str, float]:
+ """Softmax over log-scores: one normalisation over the key set."""
+ top = max(scores.values())
+ weights = {k: math.exp(v - top) for k, v in scores.items()}
+ total = sum(weights.values())
+ return {k: w / total for k, w in weights.items()}
+
+
+def expected_level(distribution: Mapping[str, float]) -> float:
+ return sum(float(p) * int(k) for k, p in distribution.items())
+
+
+# ─── §4 sugar that emits the convention ───────────────────────────────
+
+
+def choice(instruction: str, options: Mapping[str, str | None] | Sequence[str]) -> JsonObject:
+ """A choice judgment property: ``{key: description-or-None}`` or a list of keys."""
+ if isinstance(options, Mapping):
+ items = list(options.items())
+ else:
+ items = [(k, None) for k in options]
+ if not items:
+ raise ValueError("choice needs at least one option")
+ if any(not isinstance(k, str) or not k for k, _ in items):
+ raise TypeError("choice option keys must be non-empty strings")
+ if len({k for k, _ in items}) != len(items):
+ raise ValueError("choice option keys must be unique")
+ prop: JsonObject = {"type": "string", "description": instruction}
+ if all(d is None for _, d in items):
+ prop["enum"] = [k for k, _ in items]
+ else:
+ prop["anyOf"] = [({"const": k, "description": d} if d else {"const": k}) for k, d in items]
+ return prop
+
+
+def yes_no(instruction: str) -> JsonObject:
+ return {"type": "boolean", "description": instruction}
+
+
+def score(instruction: str, levels: Mapping[str, str] | Sequence[str]) -> JsonObject:
+ """An ordered judgment: levels low → high; ``{name: description}`` or descriptions."""
+ if isinstance(levels, Mapping):
+ items = list(levels.items())
+ else:
+ items = [(None, d) for d in levels]
+ if len(items) < 2:
+ raise ValueError("score needs at least two levels")
+ if len(items) > MAX_ORDERED_LEVELS:
+ raise ValueError(f"score takes at most {MAX_ORDERED_LEVELS} levels")
+ branches = []
+ for i, (name, desc) in enumerate(items):
+ b: JsonObject = {"const": i}
+ if name:
+ b["title"] = name
+ if desc:
+ b["description"] = desc
+ branches.append(b)
+ return {"type": "integer", "description": instruction, "anyOf": branches}
+
+
+def judgments(*, name: str = "judgments", strict: bool = True, **properties: JsonObject) -> JsonObject:
+ """A ``response_format`` declaring the given judgment properties."""
+ if not properties:
+ raise ValueError("judgments needs at least one property")
+ schema: JsonObject = {
+ "type": "object",
+ "properties": dict(properties),
+ "required": list(properties),
+ "additionalProperties": False,
+ }
+ return {"type": "json_schema", "name": name, "strict": strict, "schema": schema}
+
+
+__all__ = [
+ "Judgment", "judgments_in_schema", "request_judgments", "non_judgment_properties",
+ "note_unmeasurable_probabilities", "anthropic_schema", "gemini_schema",
+ "data_part_from_text", "replace_text_with_data", "normalize_logprobs", "expected_level",
+ "choice", "yes_no", "score", "judgments",
+]
diff --git a/dspy/_vendor/lm15/providers/__init__.py b/dspy/_vendor/lm15/providers/__init__.py
index c61f3a46a..2dc45bab8 100644
--- a/dspy/_vendor/lm15/providers/__init__.py
+++ b/dspy/_vendor/lm15/providers/__init__.py
@@ -8,6 +8,7 @@ from .async_base import (
AsyncOpenAICodexLM,
AsyncOpenAILM,
AsyncTransport,
+ AsyncTypeSafeLM,
AsyncXaiLM,
)
from .base import BaseProviderLM, Credential, HttpResponse, ProviderDialect, SyncTransport, resolve_credential
@@ -16,6 +17,7 @@ from .gemini import GeminiLM
from .openai import OpenAILM
from .openai_chat import OpenAIChatLM
from .openai_codex import OpenAICodexLM
+from .typesafe import TypeSafeLM
from .xai import XaiLM
__all__ = [
@@ -27,6 +29,8 @@ __all__ = [
"OpenAICodexLM",
"XaiLM",
"AsyncXaiLM",
+ "TypeSafeLM",
+ "AsyncTypeSafeLM",
"AsyncOpenAILM",
"AsyncOpenAIChatLM",
"AsyncAnthropicLM",
diff --git a/dspy/_vendor/lm15/providers/anthropic.py b/dspy/_vendor/lm15/providers/anthropic.py
index c6f34fbad..1e3d6afd9 100644
--- a/dspy/_vendor/lm15/providers/anthropic.py
+++ b/dspy/_vendor/lm15/providers/anthropic.py
@@ -25,9 +25,11 @@ from ..errors import (
from ..access import ANTHROPIC_API
from ..compat import ANTHROPIC_PRESET_BASE_URLS, AnthropicCompat, ResolvedAnthropicCompat, preset_base_url, resolve_anthropic_compat
from ..features import ProviderManifest
+from ..judgments import anthropic_schema, note_unmeasurable_probabilities, replace_text_with_data, request_judgments
from ..sse import SSEEvent
from ..transports import TransportRequest
from ..types import (
+ DataPart,
BatchEntry,
BatchJobInfo,
BatchRequest,
@@ -70,7 +72,7 @@ from .base import (
batch_entry_request,
default_transport,
)
-from .common import EFFORT_THINKING_BUDGETS, MEDIA_KINDS, anthropic_source, check_tool_result_media, iso_utc, model_infos_from_entries, multipart_form_body, parts_to_text, path_id, unnamed_tool_call_error
+from .common import EFFORT_THINKING_BUDGETS, MEDIA_KINDS, anthropic_source, check_tool_result_media, data_part_text, iso_utc, model_infos_from_entries, multipart_form_body, parts_to_text, path_id, unnamed_tool_call_error
# Canonical builtin tool name → Anthropic tool format
_ANTHROPIC_BUILTIN_MAP: dict[str, str] = {
@@ -278,6 +280,9 @@ class AnthropicLM(BaseProviderLM):
access: ProviderManifest | None = None
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = None
+ # A named cloud identity ("platform", "workload", "environment", "cli";
+ # AUTH-1) on a cloud door, instead of api_key=.
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
# MAP-13 policy: "note" (adapt and record), "silent", or "refuse".
@@ -289,7 +294,8 @@ class AnthropicLM(BaseProviderLM):
def __post_init__(self) -> None:
check_policy(self.adaptations)
- self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings)
+ self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings,
+ credential=self.credential)
compat = self.compat if self.compat is not None else self._registry_compat()
if isinstance(compat, str):
# A preset name also supplies that server's default base_url; an
@@ -445,6 +451,8 @@ class AnthropicLM(BaseProviderLM):
def _part(self, part) -> dict[str, Any]:
if isinstance(part, TextPart):
return {"type": "text", "text": part.text}
+ if isinstance(part, DataPart):
+ return {"type": "text", "text": data_part_text(part)}
if isinstance(part, ImagePart):
return {"type": "image", "source": anthropic_source(part)}
if isinstance(part, DocumentPart):
@@ -487,6 +495,8 @@ class AnthropicLM(BaseProviderLM):
def _tool_result_content(self, part) -> dict[str, Any]:
if isinstance(part, TextPart):
return {"type": "text", "text": part.text}
+ if isinstance(part, DataPart):
+ return {"type": "text", "text": data_part_text(part)}
if isinstance(part, ImagePart):
return {"type": "image", "source": anthropic_source(part)}
if isinstance(part, DocumentPart):
@@ -789,7 +799,15 @@ class AnthropicLM(BaseProviderLM):
"describe the shape in the prompt",
asked=request.config.response_format, provider=self.provider)
else:
- output_config = _response_format_to_anthropic_output_config(request.config.response_format)
+ # MAP-14 §2: a judgment property carrying type+anyOf has its
+ # type moved into every branch (the wire 400s otherwise,
+ # receipted 2026-09-17); probabilities cannot be measured here.
+ note_unmeasurable_probabilities(request, self.provider)
+ found = request_judgments(request)
+ fmt = request.config.response_format
+ if found:
+ fmt = {**fmt, "schema": anthropic_schema(fmt["schema"], found)}
+ output_config = _response_format_to_anthropic_output_config(fmt)
payload["output_config"] = {**payload.get("output_config", {}), **output_config}
# Promoted cross-provider knobs (changes/2026-09-01-extensions-burn-down):
# user_id rides Anthropic's metadata.user_id; store has no Anthropic
@@ -835,6 +853,7 @@ class AnthropicLM(BaseProviderLM):
return payload
def build_request(self, request: Request, stream: bool) -> TransportRequest:
+ request = self._wire_request(request)
return self._emit(
method="POST",
url=f"{self.base_url.rstrip('/')}/messages",
@@ -848,6 +867,7 @@ class AnthropicLM(BaseProviderLM):
# ─── Response parsing ───────────────────────────────────────────
def parse_response(self, request: Request, response: HttpResponse) -> Response:
+ request = self._wire_request(request)
data = response.json()
parts: list[Any] = []
unmapped: list[dict[str, str]] = []
@@ -926,13 +946,14 @@ class AnthropicLM(BaseProviderLM):
return Response(
id=str(data.get("id")) if data.get("id") else None,
model=str(data.get("model") or request.model),
- message=Message(role="assistant", parts=tuple(parts)),
+ message=Message(role="assistant", parts=replace_text_with_data(parts, request_judgments(request))),
finish_reason=_finish_reason(data.get("stop_reason"), has_tool_call=has_tool),
usage=usage,
provider_data=_attach_unmapped(data, unmapped),
)
def parse_stream_events(self, request: Request, raw_event: SSEEvent) -> Iterator[StreamEvent]:
+ request = self._wire_request(request)
if not raw_event.data:
return
payload = json.loads(raw_event.data)
@@ -1058,7 +1079,6 @@ class AnthropicLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/models",
params={"limit": 1000},
headers=self._headers(),
- read_timeout=30.0,
)
def _models_from_body(self, body: str):
@@ -1091,7 +1111,6 @@ class AnthropicLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/files",
headers=list(headers.items()),
body=body,
- read_timeout=300.0,
)
def _file_info_from_body(self, body: str) -> FileInfo:
@@ -1118,7 +1137,7 @@ class AnthropicLM(BaseProviderLM):
def _file_get_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _file_list_request(self, limit: int, cursor: str | None) -> TransportRequest:
@@ -1127,7 +1146,7 @@ class AnthropicLM(BaseProviderLM):
params["page"] = cursor
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files",
- params=params, headers=self._headers(), read_timeout=60.0,
+ params=params, headers=self._headers(),
)
def _file_page_from_list_body(self, body: str) -> FilePage:
@@ -1140,18 +1159,19 @@ class AnthropicLM(BaseProviderLM):
def _file_delete_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="DELETE", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _file_download_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}/content",
- headers=self._headers(), read_timeout=300.0,
+ headers=self._headers(),
)
# ─── Batch hooks (Message Batches API) ────────────────────────
def _batch_submit_request(self, request: BatchRequest, upload_body: dict[str, Any] | None) -> TransportRequest:
+ self._batch_preflight(request)
if request.label is not None:
adapt("label", "dropped",
"the Message Batches create body has no metadata field (verified live "
@@ -1169,7 +1189,6 @@ class AnthropicLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/messages/batches",
headers=self._headers(),
payload=payload,
- read_timeout=120.0,
)
def _batch_job_from_body(self, body: str) -> BatchJobInfo:
@@ -1191,7 +1210,6 @@ class AnthropicLM(BaseProviderLM):
method="GET",
url=f"{self.base_url.rstrip('/')}/messages/batches/{path_id(batch_id)}",
headers=self._headers(),
- read_timeout=60.0,
)
def _batch_cancel_request(self, batch_id: str) -> TransportRequest:
@@ -1199,14 +1217,13 @@ class AnthropicLM(BaseProviderLM):
method="POST",
url=f"{self.base_url.rstrip('/')}/messages/batches/{path_id(batch_id)}/cancel",
headers=self._headers(),
- read_timeout=60.0,
)
def _batch_result_fetches(self, status_body: dict[str, Any]) -> tuple[TransportRequest, ...]:
url = status_body.get("results_url")
if not isinstance(url, str) or not url:
raise ProviderError("anthropic: ended batch carries no results_url", provider=self.provider)
- return (self._emit(method="GET", url=url, headers=self._headers(), read_timeout=300.0),)
+ return (self._emit(method="GET", url=url, headers=self._headers()),)
def _batch_entries(self, status_body: dict[str, Any], fetched: tuple[str, ...]) -> tuple[BatchEntry, ...]:
entries: list[BatchEntry] = []
@@ -1254,7 +1271,6 @@ class AnthropicLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/messages/batches",
params={"limit": int(limit)},
headers=self._headers(),
- read_timeout=60.0,
)
def _batch_jobs_from_list_body(self, body: str) -> tuple[BatchJobInfo, ...]:
diff --git a/dspy/_vendor/lm15/providers/async_base.py b/dspy/_vendor/lm15/providers/async_base.py
index 0c3fd381c..05441387b 100644
--- a/dspy/_vendor/lm15/providers/async_base.py
+++ b/dspy/_vendor/lm15/providers/async_base.py
@@ -21,7 +21,8 @@ import os
from dataclasses import dataclass, field
from typing import Any, AsyncIterator, Callable, ClassVar, Mapping, Protocol, TypeVar
-from ..adaptation import AdaptationPolicy
+from ..adaptation import AdaptationPolicy, adapt, check_policy, collecting
+from ..judgments import request_judgments
from ..errors import (
ProviderError,
TransportError as LM15TransportError,
@@ -47,7 +48,10 @@ from ..types import (
StreamEvent,
)
from .anthropic import AnthropicLM
-from .base import BaseProviderLM, Credential, HttpResponse, _attach_error_metadata, _client_side_stop
+from .base import (
+ BaseProviderLM, Credential, HttpResponse, _attach_error_metadata, _client_side_stop,
+ _parse_reply, _reply_error_metadata, _reply_object, _stream_error_metadata,
+)
from .claude_code import DEFAULT_CLAUDE_CODE_VERSION, ClaudeCodeLM
from .gemini import GeminiLM
from .openai import OpenAILM
@@ -58,6 +62,7 @@ from .openai_codex import (
DEFAULT_CODEX_ORIGINATOR,
OpenAICodexLM,
)
+from .typesafe import TypeSafeLM
from .xai import DEFAULT_XAI_BASE_URL, XaiLM
_T = TypeVar("_T")
@@ -164,7 +169,11 @@ class AsyncBaseProviderLM:
resp = await self._send(req)
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._finish_response(request, self._inner.parse_response(request, resp), adaptations, policy=self.adaptations)
+ try:
+ return self._inner._finish_response(request, self._inner.parse_response(request, resp), adaptations, policy=self.adaptations)
+ except ProviderError as error:
+ _attach_error_metadata(error, resp.headers)
+ raise
def stream(self, request: Request) -> AsyncIterator[StreamEvent]:
# MAP-3 (docs/mapping-rules.md): adapters may emit one end event per
@@ -175,7 +184,7 @@ class AsyncBaseProviderLM:
async def _astream(self, request: Request) -> AsyncIterator[StreamEvent]:
from ..result import acoalesce_stream, atruncate_stream_at_stop
req, adaptations = await self._build(self._inner._build, request, stream=True, policy=self.adaptations)
- events = acoalesce_stream(self._stream_raw(request, req), model=request.model, adaptations=self._inner._visible(adaptations, policy=self.adaptations))
+ events = acoalesce_stream(self._stream_raw(request, req), model=self._inner._wire_request(request).model, adaptations=self._inner._visible(adaptations, policy=self.adaptations))
if _client_side_stop(adaptations):
events = atruncate_stream_at_stop(events, request.config.stop)
try:
@@ -198,10 +207,14 @@ class AsyncBaseProviderLM:
)
_attach_error_metadata(error, resp.headers)
raise error
- async for raw in aparse_sse(_aiter_lines(resp)):
- for event in self._inner.parse_stream_events(request, raw):
- if event is not None:
- yield event
+ try:
+ async for raw in aparse_sse(_aiter_lines(resp)):
+ for event in self._inner.parse_stream_events(request, raw):
+ if event is not None:
+ yield _stream_error_metadata(event, resp.headers)
+ except ProviderError as error:
+ _attach_error_metadata(error, resp.headers)
+ raise
except NetworkTransportError as exc:
raise LM15TransportError(str(exc)) from exc
@@ -228,28 +241,35 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._models_request))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._models_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._models_from_body(reply.text()))
# ── Batch: async drivers over the sync adapter's pure hooks ──────
async def batch_submit(self, request: "BatchRequest"):
+ self._inner._batch_preflight(request)
upload_body = None
upload_req = await self._build(self._inner._batch_upload_request, request)
if upload_req is not None:
resp = await self._send(upload_req)
if resp.status >= 400:
raise self._inner._http_error(resp)
- upload_body = resp.json()
- resp = await self._send(await self._build(self._inner._batch_submit_request, request, upload_body))
+ upload_body = _parse_reply(resp, _reply_object)
+ try:
+ submit_req = await self._build(self._inner._batch_submit_request, request, upload_body)
+ except ProviderError as error:
+ if upload_req is not None:
+ _reply_error_metadata(error, resp)
+ raise
+ resp = await self._send(submit_req)
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._batch_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._batch_job_from_body(reply.text()))
async def batch_status(self, batch_id: str):
resp = await self._send(await self._build(self._inner._batch_status_request, batch_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._batch_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._batch_job_from_body(reply.text()))
async def batch_results(self, batch_id: str):
from ..types import BATCH_TERMINAL_STATUSES
@@ -257,32 +277,37 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._batch_status_request, batch_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- job = self._inner._batch_job_from_body(resp.text())
+ job = _parse_reply(resp, lambda reply: self._inner._batch_job_from_body(reply.text()))
if job.status not in BATCH_TERMINAL_STATUSES:
raise ValueError(
f"batch {batch_id} is not finished (status={job.status!r}); "
f"await wait() or poll batch_status() until done"
)
- status_body = resp.json()
+ status_body = _parse_reply(resp, _reply_object)
+ try:
+ fetches = await self._build(self._inner._batch_result_fetches, status_body)
+ except ProviderError as error:
+ _reply_error_metadata(error, resp)
+ raise
texts = []
- for fetch in await self._build(self._inner._batch_result_fetches, status_body):
+ for fetch in fetches:
fetched = await self._send(fetch)
if fetched.status >= 400:
raise self._inner._http_error(fetched)
- texts.append(fetched.text())
- return self._inner._batch_entries(status_body, tuple(texts))
+ texts.append(self._inner._batch_reply_text(status_body, fetched))
+ return _parse_reply(resp, lambda reply: self._inner._batch_entries(status_body, tuple(texts)), json_body=False)
async def batch_cancel(self, batch_id: str):
resp = await self._send(await self._build(self._inner._batch_cancel_request, batch_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._batch_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._batch_job_from_body(reply.text()))
async def batch_list(self, limit: int = 20):
resp = await self._send(await self._build(self._inner._batch_list_request, limit))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._batch_jobs_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._batch_jobs_from_list_body(reply.text()))
async def batch(self, requests, *, model: str | None = None, label: str | None = None,
extensions=None):
@@ -312,19 +337,19 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._cache_create_request, prefix, ttl_seconds, label))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._cache_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._cache_info_from_body(reply.text()))
async def cache_get(self, cache_id: str):
resp = await self._send(await self._build(self._inner._cache_get_request, cache_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._cache_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._cache_info_from_body(reply.text()))
async def cache_list(self, limit: int = 20, cursor: str | None = None):
resp = await self._send(await self._build(self._inner._cache_list_request, limit, cursor))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._cache_page_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._cache_page_from_list_body(reply.text()))
async def cache_delete(self, cache_id: str) -> None:
resp = await self._send(await self._build(self._inner._cache_delete_request, cache_id))
@@ -337,15 +362,17 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._cache_update_request, cache_id, ttl_seconds))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._cache_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._cache_info_from_body(reply.text()))
async def cache(self, prefix: Request, *, ttl_seconds: int | None = None, label: str | None = None):
from ..types import CachedPrefix
+ wire = self._inner._wire_request(prefix)
+ provider = self.provider if wire.model != prefix.model else None
if self.supports.caches:
- return CachedPrefix(prefix, await self.cache_create(prefix, ttl_seconds=ttl_seconds, label=label))
- self._inner._check_cache_prefix(prefix, ttl_seconds)
- return CachedPrefix(prefix)
+ return CachedPrefix(wire, await self.cache_create(wire, ttl_seconds=ttl_seconds, label=label), provider=provider)
+ self._inner._check_cache_prefix(wire, ttl_seconds)
+ return CachedPrefix(wire, provider=provider)
# ── Files: async drivers over the sync adapter's pure hooks ──────
@@ -353,19 +380,19 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._file_upload_request, request))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._file_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._file_info_from_body(reply.text()))
async def file_get(self, file_id: str):
resp = await self._send(await self._build(self._inner._file_get_request, file_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._file_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._file_info_from_body(reply.text()))
async def file_list(self, limit: int = 20, cursor: str | None = None):
resp = await self._send(await self._build(self._inner._file_list_request, limit, cursor))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._file_page_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._file_page_from_list_body(reply.text()))
async def file_delete(self, file_id: str) -> None:
resp = await self._send(await self._build(self._inner._file_delete_request, file_id))
@@ -420,13 +447,13 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._video_submit_request, request))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._video_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._video_job_from_body(reply.text()))
async def video_status(self, video_id: str):
resp = await self._send(await self._build(self._inner._video_status_request, video_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._video_job_from_body(resp.text(), video_id)
+ return _parse_reply(resp, lambda reply: self._inner._video_job_from_body(reply.text(), video_id))
async def video_result(self, video_id: str):
from ..types import VIDEO_TERMINAL_STATUSES
@@ -434,26 +461,30 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._video_status_request, video_id))
if resp.status >= 400:
raise self._inner._http_error(resp)
- job = self._inner._video_job_from_body(resp.text(), video_id)
+ job = _parse_reply(resp, lambda reply: self._inner._video_job_from_body(reply.text(), video_id))
if job.status not in VIDEO_TERMINAL_STATUSES:
raise ValueError(
f"video {video_id} is not finished (status={job.status!r}); "
f"wait() or poll video_status() until done"
)
- status_body = resp.json()
- fetch = await self._build(self._inner._video_result_fetch, status_body)
+ status_body = _parse_reply(resp, _reply_object)
+ try:
+ fetch = await self._build(self._inner._video_result_fetch, status_body)
+ except ProviderError as error:
+ _reply_error_metadata(error, resp)
+ raise
fetched = None
if fetch is not None:
fetched = await self._send(fetch)
if fetched.status >= 400:
raise self._inner._http_error(fetched)
- return self._inner._video_part(status_body, fetched)
+ return _parse_reply(fetched or resp, lambda reply: self._inner._video_part(status_body, fetched), json_body=False)
async def video_list(self, limit: int = 20, model: str | None = None):
resp = await self._send(await self._build(self._inner._video_list_request, limit, model))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._video_jobs_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._inner._video_jobs_from_list_body(reply.text()))
async def video_generate(self, request: "VideoGenerationRequest"):
from ..video_jobs import AsyncVideoJob
@@ -476,13 +507,13 @@ class AsyncBaseProviderLM:
resp = await self._send(await self._build(self._inner._image_generate_request, request))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._image_generation_from_response(request, resp)
+ return _parse_reply(resp, lambda reply: self._inner._image_generation_from_response(request, reply))
async def speech_generate(self, request: SpeechGenerationRequest):
resp = await self._send(await self._build(self._inner._speech_generate_request, request))
if resp.status >= 400:
raise self._inner._http_error(resp)
- return self._inner._speech_generation_from_response(request, resp)
+ return _parse_reply(resp, lambda reply: self._inner._speech_generation_from_response(request, reply), json_body=False)
async def _aiter_lines(resp: AsyncTransportResponse) -> AsyncIterator[bytes]:
@@ -519,6 +550,7 @@ class AsyncOpenAILM(AsyncBaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = field(default=None, kw_only=True)
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False, kw_only=True)
account_id: str | None = None
adaptations: AdaptationPolicy = field(default="note", kw_only=True)
@@ -560,6 +592,7 @@ class AsyncOpenAILM(AsyncBaseProviderLM):
access=self.access,
credentials_path=self.credentials_path,
settings=self.settings,
+ credential=self.credential,
clock=self.clock,
account_id=self.account_id,
)
@@ -579,6 +612,7 @@ class AsyncAnthropicLM(AsyncBaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = None
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
adaptations: AdaptationPolicy = field(default="note", kw_only=True)
@@ -598,6 +632,7 @@ class AsyncAnthropicLM(AsyncBaseProviderLM):
access=self.access,
credentials_path=self.credentials_path,
settings=self.settings,
+ credential=self.credential,
clock=self.clock,
)
self._mirror_binding()
@@ -616,6 +651,7 @@ class AsyncGeminiLM(AsyncBaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = None
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
adaptations: AdaptationPolicy = field(default="note", kw_only=True)
@@ -634,6 +670,7 @@ class AsyncGeminiLM(AsyncBaseProviderLM):
access=self.access,
credentials_path=self.credentials_path,
settings=self.settings,
+ credential=self.credential,
clock=self.clock,
)
self._mirror_binding()
@@ -669,6 +706,7 @@ class AsyncOpenAIChatLM(AsyncBaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = None
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
adaptations: AdaptationPolicy = field(default="note", kw_only=True)
@@ -687,6 +725,7 @@ class AsyncOpenAIChatLM(AsyncBaseProviderLM):
access=self.access,
credentials_path=self.credentials_path,
settings=self.settings,
+ credential=self.credential,
clock=self.clock,
)
self._mirror_binding()
@@ -703,6 +742,99 @@ class AsyncOpenAIChatLM(AsyncBaseProviderLM):
"""Pure; the sync sibling's reader under this adapter's provider name."""
return self._inner.response_from_openai_chat(body, model=model, choice=choice)
+ async def complete(self, request: Request) -> Response:
+ """Mirror of OpenAIChatLM.complete: the judgment trie driver (MAP-14
+ §4) over the inner adapter's pure hooks, else the ordinary path."""
+ inner = self._inner
+ wire_request = inner._wire_request(request)
+ if not inner._judgments_via_token_scoring(wire_request):
+ return await AsyncBaseProviderLM.complete(self, request)
+ adaptations = inner._judgment_adaptations(wire_request, policy=self.adaptations)
+ found = request_judgments(request)
+ plan = await self._build(inner._judgment_plan, wire_request)
+
+ async def tokens(req):
+ resp = await self._send(req)
+ if resp.status >= 400:
+ raise inner._http_error(resp)
+ return inner._judgment_tokens_from_body(resp)
+
+ tokenized = []
+ calls = 0
+ for entry in plan:
+ prefix = await tokens(entry["prefill"]); calls += 1
+ pairs = await asyncio.gather(*(asyncio.gather(tokens(o), tokens(c)) for o, c in entry["keys"].values()))
+ calls += 2 * len(pairs)
+ keys = {k: (list(o), list(c)) for k, (o, c) in zip(entry["keys"], pairs)}
+ tokenized.append((entry["judgment"], inner._judgment_paths(prefix, keys), prefix))
+ prompts, meta, union, nodes_per = [], [], set(), []
+ for index, (j, paths, prefix) in enumerate(tokenized):
+ nodes = inner._judgment_nodes(paths)
+ nodes_per.append(nodes)
+ for node_prefix, children in nodes.items():
+ prompts.append(list(prefix) + list(node_prefix))
+ meta.append((index, node_prefix))
+ union |= children
+ scoring_request = await self._build(inner._judgment_score_request, wire_request.model, prompts, sorted(union))
+ resp = await self._send(scoring_request)
+ if resp.status >= 400:
+ raise inner._http_error(resp)
+ scores, usage, model = inner._judgment_scores_from_body(resp, len(prompts))
+ tables: list[dict] = [{} for _ in tokenized]
+ for (index, node_prefix), got in zip(meta, scores):
+ children = nodes_per[index][node_prefix]
+ if any(t not in got for t in children):
+ return await self._judgment_unmeasured(request, adaptations, usage)
+ tables[index][node_prefix] = {t: got[t] for t in children}
+ per = [(j, paths, tables[i]) for i, (j, paths, _) in enumerate(tokenized)]
+ try:
+ response = inner._judgment_fold(wire_request, found, per, usage, model, len(prompts), calls)
+ except ProviderError as error:
+ error.status = resp.status
+ _attach_error_metadata(error, resp.headers)
+ raise
+ from dataclasses import replace
+
+ if inner._judgment_mixed(request):
+ generated, _ = await self._judgment_generate(request)
+ response = inner._judgment_merge(response, generated)
+ return replace(response, adaptations=inner._visible(adaptations, policy=self.adaptations))
+
+ async def _judgment_generate(self, request: Request, *, unmeasured: bool = False):
+ from dataclasses import replace
+ from ..result import amaterialize_response
+
+ inner = self._inner
+ generated_request = inner._judgment_generated_request(request)
+ wire, built = await self._build(inner._build, generated_request, stream=False, policy=self.adaptations)
+ if _client_side_stop(built):
+ plain = replace(generated_request, config=replace(generated_request.config, response_format=None))
+ response = await amaterialize_response(self.stream(generated_request), plain)
+ return inner._judgment_generated_value(generated_request, response, unmeasured=unmeasured), built
+ reply = await self._send(wire)
+ if reply.status >= 400:
+ raise inner._http_error(reply)
+ return inner._judgment_generated_response(generated_request, reply, built, policy=self.adaptations, unmeasured=unmeasured), built
+
+ async def _judgment_unmeasured(self, request: Request, adaptations, usage) -> Response:
+ inner = self._inner
+ if request.config.probabilities == "required":
+ raise UnsupportedFeatureError(
+ f"{self.provider}: config.probabilities='required' but this server ignored logprob_token_ids "
+ "(vLLM < 0.29?); no distribution can be measured here",
+ provider=self.provider, feature="config.probabilities",
+ )
+ with collecting(check_policy(self.adaptations), provider=self.provider) as scope:
+ adapt("config.probabilities", "dropped",
+ "the server accepted the request and returned no log-probs for the requested token ids (logprob_token_ids ignored); "
+ "answered by structured output instead", asked=request.config.probabilities, provider=self.provider)
+ from dataclasses import replace
+
+ response, built = await self._judgment_generate(request, unmeasured=True)
+ response = inner._judgment_fallback_usage(response, usage)
+ records = tuple(adaptations) + tuple(scope.records) + tuple(a for a in built if a not in adaptations)
+ return replace(response, adaptations=inner._visible(records, policy=self.adaptations))
+
# ─── Subscription mirrors (Claude Code / Codex CLI OAuth) ────────────
#
@@ -903,3 +1035,36 @@ __all__ = [
"AsyncXaiLM",
"default_async_transport",
]
+
+
+@dataclass
+class AsyncTypeSafeLM(AsyncBaseProviderLM):
+ """Async mirror of :class:`TypeSafeLM` (composition; the inner adapter
+ cannot reach the network)."""
+
+ api_key: Credential | None = field(default=None, repr=False)
+ transport: AsyncTransport = field(default_factory=default_async_transport)
+ base_url: str = "https://api.typesafe.ai"
+ access: ProviderManifest | None = field(default=None, repr=False)
+ credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
+ settings: "Mapping[str, str] | None" = None
+ clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
+ adaptations: AdaptationPolicy = field(default="note", kw_only=True)
+
+ provider: str = field(default="typesafe", init=False)
+ manifest: ClassVar[ProviderManifest] = TypeSafeLM.manifest
+
+ _inner: TypeSafeLM = field(init=False, repr=False, compare=False)
+
+ def __post_init__(self) -> None:
+ self._inner = TypeSafeLM(
+ adaptations=self.adaptations,
+ api_key=self.api_key,
+ transport=_ForbiddenTransport(),
+ base_url=self.base_url,
+ access=self.access,
+ credentials_path=self.credentials_path,
+ settings=self.settings,
+ clock=self.clock,
+ )
+ self._mirror_binding()
diff --git a/dspy/_vendor/lm15/providers/base.py b/dspy/_vendor/lm15/providers/base.py
index 6ecbd2744..9f599e4bd 100644
--- a/dspy/_vendor/lm15/providers/base.py
+++ b/dspy/_vendor/lm15/providers/base.py
@@ -3,9 +3,9 @@ from __future__ import annotations
import json
import math
import os
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
from datetime import datetime
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterator, Mapping, Protocol, Sequence
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterator, Mapping, Protocol, Sequence, TypeVar
if TYPE_CHECKING: # pragma: no cover - import cycle guard for annotations
from ..batch import BatchJob
@@ -54,6 +54,7 @@ from ..types import (
Request,
Response,
StreamEvent,
+ StreamErrorEvent,
)
@@ -84,6 +85,19 @@ def resolve_credential_value(credential: Credential) -> CredentialValue:
return coerce_credential(raw)
+def _origin_label(credential: Credential | None, source: str) -> str:
+ """The provenance label for a credential the adapter was handed (AUTH-1
+ provenance). Honest about what lm15 can see: a callable's identity is
+ not inspected."""
+ if credential is None or credential == "":
+ return "no credential"
+ if source == "stored":
+ return "the stored local login (credentials file)"
+ if callable(credential):
+ return "an application-supplied callable (identity not inspected by lm15)"
+ return "an explicit api_key (value never shown)"
+
+
def resolve_credential(credential: Credential) -> str:
"""The bearer/key STRING of a credential — the pre-2026-09-03 shape the
dialects' header code reads. AWS credentials have no single string;
@@ -135,20 +149,52 @@ def _attach_retry_after(error: ProviderError, headers: "list[tuple[str, str]] |
seconds = _retry_after_seconds(value)
if seconds is not None:
error.retry_after = seconds
+ return
+ from ..rate_limits import milliseconds_seconds
+
+ for name in ("retry-after-ms", "x-ms-retry-after-ms"):
+ value = next((v for k, v in headers or [] if k.lower() == name), None)
+ seconds = milliseconds_seconds(value)
+ if seconds is not None:
+ error.retry_after = seconds
+ return
def _attach_error_metadata(error: ProviderError, headers: "list[tuple[str, str]] | None") -> None:
"""Fill HTTP diagnostics absent from the body; never invent absent fields."""
+ from ..rate_limits import capture_rate_limits
+
+ error.rate_limit_headers = capture_rate_limits(headers or [])
_attach_retry_after(error, headers)
if error.request_id is not None:
return
- values = {key.lower(): value for key, value in headers or []}
- for name in ("x-request-id", "request-id", "x-amzn-requestid", "x-amz-request-id", "x-ms-request-id"):
+ values = {}
+ for key, value in headers or []:
+ values.setdefault(key.lower(), value)
+ for name in ("x-request-id", "request-id", "x-amzn-requestid", "x-amz-request-id", "x-ms-request-id", "apim-request-id", "x-typesafe-request-id"):
if values.get(name):
error.request_id = values[name]
break
+def _stream_error_metadata(event, headers):
+ """Handshake evidence on an in-stream error; never infer status 200."""
+ if not isinstance(event, StreamErrorEvent):
+ return event
+ error = ProviderError()
+ _attach_error_metadata(error, headers)
+ http = {}
+ if error.request_id is not None:
+ http["request_id"] = error.request_id
+ if error.retry_after is not None:
+ http["retry_after"] = error.retry_after
+ if error.rate_limit_headers:
+ http["rate_limit_headers"] = {k: list(v) for k, v in error.rate_limit_headers.items()}
+ if not http:
+ return event
+ return replace(event, error=replace(event.error, http_response=http))
+
+
@dataclass(frozen=True, slots=True)
class HttpResponse:
"""Buffered provider-level HTTP response.
@@ -190,12 +236,11 @@ class HttpResponse:
try:
return json.loads(self.body)
except (ValueError, UnicodeDecodeError) as exc:
- raise ProviderError(
- _non_json_message(self, exc),
- provider=self.provider,
- status=self.status,
- request_id=self.header("x-request-id") or self.header("request-id"),
- ) from exc
+ error = ProviderError(
+ _non_json_message(self, exc), provider=self.provider, status=self.status,
+ )
+ _attach_error_metadata(error, self.headers)
+ raise error from exc
def _non_json_message(response: "HttpResponse", exc: Exception) -> str:
@@ -210,6 +255,67 @@ def _non_json_message(response: "HttpResponse", exc: Exception) -> str:
)
+_Reply = TypeVar("_Reply")
+
+
+def _reply_error_metadata(error: ProviderError, response: HttpResponse) -> None:
+ """Fill missing provider/status and attach the shared HTTP diagnostics."""
+ if error.provider is None:
+ error.provider = response.provider
+ if error.status is None:
+ error.status = response.status
+ _attach_error_metadata(error, response.headers)
+
+
+def _parse_reply(
+ response: HttpResponse, parser: Callable[[HttpResponse], _Reply], *, json_body: bool = True,
+) -> _Reply:
+ """Pure reply-decoder boundary, shared by sync and async auxiliary drivers.
+
+ Only pass parsing here, never request builders, credentials or user callbacks.
+ Binary media and JSONL opt out of whole-body JSON validation. Local control
+ errors (notably RuntimeError for a not-ready result) deliberately pass through.
+ """
+ try:
+ if json_body:
+ response.json()
+ return parser(response)
+ except ProviderError as error:
+ _reply_error_metadata(error, response)
+ raise
+ except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+ error = ProviderError(_non_json_message(response, exc))
+ _reply_error_metadata(error, response)
+ raise error from exc
+ except (TypeError, ValueError, KeyError, AttributeError, IndexError, OverflowError) as exc:
+ # Canonical constructors and provider field access can reject valid
+ # JSON with an unusable shape. This is a reply fault, not bad input.
+ content_type = response.header("content-type") or "no content-type"
+ excerpt = response.body[:200].decode("utf-8", errors="replace")
+ error = ProviderError(
+ f"malformed provider reply (HTTP {response.status}, {content_type}): "
+ f"{exc}. Body starts: {excerpt!r}"
+ )
+ _reply_error_metadata(error, response)
+ raise error from exc
+
+
+def _reply_object(response: HttpResponse) -> dict[str, Any]:
+ data = response.json()
+ if not isinstance(data, dict):
+ raise TypeError("expected a JSON object")
+ return data
+
+
+def _jsonl_reply_text(response: HttpResponse) -> str:
+ # Decode strictly before the legacy text hooks can replace invalid UTF-8.
+ text = response.body.decode("utf-8")
+ for line in text.splitlines():
+ if line.strip():
+ json.loads(line)
+ return text
+
+
class ProviderDialect(Protocol):
provider: str
supports: EndpointSupport
@@ -261,6 +367,12 @@ class BaseProviderLM:
# dialect declares it as a constructor field; this is the fallback.
adaptations: AdaptationPolicy = "note"
_credential_source: str = "explicit"
+ # AUTH-1 provenance (amended 2026-09-19): where the credential came
+ # from, as a human label, for auth errors. A static label for an
+ # explicit value / env key / stored login; a cloud chain provider
+ # carries its own (``.source``), read at error time so the label names
+ # the rung that actually won.
+ _credential_origin: str | None = None
# Cloud-host state (AUTH-10): the resolved host settings and the clock
# every time-dependent byte (SigV4 date, JWT iat/exp) is read from. The
# harness injects a fixed clock; users never touch it.
@@ -270,6 +382,19 @@ class BaseProviderLM:
# (Anthropic ``x-api-key``, Gemini ``x-goog-api-key``).
_api_key_header: ClassVar[str] = "x-api-key"
+ def _wire_request(self, request: Request) -> Request:
+ """Strip exactly this binding's prefix once, at a codec boundary.
+
+ Keep the caller request in drivers so subsequent build/parse boundaries
+ each see the original spelling; other colon-bearing IDs are opaque.
+ """
+ head, sep, model = request.model.partition(":")
+ if sep and model and head.replace("_", "-") == self.provider.replace("_", "-"):
+ from dataclasses import replace
+
+ return replace(request, model=model)
+ return request
+
@property
def supports(self) -> EndpointSupport:
"""The endpoint surfaces this bound access path carries."""
@@ -290,6 +415,7 @@ class BaseProviderLM:
credentials_path: "str | os.PathLike[str] | None" = None,
default_base_url: str | None = None,
settings: "Mapping[str, str] | None" = None,
+ credential: str | None = None,
) -> None:
"""Bind the access policy and resolve the credential it calls for.
@@ -300,7 +426,15 @@ class BaseProviderLM:
and defaults only — the router fills env fallbacks, like it does for
the key), and ``base_url``: the policy's own, or the host template
rendered over the settings, when the caller left the dialect's
- default.
+ default; an explicit ``base_url`` on a cloud door is the endpoint
+ root, and the door's path is appended unless already present
+ (AUTH-10, amended 2026-09-19).
+
+ ``credential`` names one identity on a cloud door (``platform``,
+ ``workload``, ``environment``, ``cli``; AUTH-1 named credentials):
+ that rung only, read from this process's environment, never the
+ chain. It cannot be combined with ``api_key``: two answers to "who
+ am I" is a configuration error, not a precedence question.
"""
from ..access import load_credential
from ..cloud.hosts import render_base_url, resolve_settings
@@ -308,26 +442,67 @@ class BaseProviderLM:
policy = access if access is not None else type(self).manifest
self.access = policy
self.provider = policy.provider
- loaded = load_credential(policy, self.api_key, credentials_path=credentials_path)
- self.api_key = loaded.credential
- self._credential_source = loaded.source
- if loaded.account_id is not None and self.account_id is None:
- self.account_id = loaded.account_id
- if loaded.credential is not None and not callable(loaded.credential):
- # A static credential of the wrong kind for this door fails now,
- # not on the first request (a provider callable is checked per call).
- from ..access import select_scheme
-
- select_scheme(policy, coerce_credential(loaded.credential))
- self.host_settings = resolve_settings(policy.host, settings, None, provider=policy.provider)
+ endpoint = self.base_url if (policy.host is not None and default_base_url is not None
+ and self.base_url != default_base_url) else None
+ if credential is not None:
+ if not policy.cloud_chain:
+ raise NotConfiguredError(
+ f"{policy.provider}: credential={credential!r} names a cloud identity, and this door is not a "
+ "cloud door; pass api_key= instead",
+ provider=policy.provider,
+ )
+ if self.api_key is not None and self.api_key != "":
+ raise NotConfiguredError(
+ f"{policy.provider}: both api_key= and credential={credential!r} were given; a door has one "
+ "identity — pass the credential value, or name the identity, not both",
+ provider=policy.provider,
+ )
+ from ..cloud.chains import ChainContext, credential_provider
+
+ self.host_settings = resolve_settings(policy.host, settings, None, provider=policy.provider, endpoint=endpoint)
+ ctx = ChainContext.online()
+ ctx.settings = self.host_settings
+ self.api_key = credential_provider(policy, ctx, named=credential)
+ self._credential_source = "named"
+ else:
+ loaded = load_credential(policy, self.api_key, credentials_path=credentials_path)
+ self.api_key = loaded.credential
+ self._credential_source = loaded.source
+ if loaded.account_id is not None and self.account_id is None:
+ self.account_id = loaded.account_id
+ if loaded.credential is not None and not callable(loaded.credential):
+ # A static credential of the wrong kind for this door fails now,
+ # not on the first request (a provider callable is checked per call).
+ from ..access import select_scheme
+
+ select_scheme(policy, coerce_credential(loaded.credential))
+ self.host_settings = resolve_settings(policy.host, settings, None, provider=policy.provider, endpoint=endpoint)
+ if self._credential_origin is None:
+ self._credential_origin = _origin_label(self.api_key, self._credential_source)
if getattr(self, "clock", None) is None:
self.clock = None
if policy.host is not None:
- if default_base_url is None or self.base_url == default_base_url:
- self.base_url = render_base_url(policy.host, self.host_settings)
+ self.base_url = render_base_url(policy.host, self.host_settings, endpoint, provider=policy.provider)
elif policy.base_url is not None and default_base_url is not None and self.base_url == default_base_url:
self.base_url = policy.base_url
+ def credential_origin(self) -> str:
+ """Where this adapter's credential comes from, as a sentence fragment
+ with no secret in it (AUTH-1 provenance). For a cloud chain
+ provider this is the rung that last won, or what will be walked
+ when no request has been sent yet."""
+ provider = self.api_key
+ if hasattr(provider, "source") and hasattr(provider, "named"): # a cloud chain provider
+ source = provider.source
+ if source is not None and hasattr(source, "describe"):
+ return source.describe(self._now())
+ if provider.named:
+ from ..cloud.chains import named_meaning
+
+ return f'named credential "{provider.named}" ({named_meaning(self.access, provider.named)}; not yet resolved)'
+ return f"the {self.access.credential_policy} (not yet resolved)"
+ return self._credential_origin or _origin_label(provider, self._credential_source)
+
def _registry_compat(self) -> str | None:
"""The compat preset the bound provider names in the registry, for a
dialect constructed directly with a bound access policy and no
@@ -487,7 +662,11 @@ class BaseProviderLM:
resp = self._send(req)
if resp.status >= 400:
raise self._http_error(resp)
- return self._finish_response(request, self.parse_response(request, resp), adaptations)
+ try:
+ return self._finish_response(request, self.parse_response(request, resp), adaptations)
+ except ProviderError as error:
+ _attach_error_metadata(error, resp.headers)
+ raise
def stream(self, request: Request) -> Iterator[StreamEvent]:
# MAP-3 (docs/mapping-rules.md): adapters may emit one end event per
@@ -496,7 +675,7 @@ class BaseProviderLM:
from ..result import coalesce_stream, truncate_stream_at_stop
req, adaptations = self._build(request, stream=True)
- events = coalesce_stream(self._stream_raw(request, req), model=request.model, adaptations=self._visible(adaptations))
+ events = coalesce_stream(self._stream_raw(request, req), model=self._wire_request(request).model, adaptations=self._visible(adaptations))
if _client_side_stop(adaptations):
events = truncate_stream_at_stop(events, request.config.stop)
return events
@@ -515,10 +694,14 @@ class BaseProviderLM:
_attach_error_metadata(error, resp.headers)
raise error
lines = resp.iter_lines() if hasattr(resp, "iter_lines") else _iter_lines(resp)
- for raw in parse_sse(lines):
- for event in self.parse_stream_events(request, raw):
- if event is not None:
- yield event
+ try:
+ for raw in parse_sse(lines):
+ for event in self.parse_stream_events(request, raw):
+ if event is not None:
+ yield _stream_error_metadata(event, resp.headers)
+ except ProviderError as error:
+ _attach_error_metadata(error, resp.headers)
+ raise
except NetworkTransportError as exc:
raise LM15TransportError(str(exc)) from exc
@@ -579,10 +762,24 @@ class BaseProviderLM:
local login: always under an ``oauth`` policy (there is no env var),
and under ``oauth-unless-explicit`` only when the stored login was
the rung that won — an explicit key keeps the generic guidance.
- ``with_credential_hint`` is a no-op on non-auth errors."""
+ ``with_credential_hint`` is a no-op on non-auth errors.
+
+ Every auth error from the wire also names where the credential came
+ from (AUTH-1 provenance, amended 2026-09-19): the rung of a cloud
+ chain, the env variable, the explicit value, or "an
+ application-supplied callable" — never the value."""
hint = self.access.login_hint
if hint and (self.access.credential_policy == "oauth" or self._credential_source == "stored"):
- return with_credential_hint(error, hint)
+ error = with_credential_hint(error, hint)
+ if isinstance(error, AuthError):
+ from ..errors import with_credential_origin
+
+ try:
+ origin = self.credential_origin()
+ except Exception: # noqa: BLE001 - provenance must never mask the real error
+ origin = None
+ if origin:
+ error = with_credential_origin(error, origin)
return error
def close(self) -> None:
@@ -648,7 +845,7 @@ class BaseProviderLM:
resp = self._send(self._image_generate_request(request))
if resp.status >= 400:
raise self._http_error(resp)
- return self._image_generation_from_response(request, resp)
+ return _parse_reply(resp, lambda reply: self._image_generation_from_response(request, reply))
def speech_generate(self, request: SpeechGenerationRequest) -> SpeechGenerationResponse:
"""Text-to-speech. Omitted ``voice``/``format`` mean the server's
@@ -658,7 +855,7 @@ class BaseProviderLM:
resp = self._send(self._speech_generate_request(request))
if resp.status >= 400:
raise self._http_error(resp)
- return self._speech_generation_from_response(request, resp)
+ return _parse_reply(resp, lambda reply: self._speech_generation_from_response(request, reply), json_body=False)
# ─── Video generation (job-shaped on every wire: Sora / Veo / grok) ─────
#
@@ -701,14 +898,14 @@ class BaseProviderLM:
resp = self._send(self._video_submit_request(request))
if resp.status >= 400:
raise self._http_error(resp)
- return self._video_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._video_job_from_body(reply.text()))
def video_status(self, video_id: str) -> VideoJobInfo:
self._require("video")
resp = self._send(self._video_status_request(video_id))
if resp.status >= 400:
raise self._http_error(resp)
- return self._video_job_from_body(resp.text(), video_id)
+ return _parse_reply(resp, lambda reply: self._video_job_from_body(reply.text(), video_id))
def video_result(self, video_id: str) -> VideoPart:
"""The finished video as a VideoPart, in the provider's own
@@ -719,20 +916,24 @@ class BaseProviderLM:
resp = self._send(self._video_status_request(video_id))
if resp.status >= 400:
raise self._http_error(resp)
- job = self._video_job_from_body(resp.text(), video_id)
+ job = _parse_reply(resp, lambda reply: self._video_job_from_body(reply.text(), video_id))
if job.status not in VIDEO_TERMINAL_STATUSES:
raise ValueError(
f"video {video_id} is not finished (status={job.status!r}); "
f"wait() or poll video_status() until done"
)
- status_body = resp.json()
- fetch = self._video_result_fetch(status_body)
+ status_body = _parse_reply(resp, _reply_object)
+ try:
+ fetch = self._video_result_fetch(status_body)
+ except ProviderError as error:
+ _reply_error_metadata(error, resp)
+ raise
fetched = None
if fetch is not None:
fetched = self._send(fetch)
if fetched.status >= 400:
raise self._http_error(fetched)
- return self._video_part(status_body, fetched)
+ return _parse_reply(fetched or resp, lambda reply: self._video_part(status_body, fetched), json_body=False)
def video_list(self, limit: int = 20, model: str | None = None) -> "tuple[VideoJobInfo, ...]":
"""One page of this credential's video jobs. ``model`` is required
@@ -742,7 +943,7 @@ class BaseProviderLM:
resp = self._send(self._video_list_request(limit, model))
if resp.status >= 400:
raise self._http_error(resp)
- return self._video_jobs_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._video_jobs_from_list_body(reply.text()))
# Ergonomic verbs (ticket handles) ---------------------------------------
@@ -788,7 +989,7 @@ class BaseProviderLM:
resp = self._send(self._models_request())
if resp.status >= 400:
raise self._http_error(resp)
- return self._models_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._models_from_body(reply.text()))
# ─── Batch jobs (third execution mode: complete / stream / batch) ───────
#
@@ -802,8 +1003,22 @@ class BaseProviderLM:
def _batch_unsupported(self) -> UnsupportedFeatureError:
return UnsupportedFeatureError(f"{self.provider}: batch not supported", provider=self.provider)
+ def _batch_preflight(self, request: BatchRequest) -> None:
+ """Plan every item before credentials or paid work, including direct hooks."""
+ for nested in request.requests:
+ records = self.plan(nested, policy="note")
+ if _client_side_stop(records):
+ raise UnsupportedFeatureError(
+ f"{self.provider}: batch cannot close the generation source at a client-side stop cut; "
+ "use a dialect with native stop support or individual complete()/stream() calls",
+ provider=self.provider, feature="config.stop",
+ )
+ if self.adaptations == "refuse":
+ self.plan(nested, policy="refuse")
+
def _batch_upload_request(self, request: BatchRequest) -> TransportRequest | None:
"""Optional pre-submit upload step (OpenAI's JSONL file); None = single-step."""
+ self._batch_preflight(request)
return None
def _batch_submit_request(self, request: BatchRequest, upload_body: "dict[str, Any] | None") -> TransportRequest:
@@ -833,6 +1048,7 @@ class BaseProviderLM:
def batch_submit(self, request: BatchRequest) -> BatchJobInfo:
"""Submit to the provider's batch queue; returns the ticket snapshot."""
self._require("batches")
+ self._batch_preflight(request)
upload_body = None
# MAP-13: the batch builders run under the adapter's policy so
# "refuse" refuses here too; a batch ticket has no adaptations field
@@ -843,20 +1059,25 @@ class BaseProviderLM:
resp = self._send(upload_req)
if resp.status >= 400:
raise self._http_error(resp)
- upload_body = resp.json()
- with collecting(check_policy(self.adaptations), provider=self.provider):
- submit_req = self._batch_submit_request(request, upload_body)
+ upload_body = _parse_reply(resp, _reply_object)
+ try:
+ with collecting(check_policy(self.adaptations), provider=self.provider):
+ submit_req = self._batch_submit_request(request, upload_body)
+ except ProviderError as error:
+ if upload_req is not None:
+ _reply_error_metadata(error, resp)
+ raise
resp = self._send(submit_req)
if resp.status >= 400:
raise self._http_error(resp)
- return self._batch_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._batch_job_from_body(reply.text()))
def batch_status(self, batch_id: str) -> BatchJobInfo:
self._require("batches")
resp = self._send(self._batch_status_request(batch_id))
if resp.status >= 400:
raise self._http_error(resp)
- return self._batch_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._batch_job_from_body(reply.text()))
def batch_results(self, batch_id: str) -> "tuple[BatchEntry, ...]":
"""Entries in submission order; raises ValueError while the job runs."""
@@ -864,20 +1085,43 @@ class BaseProviderLM:
resp = self._send(self._batch_status_request(batch_id))
if resp.status >= 400:
raise self._http_error(resp)
- job = self._batch_job_from_body(resp.text())
+ job = _parse_reply(resp, lambda reply: self._batch_job_from_body(reply.text()))
if job.status not in BATCH_TERMINAL_STATUSES:
raise ValueError(
f"batch {batch_id} is not finished (status={job.status!r}); "
f"wait() or poll batch_status() until done"
)
- status_body = resp.json()
+ status_body = _parse_reply(resp, _reply_object)
+ try:
+ fetches = self._batch_result_fetches(status_body)
+ except ProviderError as error:
+ _reply_error_metadata(error, resp)
+ raise
texts = []
- for fetch in self._batch_result_fetches(status_body):
+ for fetch in fetches:
fetched = self._send(fetch)
if fetched.status >= 400:
raise self._http_error(fetched)
- texts.append(fetched.text())
- return self._batch_entries(status_body, tuple(texts))
+ texts.append(self._batch_reply_text(status_body, fetched))
+ return _parse_reply(resp, lambda reply: self._batch_entries(status_body, tuple(texts)), json_body=False)
+
+ def _batch_reply_text(self, status_body: dict[str, Any], response: HttpResponse) -> str:
+ """Validate each result file against its own HTTP evidence.
+
+ Legacy hooks combine files and fill missing entries from job status.
+ Decode each file once in isolation before that combined pass so both
+ JSONL syntax and entry-shape faults retain the offending fetch's headers.
+ Blank lines remain valid. Hooks are pure; no request is repeated.
+ """
+ text = _parse_reply(response, _jsonl_reply_text, json_body=False)
+ try:
+ _parse_reply(response, lambda reply: self._batch_entries(status_body, (text,)), json_body=False)
+ except ProviderError as error:
+ # Entry decoders may use synthetic HttpResponse(status=200).
+ # The actual reply containing the broken entry is this fetch.
+ error.status = response.status
+ raise
+ return text
def batch_cancel(self, batch_id: str) -> BatchJobInfo:
"""Request cancellation — a request, not a guarantee."""
@@ -885,7 +1129,7 @@ class BaseProviderLM:
resp = self._send(self._batch_cancel_request(batch_id))
if resp.status >= 400:
raise self._http_error(resp)
- return self._batch_job_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._batch_job_from_body(reply.text()))
def batch_list(self, limit: int = 20) -> "tuple[BatchJobInfo, ...]":
"""Enumerate this credential's batch jobs, newest first.
@@ -897,7 +1141,7 @@ class BaseProviderLM:
resp = self._send(self._batch_list_request(limit))
if resp.status >= 400:
raise self._http_error(resp)
- return self._batch_jobs_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._batch_jobs_from_list_body(reply.text()))
def batch(self, requests: "BatchRequest | Sequence[Request]", *, model: str | None = None,
label: str | None = None, extensions: "dict[str, Any] | None" = None) -> "BatchJob":
@@ -969,21 +1213,21 @@ class BaseProviderLM:
resp = self._send(self._cache_create_request(prefix, ttl_seconds, label))
if resp.status >= 400:
raise self._http_error(resp)
- return self._cache_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._cache_info_from_body(reply.text()))
def cache_get(self, cache_id: str) -> CacheInfo:
self._require("caches")
resp = self._send(self._cache_get_request(cache_id))
if resp.status >= 400:
raise self._http_error(resp)
- return self._cache_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._cache_info_from_body(reply.text()))
def cache_list(self, limit: int = 20, cursor: str | None = None) -> CachePage:
self._require("caches")
resp = self._send(self._cache_list_request(limit, cursor))
if resp.status >= 400:
raise self._http_error(resp)
- return self._cache_page_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._cache_page_from_list_body(reply.text()))
def cache_delete(self, cache_id: str) -> None:
"""Returning without an exception IS the confirmation (the files precedent)."""
@@ -999,7 +1243,7 @@ class BaseProviderLM:
resp = self._send(self._cache_update_request(cache_id, ttl_seconds))
if resp.status >= 400:
raise self._http_error(resp)
- return self._cache_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._cache_info_from_body(reply.text()))
def cache(self, prefix: Request, *, ttl_seconds: int | None = None, label: str | None = None) -> CachedPrefix:
"""Make a prompt beginning reusable with the best tier this provider has.
@@ -1009,10 +1253,12 @@ class BaseProviderLM:
Marks and automatic tiers: pure — the CachedPrefix only records the
boundary; `cached + messages` places the mark or sends nothing.
"""
+ wire = self._wire_request(prefix)
+ provider = self.provider if wire.model != prefix.model else None
if self.supports.caches:
- return CachedPrefix(prefix, self.cache_create(prefix, ttl_seconds=ttl_seconds, label=label))
- self._check_cache_prefix(prefix, ttl_seconds)
- return CachedPrefix(prefix)
+ return CachedPrefix(wire, self.cache_create(wire, ttl_seconds=ttl_seconds, label=label), provider=provider)
+ self._check_cache_prefix(wire, ttl_seconds)
+ return CachedPrefix(wire, provider=provider)
# ─── Files (account-scoped storage: upload / get / list / delete / download) ─
#
@@ -1058,14 +1304,14 @@ class BaseProviderLM:
resp = self._send(self._file_upload_request(request))
if resp.status >= 400:
raise self._http_error(resp)
- return self._file_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._file_info_from_body(reply.text()))
def file_get(self, file_id: str) -> FileInfo:
self._require("files")
resp = self._send(self._file_get_request(file_id))
if resp.status >= 400:
raise self._http_error(resp)
- return self._file_info_from_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._file_info_from_body(reply.text()))
def file_list(self, limit: int = 20, cursor: str | None = None) -> FilePage:
"""One page of this credential's stored files.
@@ -1078,7 +1324,7 @@ class BaseProviderLM:
resp = self._send(self._file_list_request(limit, cursor))
if resp.status >= 400:
raise self._http_error(resp)
- return self._file_page_from_list_body(resp.text())
+ return _parse_reply(resp, lambda reply: self._file_page_from_list_body(reply.text()))
def file_delete(self, file_id: str) -> None:
"""Delete a stored file. Returning without an exception IS the
diff --git a/dspy/_vendor/lm15/providers/common.py b/dspy/_vendor/lm15/providers/common.py
index 0e1763b8e..a0285ada1 100644
--- a/dspy/_vendor/lm15/providers/common.py
+++ b/dspy/_vendor/lm15/providers/common.py
@@ -11,6 +11,7 @@ from ..types import (
AudioPart,
BinaryPart,
CitationPart,
+ DataPart,
DocumentPart,
ImagePart,
Message,
@@ -78,6 +79,8 @@ def parts_to_text(parts: tuple[Part, ...], *, provider: str | None = None,
)
if isinstance(part, TextPart):
out.append(part.text)
+ elif isinstance(part, DataPart):
+ out.append(data_part_text(part))
elif isinstance(part, ThinkingPart) and part.text:
out.append(part.text)
elif isinstance(part, CitationPart):
@@ -91,12 +94,22 @@ def message_text(msg: Message) -> str:
return parts_to_text(msg.parts)
+def data_part_text(part: DataPart) -> str:
+ """A data part on a wire that takes only text: its ``value`` as compact
+ canonical JSON, nothing added (changes/2026-09-19-jev-state.md D3;
+ types.md §DataPart). An opaque payload: numbers as written."""
+ return json.dumps(part.value, separators=(",", ":"), ensure_ascii=False)
+
+
def media_base64(part: ImagePart | AudioPart | VideoPart | DocumentPart | BinaryPart) -> str:
"""The part's bytes as base64: inline `data`, or the `path` read now.
A url/file_id-addressed part has no bytes here; the caller maps those."""
if part.data is not None:
return part.data
if part.path is not None:
+ from ..adaptation import is_planning
+ if is_planning():
+ return "" # Discarded preview bytes, never a sendable request.
return base64.b64encode(part.path.read_bytes()).decode("ascii")
raise ValueError(f"{part.type} part has no inline data or path")
@@ -147,6 +160,9 @@ def tool_result_error_text(part: ToolResultPart, text: str) -> str:
def media_bytes(part: ImagePart | AudioPart | VideoPart | DocumentPart | BinaryPart) -> bytes:
+ from ..adaptation import is_planning
+ if part.path is not None and is_planning():
+ return b""
return part.bytes
@@ -266,6 +282,8 @@ def part_to_openai_input(part: Part, *, provider: str | None = None) -> dict[str
if isinstance(part, TextPart):
return {"type": "input_text", "text": part.text}
+ if isinstance(part, DataPart):
+ return {"type": "input_text", "text": data_part_text(part)}
if isinstance(part, ImagePart):
if part.file_id is not None:
@@ -346,8 +364,7 @@ def anthropic_source(part: ImagePart | DocumentPart | BinaryPart) -> dict[str, A
if part.data is not None:
return {"type": "base64", "media_type": part.media_type, "data": part.data}
if part.path is not None:
- data = base64.b64encode(part.path.read_bytes()).decode("ascii")
- return {"type": "base64", "media_type": part.media_type, "data": data}
+ return {"type": "base64", "media_type": part.media_type, "data": media_base64(part)}
raise ValueError(f"{part.type} part has no usable source")
diff --git a/dspy/_vendor/lm15/providers/gemini.py b/dspy/_vendor/lm15/providers/gemini.py
index 2a48b2531..f15e9a6f8 100644
--- a/dspy/_vendor/lm15/providers/gemini.py
+++ b/dspy/_vendor/lm15/providers/gemini.py
@@ -27,10 +27,12 @@ from ..errors import (
)
from ..access import GEMINI_API
from ..features import ProviderManifest
+from ..judgments import gemini_schema, note_unmeasurable_probabilities, replace_text_with_data, request_judgments
from ..live import WebSocketLiveSession, require_websocket_sync_connect
from ..sse import SSEEvent
from ..transports import TransportRequest
from ..types import (
+ DataPart,
CacheInfo,
CachePage,
VideoGenerationRequest,
@@ -105,7 +107,7 @@ from .base import (
default_transport,
resolve_credential,
)
-from .common import EFFORT_THINKING_BUDGETS, MEDIA_KINDS, build_url, iso_utc, model_infos_from_entries, multipart_related_body, parts_to_text, path_id, unnamed_tool_call_error
+from .common import EFFORT_THINKING_BUDGETS, MEDIA_KINDS, build_url, data_part_text, iso_utc, media_base64, model_infos_from_entries, multipart_related_body, parts_to_text, path_id, unnamed_tool_call_error
# Canonical builtin tool name → Gemini tool key
_GEMINI_BUILTIN_MAP: dict[str, str] = {
@@ -402,6 +404,9 @@ class GeminiLM(BaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = None
+ # A named cloud identity ("platform", "workload", "environment", "cli";
+ # AUTH-1) on a cloud door, instead of api_key=.
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
# MAP-13 policy: "note" (adapt and record), "silent", or "refuse".
@@ -413,7 +418,8 @@ class GeminiLM(BaseProviderLM):
def __post_init__(self) -> None:
check_policy(self.adaptations)
- self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings)
+ self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings,
+ credential=self.credential)
_error_status_map: ClassVar[dict[str, type[ProviderError]]] = {
"INVALID_ARGUMENT": InvalidRequestError,
@@ -602,6 +608,8 @@ class GeminiLM(BaseProviderLM):
return {"functionResponse": fr}
def _part(self, part, names: dict[str, str] | None = None) -> dict[str, Any]:
+ if isinstance(part, DataPart):
+ return {"text": data_part_text(part)}
if isinstance(part, TextPart):
out: dict[str, Any] = {"text": part.text}
thought = continuation_data(part, "gemini", "thought_signature")
@@ -617,7 +625,7 @@ class GeminiLM(BaseProviderLM):
if part.data is not None:
return {"inlineData": {"mimeType": mime, "data": part.data}}
if part.path is not None:
- return {"inlineData": {"mimeType": mime, "data": base64.b64encode(part.path.read_bytes()).decode("ascii")}}
+ return {"inlineData": {"mimeType": mime, "data": media_base64(part)}}
if isinstance(part, ToolCallPart):
out: dict[str, Any] = {"functionCall": {"name": part.name, "args": part.input}}
if part.id:
@@ -752,7 +760,16 @@ class GeminiLM(BaseProviderLM):
if request.config.logprobs > 0:
generation_config["logprobs"] = request.config.logprobs
if request.config.response_format:
- generation_config.update(_response_format_to_gemini_config(request.config.response_format))
+ # MAP-14 §2: judgment properties go as enum with descriptions
+ # folded into the property description — responseJsonSchema
+ # ignores anyOf/const (receipted 2026-09-17: "Bordeaux-blend");
+ # probabilities cannot be measured here.
+ note_unmeasurable_probabilities(request, self.provider)
+ found = request_judgments(request)
+ fmt = request.config.response_format
+ if found:
+ fmt = {**fmt, "schema": gemini_schema(fmt["schema"], found)}
+ generation_config.update(_response_format_to_gemini_config(fmt))
if request.config.reasoning is not None:
reasoning = request.config.reasoning
level_class = gemini_level_class(request.model)
@@ -845,6 +862,7 @@ class GeminiLM(BaseProviderLM):
return payload
def build_request(self, request: Request, stream: bool) -> TransportRequest:
+ request = self._wire_request(request)
endpoint = "streamGenerateContent" if stream else "generateContent"
params = self._auth_params({"alt": "sse"} if stream else None)
return self._emit(
@@ -937,6 +955,7 @@ class GeminiLM(BaseProviderLM):
return parts
def parse_response(self, request: Request, response: HttpResponse) -> Response:
+ request = self._wire_request(request)
data = response.json()
inband = self._inband_error(data)
if inband is not None:
@@ -962,7 +981,7 @@ class GeminiLM(BaseProviderLM):
return Response(
id=str(data.get("responseId")) if data.get("responseId") else None,
model=request.model,
- message=Message(role="assistant", parts=tuple(parts)),
+ message=Message(role="assistant", parts=replace_text_with_data(parts, request_judgments(request))),
finish_reason=_finish_reason(candidate.get("finishReason"), has_tool_call=has_tool),
usage=usage,
logprobs=logprob_seq or None,
@@ -970,6 +989,7 @@ class GeminiLM(BaseProviderLM):
)
def parse_stream_events(self, request: Request, raw_event: SSEEvent) -> Iterator[StreamEvent]:
+ request = self._wire_request(request)
if not raw_event.data:
return
payload = json.loads(raw_event.data)
@@ -1069,8 +1089,9 @@ class GeminiLM(BaseProviderLM):
# ─── Streaming via Gemini Live for live models ──────────────────
def stream(self, request: Request) -> Iterator[StreamEvent]:
- if self._should_use_live_completion(request):
- yield from self._stream_via_live_completion(request)
+ wire = self._wire_request(request)
+ if self._should_use_live_completion(wire):
+ yield from self._stream_via_live_completion(wire)
return
yield from BaseProviderLM.stream(self, request)
@@ -1431,7 +1452,6 @@ class GeminiLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/models",
params={"pageSize": 1000},
headers=self._auth_headers(),
- read_timeout=30.0,
)
def _models_from_body(self, body: str):
@@ -1493,7 +1513,6 @@ class GeminiLM(BaseProviderLM):
"Content-Type": content_type,
}).items()),
body=body,
- read_timeout=300.0,
)
def _file_info_from_body(self, body: str) -> FileInfo:
@@ -1543,7 +1562,7 @@ class GeminiLM(BaseProviderLM):
def _file_get_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/{path_id(self._file_resource(file_id), resource_name=True)}",
- headers=self._auth_headers(), read_timeout=60.0,
+ headers=self._auth_headers(),
)
def _file_list_request(self, limit: int, cursor: str | None) -> TransportRequest:
@@ -1552,7 +1571,7 @@ class GeminiLM(BaseProviderLM):
params["pageToken"] = cursor
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files",
- params=params, headers=self._auth_headers(), read_timeout=60.0,
+ params=params, headers=self._auth_headers(),
)
def _file_page_from_list_body(self, body: str) -> FilePage:
@@ -1565,14 +1584,14 @@ class GeminiLM(BaseProviderLM):
def _file_delete_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="DELETE", url=f"{self.base_url.rstrip('/')}/{path_id(self._file_resource(file_id), resource_name=True)}",
- headers=self._auth_headers(), read_timeout=60.0,
+ headers=self._auth_headers(),
)
def _file_download_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="GET",
url=f"{self.base_url.rstrip('/')}/{path_id(self._file_resource(file_id), resource_name=True)}:download?alt=media",
- headers=self._auth_headers(), read_timeout=300.0,
+ headers=self._auth_headers(),
)
# ─── Cache resource hooks (cachedContents; the stored tier of MAP-6) ──
@@ -1614,7 +1633,7 @@ class GeminiLM(BaseProviderLM):
body["displayName"] = label
return self._emit(
method="POST", url=f"{self.base_url.rstrip('/')}/cachedContents",
- headers=self._auth_headers({"Content-Type": "application/json"}), payload=body, read_timeout=120.0,
+ headers=self._auth_headers({"Content-Type": "application/json"}), payload=body,
)
def _cache_info_from_body(self, body: str) -> CacheInfo:
@@ -1644,7 +1663,7 @@ class GeminiLM(BaseProviderLM):
def _cache_get_request(self, cache_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/{path_id(self._cache_resource(cache_id), resource_name=True)}",
- headers=self._auth_headers(), read_timeout=60.0,
+ headers=self._auth_headers(),
)
def _cache_list_request(self, limit: int, cursor: str | None) -> TransportRequest:
@@ -1653,7 +1672,7 @@ class GeminiLM(BaseProviderLM):
params["pageToken"] = cursor
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/cachedContents",
- params=params, headers=self._auth_headers(), read_timeout=60.0,
+ params=params, headers=self._auth_headers(),
)
def _cache_page_from_list_body(self, body: str) -> CachePage:
@@ -1666,14 +1685,14 @@ class GeminiLM(BaseProviderLM):
def _cache_delete_request(self, cache_id: str) -> TransportRequest:
return self._emit(
method="DELETE", url=f"{self.base_url.rstrip('/')}/{path_id(self._cache_resource(cache_id), resource_name=True)}",
- headers=self._auth_headers(), read_timeout=60.0,
+ headers=self._auth_headers(),
)
def _cache_update_request(self, cache_id: str, ttl_seconds: int) -> TransportRequest:
return self._emit(
method="PATCH", url=f"{self.base_url.rstrip('/')}/{path_id(self._cache_resource(cache_id), resource_name=True)}",
headers=self._auth_headers({"Content-Type": "application/json"}),
- payload={"ttl": f"{ttl_seconds}s"}, read_timeout=60.0,
+ payload={"ttl": f"{ttl_seconds}s"},
)
# ─── Batch hooks (Batch Mode, inline requests) ───────────────────
@@ -1685,6 +1704,7 @@ class GeminiLM(BaseProviderLM):
# correlation, list → GET /batches?pageSize=N → {"operations": [...]}.
def _batch_submit_request(self, request: BatchRequest, upload_body: dict[str, Any] | None) -> TransportRequest:
+ self._batch_preflight(request)
model = request.model or request.requests[0].model
batch: dict[str, Any] = {
"inputConfig": {
@@ -1704,7 +1724,6 @@ class GeminiLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/{self._model_path(model)}:batchGenerateContent",
headers=self._auth_headers({"Content-Type": "application/json"}),
payload=payload,
- read_timeout=120.0,
)
def _batch_job_from_body(self, body: str) -> BatchJobInfo:
@@ -1729,7 +1748,6 @@ class GeminiLM(BaseProviderLM):
method="GET",
url=f"{self.base_url.rstrip('/')}/{path_id(batch_id, resource_name=True)}",
headers=self._auth_headers(),
- read_timeout=60.0,
)
def _batch_cancel_request(self, batch_id: str) -> TransportRequest:
@@ -1738,7 +1756,6 @@ class GeminiLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/{path_id(batch_id, resource_name=True)}:cancel",
headers=self._auth_headers({"Content-Type": "application/json"}),
payload={},
- read_timeout=60.0,
)
def _batch_result_fetches(self, status_body: dict[str, Any]) -> tuple[TransportRequest, ...]:
@@ -1787,7 +1804,6 @@ class GeminiLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/batches",
params={"pageSize": int(limit)},
headers=self._auth_headers(),
- read_timeout=60.0,
)
def _batch_jobs_from_list_body(self, body: str) -> tuple[BatchJobInfo, ...]:
@@ -1825,7 +1841,6 @@ class GeminiLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/{self._model_path(request.model)}:predictLongRunning",
headers=self._auth_headers({"Content-Type": "application/json"}),
payload=payload,
- read_timeout=120.0,
)
def _video_job_from_body(self, body: str, video_id: "str | None" = None) -> VideoJobInfo:
@@ -1847,7 +1862,6 @@ class GeminiLM(BaseProviderLM):
method="GET",
url=f"{self.base_url.rstrip('/')}/{path_id(video_id, resource_name=True)}",
headers=self._auth_headers({}),
- read_timeout=60.0,
)
def _video_result_uri(self, status_body: dict[str, Any]) -> str:
@@ -1866,7 +1880,6 @@ class GeminiLM(BaseProviderLM):
method="GET",
url=self._video_result_uri(status_body),
headers=self._auth_headers({}),
- read_timeout=600.0,
)
def _video_part(self, status_body: dict[str, Any], fetched: "HttpResponse | None") -> VideoPart:
@@ -1888,7 +1901,6 @@ class GeminiLM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/{self._model_path(model)}/operations",
params={"pageSize": int(limit)},
headers=self._auth_headers({}),
- read_timeout=60.0,
)
def _video_jobs_from_list_body(self, body: str) -> tuple[VideoJobInfo, ...]:
diff --git a/dspy/_vendor/lm15/providers/openai.py b/dspy/_vendor/lm15/providers/openai.py
index 954493591..4674c5f48 100644
--- a/dspy/_vendor/lm15/providers/openai.py
+++ b/dspy/_vendor/lm15/providers/openai.py
@@ -30,6 +30,7 @@ from ..access import OPENAI_API, auth_header
from ..auth import extract_chatgpt_account_id
from ..compat import OPENAI_RESPONSES_PRESET_BASE_URLS, OpenAIResponsesCompat, preset_base_url
from ..features import ProviderManifest
+from ..judgments import note_unmeasurable_probabilities, replace_text_with_data, request_judgments
from ..result import materialize_response
from ..live import WebSocketLiveSession, require_websocket_sync_connect
from ..profiles import ProviderProfile, ResolvedOpenAIResponsesCompat, resolve_openai_responses_compat
@@ -474,6 +475,9 @@ class OpenAILM(BaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = field(default=None, kw_only=True)
+ # A named cloud identity ("platform", "workload", "environment", "cli";
+ # AUTH-1) on a cloud door, instead of api_key=.
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False, kw_only=True)
account_id: str | None = None
@@ -494,7 +498,8 @@ class OpenAILM(BaseProviderLM):
DeprecationWarning,
stacklevel=3,
)
- self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings)
+ self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings,
+ credential=self.credential)
compat = self.compat if self.compat is not None else self._registry_compat()
if isinstance(compat, str):
self._compat_base = OpenAIResponsesCompat.preset(compat)
@@ -523,6 +528,9 @@ class OpenAILM(BaseProviderLM):
_response_error_code_map: ClassVar[dict[str, type[ProviderError]]] = {
"server_error": ServerError,
"rate_limit_exceeded": RateLimitError,
+ # Azure documents these on Responses error frames even under HTTP 200.
+ "no_capacity": RateLimitError,
+ "too_many_requests": RateLimitError,
"invalid_prompt": InvalidRequestError,
"vector_store_timeout": TimeoutError,
"invalid_image": InvalidRequestError,
@@ -939,6 +947,10 @@ class OpenAILM(BaseProviderLM):
if request.config.tool_choice and request.config.tool_choice.parallel is not None:
payload["parallel_tool_calls"] = request.config.tool_choice.parallel
if request.config.response_format:
+ # MAP-14: the judgment convention goes verbatim (strict honours
+ # anyOf/const/title, receipted 2026-09-17); probabilities cannot
+ # be measured here.
+ note_unmeasurable_probabilities(request, self.provider)
payload["text"] = _response_format_to_openai_text(request.config.response_format)
if request.config.reasoning:
reasoning = request.config.reasoning
@@ -1043,6 +1055,7 @@ class OpenAILM(BaseProviderLM):
return payload
def build_request(self, request: Request, stream: bool) -> TransportRequest:
+ request = self._wire_request(request)
return self._emit(
method="POST",
url=f"{self.base_url.rstrip('/')}/responses",
@@ -1056,6 +1069,7 @@ class OpenAILM(BaseProviderLM):
# ─── Response parsing ───────────────────────────────────────────
def parse_response(self, request: Request, response: HttpResponse) -> Response:
+ request = self._wire_request(request)
data = response.json()
resp_error = data.get("error") if isinstance(data, dict) else None
@@ -1162,7 +1176,7 @@ class OpenAILM(BaseProviderLM):
return Response(
id=str(data.get("id")) if data.get("id") else None,
model=str(data.get("model") or request.model),
- message=Message(role="assistant", parts=tuple(parts)),
+ message=Message(role="assistant", parts=replace_text_with_data(parts, request_judgments(request))),
finish_reason=_finish_from_status(data, has_tool_call=has_tool),
usage=usage,
logprobs=tuple(logprob_seq) if logprob_seq else None,
@@ -1170,6 +1184,7 @@ class OpenAILM(BaseProviderLM):
)
def parse_stream_events(self, request: Request, raw_event: SSEEvent) -> Iterator[StreamEvent]:
+ request = self._wire_request(request)
payload = json.loads(raw_event.data) if raw_event.data and raw_event.data != "[DONE]" else None
if isinstance(payload, dict) and payload.get("type") in {"response.output_item.added", "response.output_item.done"}:
item = payload.get("item")
@@ -1326,8 +1341,9 @@ class OpenAILM(BaseProviderLM):
return BaseProviderLM.complete(self, request)
def stream(self, request: Request) -> Iterator[StreamEvent]:
- if not self._codex and self._should_use_live_completion(request):
- yield from self._stream_via_live_completion(request)
+ wire = self._wire_request(request)
+ if not self._codex and self._should_use_live_completion(wire):
+ yield from self._stream_via_live_completion(wire)
return
# BaseProviderLM.stream applies the MAP-3 coalescer: the Codex
# backend sends response.completed (usage) and then [DONE], two
@@ -1690,7 +1706,6 @@ class OpenAILM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/models",
params=params,
headers=self._headers(),
- read_timeout=30.0,
)
def _models_from_body(self, body: str):
@@ -1733,7 +1748,6 @@ class OpenAILM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/files",
headers=list(self._headers(content_type=content_type).items()),
body=body,
- read_timeout=300.0,
)
def _file_info_from_body(self, body: str) -> FileInfo:
@@ -1760,7 +1774,7 @@ class OpenAILM(BaseProviderLM):
def _file_get_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _file_list_request(self, limit: int, cursor: str | None) -> TransportRequest:
@@ -1769,7 +1783,7 @@ class OpenAILM(BaseProviderLM):
params["after"] = cursor
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files",
- params=params, headers=self._headers(), read_timeout=60.0,
+ params=params, headers=self._headers(),
)
def _file_page_from_list_body(self, body: str) -> FilePage:
@@ -1782,13 +1796,13 @@ class OpenAILM(BaseProviderLM):
def _file_delete_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="DELETE", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _file_download_request(self, file_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}/content",
- headers=self._headers(), read_timeout=300.0,
+ headers=self._headers(),
)
# ─── Batch hooks (Batch API over /v1/responses) ──────────────────
@@ -1800,6 +1814,7 @@ class OpenAILM(BaseProviderLM):
# results so entry order always equals submission order.
def _batch_upload_request(self, request: BatchRequest) -> TransportRequest:
+ self._batch_preflight(request)
lines = []
for i, nested in enumerate(request.requests):
lines.append(json.dumps({
@@ -1818,10 +1833,10 @@ class OpenAILM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/files",
headers=list(self._headers(content_type=content_type).items()),
body=body,
- read_timeout=300.0,
)
def _batch_submit_request(self, request: BatchRequest, upload_body: dict[str, Any] | None) -> TransportRequest:
+ self._batch_preflight(request)
input_file_id = (upload_body or {}).get("id")
if not isinstance(input_file_id, str) or not input_file_id:
raise ProviderError("openai: batch input file upload returned no id", provider=self.provider)
@@ -1839,7 +1854,6 @@ class OpenAILM(BaseProviderLM):
url=f"{self.base_url.rstrip('/')}/batches",
headers=self._headers(),
payload=payload,
- read_timeout=120.0,
)
def _batch_job_from_body(self, body: str) -> BatchJobInfo:
@@ -1862,13 +1876,13 @@ class OpenAILM(BaseProviderLM):
def _batch_status_request(self, batch_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/batches/{path_id(batch_id)}",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _batch_cancel_request(self, batch_id: str) -> TransportRequest:
return self._emit(
method="POST", url=f"{self.base_url.rstrip('/')}/batches/{path_id(batch_id)}/cancel",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _batch_result_fetches(self, status_body: dict[str, Any]) -> tuple[TransportRequest, ...]:
@@ -1878,7 +1892,7 @@ class OpenAILM(BaseProviderLM):
if isinstance(file_id, str) and file_id:
fetches.append(self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/files/{path_id(file_id)}/content",
- headers=self._headers(), read_timeout=300.0,
+ headers=self._headers(),
))
return tuple(fetches)
@@ -1936,7 +1950,7 @@ class OpenAILM(BaseProviderLM):
def _batch_list_request(self, limit: int) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/batches",
- params={"limit": int(limit)}, headers=self._headers(), read_timeout=60.0,
+ params={"limit": int(limit)}, headers=self._headers(),
)
def _batch_jobs_from_list_body(self, body: str) -> tuple[BatchJobInfo, ...]:
@@ -1972,7 +1986,7 @@ class OpenAILM(BaseProviderLM):
payload: dict[str, Any] = {"model": request.model, "prompt": request.prompt, **(request.extensions or {})}
if request.seconds is not None:
payload["seconds"] = str(request.seconds) # the wire wants a string enum
- return self._emit(method="POST", url=f"{self.base_url.rstrip('/')}/videos", headers=self._headers(), payload=payload, read_timeout=120.0)
+ return self._emit(method="POST", url=f"{self.base_url.rstrip('/')}/videos", headers=self._headers(), payload=payload)
def _video_job_from_body(self, body: str, video_id: "str | None" = None) -> VideoJobInfo:
return self._video_job_info(json.loads(body))
@@ -1996,14 +2010,13 @@ class OpenAILM(BaseProviderLM):
)
def _video_status_request(self, video_id: str) -> TransportRequest:
- return self._emit(method="GET", url=f"{self.base_url.rstrip('/')}/videos/{path_id(video_id)}", headers=self._headers(), read_timeout=60.0)
+ return self._emit(method="GET", url=f"{self.base_url.rstrip('/')}/videos/{path_id(video_id)}", headers=self._headers())
def _video_result_fetch(self, status_body: dict[str, Any]) -> TransportRequest:
return self._emit(
method="GET",
url=f"{self.base_url.rstrip('/')}/videos/{path_id(str(status_body.get('id')))}/content",
headers=self._headers(),
- read_timeout=600.0,
)
def _video_part(self, status_body: dict[str, Any], fetched: "HttpResponse | None") -> VideoPart:
@@ -2017,7 +2030,7 @@ class OpenAILM(BaseProviderLM):
def _video_list_request(self, limit: int, model: str | None) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/videos",
- params={"limit": int(limit)}, headers=self._headers(), read_timeout=60.0,
+ params={"limit": int(limit)}, headers=self._headers(),
)
def _video_jobs_from_list_body(self, body: str) -> tuple[VideoJobInfo, ...]:
@@ -2044,7 +2057,7 @@ class OpenAILM(BaseProviderLM):
if not request.images:
payload = {"model": request.model, "prompt": request.prompt, "size": request.size, **(request.extensions or {})}
payload = {k: v for k, v in payload.items() if v is not None}
- return self._emit(method="POST", url=f"{base}/images/generations", headers=self._headers(), payload=payload, read_timeout=300.0)
+ return self._emit(method="POST", url=f"{base}/images/generations", headers=self._headers(), payload=payload)
# Edits are multipart: the wire takes uploaded bytes only.
for part in request.images:
if part.data is None and part.path is None:
@@ -2069,7 +2082,6 @@ class OpenAILM(BaseProviderLM):
url=f"{base}/images/edits",
headers=list(self._headers(content_type=content_type).items()),
body=body,
- read_timeout=300.0,
)
def _image_generation_from_response(self, request: ImageGenerationRequest, resp: HttpResponse) -> ImageGenerationResponse:
@@ -2099,7 +2111,7 @@ class OpenAILM(BaseProviderLM):
payload["voice"] = request.voice
if request.format is not None:
payload["response_format"] = request.format
- return self._emit(method="POST", url=f"{self.base_url.rstrip('/')}/audio/speech", headers=self._headers(), payload=payload, read_timeout=300.0)
+ return self._emit(method="POST", url=f"{self.base_url.rstrip('/')}/audio/speech", headers=self._headers(), payload=payload)
def _speech_generation_from_response(self, request: SpeechGenerationRequest, resp: HttpResponse) -> SpeechGenerationResponse:
content_type = (resp.header("content-type") or "").split(";", 1)[0].strip()
diff --git a/dspy/_vendor/lm15/providers/openai_chat.py b/dspy/_vendor/lm15/providers/openai_chat.py
index 23e68c242..f5a6eab2d 100644
--- a/dspy/_vendor/lm15/providers/openai_chat.py
+++ b/dspy/_vendor/lm15/providers/openai_chat.py
@@ -13,6 +13,7 @@ from __future__ import annotations
from datetime import datetime
import json
+import math
import mimetypes
import os
from dataclasses import dataclass, field, replace
@@ -25,13 +26,15 @@ from ..compat import (
ResolvedOpenAIChatCompat,
resolve_openai_chat_compat,
)
-from ..adaptation import AdaptationPolicy, adapt, check_policy, nearest_effort
+from ..adaptation import Adaptation, AdaptationPolicy, adapt, check_policy, collecting, nearest_effort
from ..errors import ProviderError, ServerError, UnsupportedFeatureError
from ..access import OPENAI_CHAT_API
from ..features import ProviderManifest
+from ..judgments import Judgment, judgments_in_schema, non_judgment_properties, normalize_logprobs, note_unmeasurable_probabilities, replace_text_with_data, request_judgments
from ..sse import SSEEvent
from ..transports import TransportRequest
from ..types import (
+ DataPart,
BuiltinTool,
CacheConfig,
CitationPart,
@@ -61,7 +64,7 @@ from ..types import (
document,
image,
)
-from .base import BaseProviderLM, Credential, HttpResponse, SyncTransport, default_transport
+from .base import BaseProviderLM, Credential, HttpResponse, SyncTransport, default_transport, _attach_error_metadata
from .common import (
MEDIA_KINDS,
check_tool_result_media,
@@ -72,6 +75,7 @@ from .common import (
parse_json_object,
unnamed_tool_call_error,
parts_to_text,
+ data_part_text,
)
from .openai import (
OpenAILM,
@@ -129,6 +133,8 @@ def _chat_content_parts(msg: Message, *, force_array: bool = False, provider: st
parts = [p for p in msg.parts if not isinstance(p, (ToolCallPart, ToolResultPart))]
if len(parts) == 1 and isinstance(parts[0], TextPart) and not force_array:
return parts[0].text
+ if len(parts) == 1 and isinstance(parts[0], DataPart) and not force_array:
+ return data_part_text(parts[0]) # a data part is text on this wire (D3): the same string form as a lone text part
out: list[dict[str, Any]] = []
for part in parts:
if isinstance(part, TextPart):
@@ -1037,7 +1043,19 @@ def _response_from_chat_body(
)
-def response_from_openai_chat(body: Mapping[str, Any], *, model: str | None = None, choice: int | None = None) -> Response:
+def _fold_judgments(resp: Response, response_format: Mapping[str, Any] | None) -> Response:
+ """MAP-14 §3: the single text part of a judgment answer becomes a DataPart."""
+ if not isinstance(response_format, Mapping) or response_format.get("type") != "json_schema":
+ return resp
+ found = judgments_in_schema(response_format.get("schema"))
+ if not found:
+ return resp
+ parts = replace_text_with_data(resp.message.parts, found)
+ return replace(resp, message=Message(role="assistant", parts=parts, continuation=resp.message.continuation))
+
+
+def response_from_openai_chat(body: Mapping[str, Any], *, model: str | None = None, choice: int | None = None,
+ response_format: Mapping[str, Any] | None = None) -> Response:
"""A Chat Completions response body → the canonical :class:`Response`.
The reading-side twin of :func:`request_from_openai_chat`: ``body`` is
@@ -1062,7 +1080,7 @@ def response_from_openai_chat(body: Mapping[str, Any], *, model: str | None = No
cls = OpenAILM._response_error_code_map.get(code, ServerError)
return cls(message or code or "provider error", provider="openai-chat", provider_code=code or None)
- return _response_from_chat_body("openai-chat", body, model=model, choice=choice, on_error=on_error)
+ return _fold_judgments(_response_from_chat_body("openai-chat", body, model=model, choice=choice, on_error=on_error), response_format)
def _usage_from_chat(usage_data: dict[str, Any]) -> Usage:
@@ -1098,6 +1116,9 @@ class OpenAIChatLM(BaseProviderLM):
access: ProviderManifest | None = field(default=None, repr=False)
credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
settings: "Mapping[str, str] | None" = None
+ # A named cloud identity ("platform", "workload", "environment", "cli";
+ # AUTH-1) on a cloud door, instead of api_key=.
+ credential: str | None = field(default=None, kw_only=True)
clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
# MAP-13 policy: "note" (adapt and record), "silent", or "refuse".
@@ -1119,7 +1140,8 @@ class OpenAIChatLM(BaseProviderLM):
def __post_init__(self) -> None:
check_policy(self.adaptations)
- self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings)
+ self._bind_access(self.access, credentials_path=self.credentials_path, default_base_url=_DEFAULT_BASE_URL, settings=self.settings,
+ credential=self.credential)
compat = self.compat if self.compat is not None else self._registry_compat()
if isinstance(compat, str):
partial = OpenAIChatCompat.preset(compat)
@@ -1151,7 +1173,6 @@ class OpenAIChatLM(BaseProviderLM):
method="GET",
url=f"{self.base_url.rstrip('/')}/models",
headers=self._headers(),
- read_timeout=30.0,
)
def _models_from_body(self, body: str):
@@ -1323,6 +1344,14 @@ class OpenAIChatLM(BaseProviderLM):
def _payload(self, request: Request, stream: bool) -> dict[str, Any]:
compat = self._compat_for(request.model)
+ # Streaming uses generated JSON, never the non-streamable trie driver.
+ # Check before building messages or invoking credentials, including on
+ # servers that would otherwise ignore response_format.
+ if stream or not self._scores_named_tokens(request.model):
+ if stream and self._judgments_via_token_scoring(request):
+ self._judgment_stream_policy(request)
+ else:
+ note_unmeasurable_probabilities(request, self.provider)
breakpoint_index = _cache_breakpoint_index(request, compat.cache_control) # once: it may record
payload: dict[str, Any] = {
"model": request.model,
@@ -1414,6 +1443,11 @@ class OpenAIChatLM(BaseProviderLM):
"and does not apply it; use {'type': 'json_object'} and describe the shape in the prompt",
asked=request.config.response_format, provider=self.provider)
else:
+ # MAP-14: the judgment convention goes verbatim on the chat
+ # dialect (api.openai.com strict honours it, receipted
+ # 2026-09-17); a server that scores named tokens delivers
+ # probabilities through the trie driver, every other one
+ # answers with the pick only.
payload["response_format"] = _response_format_to_chat(request.config.response_format)
if request.config.reasoning:
reasoning = request.config.reasoning
@@ -1541,6 +1575,7 @@ class OpenAIChatLM(BaseProviderLM):
return payload
def build_request(self, request: Request, stream: bool) -> TransportRequest:
+ request = self._wire_request(request)
return self._emit(
method="POST",
url=f"{self.base_url.rstrip('/')}/chat/completions",
@@ -1566,20 +1601,468 @@ class OpenAIChatLM(BaseProviderLM):
return mapped
def parse_response(self, request: Request, response: HttpResponse) -> Response:
- return _response_from_chat_body(
+ request = self._wire_request(request)
+ resp = _response_from_chat_body(
self.provider, response.json(), model=request.model,
choice=None, on_error=self._response_error,
)
+ return _fold_judgments(resp, request.config.response_format)
+
+ # ─── Judgments by candidate-sequence likelihood (MAP-14 §4) ───────
+ #
+ # A server that scores named tokens (compat token_scoring =
+ # "logprob_token_ids": vLLM ≥ 0.29, receipted 2026-09-17) can deliver a
+ # distribution over the declared keys of every judgment. Pure hooks
+ # below; the driver sequences them like files and batch:
+ # 1. two /tokenize calls per key plus one per judgment prefill, so
+ # the server's chat template is honoured and the key path is
+ # read in context (terminator included: prefix-free paths);
+ # 2. ONE /v1/completions call carrying every trie node as a prompt
+ # (token ids), max_tokens 1, logprob_token_ids = union of child
+ # tokens; raw log-probs sum along each path, one normalisation.
+
+ _JUDGMENT_PREFILL = "Answer:"
+
+ def _judgment_ask(self, j: "Judgment") -> str:
+ keys = []
+ for k in j.keys:
+ label = j.titles.get(k)
+ desc = j.descriptions.get(k)
+ tail = f": {label} - {desc}" if label and desc else (f": {label or desc}" if (label or desc) else "")
+ keys.append(f"- {k}{tail}")
+ instruction = j.instruction or j.name
+ return f"{instruction}\nOptions:\n" + "\n".join(keys) + "\nAnswer with the option only, spelled exactly as listed."
+
+ def _judgment_messages(self, request: Request, j: "Judgment", answer: str) -> list[dict[str, Any]]:
+ """The conversation, the judgment's question as a final user turn,
+ and the assistant's answer so far (prefill + key)."""
+ compat = self._compat_for(request.model)
+ messages = self._build_messages(replace(request, config=Config()), compat)
+ messages.append({"role": "user", "content": self._judgment_ask(j)})
+ messages.append({"role": "assistant", "content": answer})
+ return messages
+
+ def _judgment_tokenize_request(self, model: str, messages: list[dict[str, Any]], *, continue_final: bool) -> TransportRequest:
+ return self._emit(
+ method="POST",
+ url=f"{self.base_url.rstrip('/').removesuffix('/v1')}/tokenize",
+ endpoint="tokenize",
+ model=model,
+ headers=self._headers(),
+ payload={"model": model, "messages": messages, "add_generation_prompt": False,
+ "continue_final_message": continue_final},
+ )
+
+ def _judgment_reply_error(self, response: HttpResponse, detail: str) -> ProviderError:
+ error = ProviderError(f"malformed judgment reply: {detail}", provider=self.provider, status=response.status)
+ _attach_error_metadata(error, response.headers)
+ return error
+
+ def _judgment_tokens_from_body(self, response: HttpResponse) -> list[int]:
+ data = response.json()
+ tokens = data.get("tokens") if isinstance(data, dict) else None
+ if not isinstance(tokens, list) or not tokens or not all(type(t) is int and t >= 0 for t in tokens):
+ raise self._judgment_reply_error(response, "tokenize reply carries no non-negative integer token list")
+ return tokens
+
+ def _judgment_score_request(self, model: str, prompts: list[list[int]], token_ids: list[int]) -> TransportRequest:
+ return self._emit(
+ method="POST",
+ url=f"{self.base_url.rstrip('/')}/completions",
+ endpoint="completions",
+ model=model,
+ headers=self._headers(),
+ payload={"model": model, "prompt": prompts, "max_tokens": 1, "temperature": 1.0, "logprobs": 0,
+ "return_tokens_as_token_ids": True, "logprob_token_ids": sorted(token_ids)},
+ )
+
+ def _judgment_scores_from_body(self, response: HttpResponse, n_prompts: int) -> tuple[list[dict[int, float]], Usage, str | None]:
+ """Per prompt, measured token log-probs; missing ids follow MAP-14 §4."""
+ data = response.json()
+ choices = data.get("choices") if isinstance(data, dict) else None
+ if (not isinstance(choices, list) or len(choices) != n_prompts
+ or any(not isinstance(c, dict) or type(c.get("index")) is not int for c in choices)
+ or {c["index"] for c in choices} != set(range(n_prompts))):
+ raise self._judgment_reply_error(response, "choices must contain every prompt index exactly once")
+ out: list[dict[int, float]] = []
+ for choice in sorted(choices, key=lambda c: c["index"]):
+ logprobs = choice.get("logprobs")
+ if logprobs is None:
+ logprobs = {}
+ if not isinstance(logprobs, dict):
+ raise self._judgment_reply_error(response, "logprobs must be an object or null")
+ top_list = logprobs.get("top_logprobs")
+ if top_list is None or top_list == []:
+ top = {}
+ elif isinstance(top_list, list) and len(top_list) == 1 and (top_list[0] is None or isinstance(top_list[0], dict)):
+ top = top_list[0] if top_list[0] is not None else {}
+ else:
+ raise self._judgment_reply_error(response, "expected one top_logprobs object")
+ scores: dict[int, float] = {}
+ for token, value in top.items():
+ if isinstance(token, str) and token.startswith("token_id:") and token[9:].isascii() and token[9:].isdigit():
+ # -inf is a zero-likelihood token; NaN/+inf, positive log
+ # probabilities, booleans and string coercions are not measurements.
+ if (isinstance(value, bool) or not isinstance(value, (int, float))
+ or value > 0 or (isinstance(value, float) and math.isnan(value))):
+ raise self._judgment_reply_error(response, f"invalid log probability for {token}")
+ try:
+ scores[int(token[9:])] = float(value)
+ except (ValueError, OverflowError) as exc:
+ raise self._judgment_reply_error(response, f"invalid token score for {token}") from exc
+ out.append(scores)
+ usage_raw = data.get("usage")
+ if usage_raw is None:
+ usage_raw = {}
+ if not isinstance(usage_raw, dict):
+ raise self._judgment_reply_error(response, "usage must be an object or null")
+ for name in ("prompt_tokens_details", "completion_tokens_details"):
+ if usage_raw.get(name) is not None and not isinstance(usage_raw[name], dict):
+ raise self._judgment_reply_error(response, f"{name} must be an object or null")
+ try:
+ usage = _usage_from_chat(usage_raw)
+ except (ValueError, TypeError, OverflowError) as exc:
+ raise self._judgment_reply_error(response, f"invalid usage: {exc}") from exc
+ model = data.get("model")
+ if model is not None and (not isinstance(model, str) or not model):
+ raise self._judgment_reply_error(response, "model must be a non-empty string")
+ return out, usage, model
+
+ def _judgment_plan(self, request: Request) -> "list[dict[str, Any]]":
+ """One entry per judgment: the tokenize requests it needs. Pure."""
+ plan = []
+ for name, j in request_judgments(request).items():
+ plan.append({
+ "judgment": j,
+ "prefill": self._judgment_tokenize_request(request.model, self._judgment_messages(request, j, self._JUDGMENT_PREFILL), continue_final=True),
+ "keys": {k: (self._judgment_tokenize_request(request.model, self._judgment_messages(request, j, f"{self._JUDGMENT_PREFILL} {k}"), continue_final=True),
+ self._judgment_tokenize_request(request.model, self._judgment_messages(request, j, f"{self._JUDGMENT_PREFILL} {k}"), continue_final=False))
+ for k in j.keys},
+ })
+ return plan
- def response_from_openai_chat(self, body: Mapping[str, Any], *, model: str | None = None, choice: int | None = None) -> Response:
+ @staticmethod
+ def _judgment_paths(prefix: list[int], keys: dict[str, tuple[list[int], list[int]]]) -> dict[str, tuple[int, ...]]:
+ """Each key's token path after the prefill, terminator included."""
+ paths: dict[str, tuple[int, ...]] = {}
+ for key, (open_tokens, closed_tokens) in keys.items():
+ if open_tokens[:len(prefix)] != prefix or closed_tokens[:len(open_tokens)] != open_tokens:
+ raise UnsupportedFeatureError(
+ f"openai-chat: key {key!r} does not tokenize as an extension of the prefill in this chat template; "
+ "candidate-sequence scoring cannot place it (rename the key or use a provider that classifies natively)",
+ provider="openai-chat", feature="config.response_format",
+ )
+ body = open_tokens[len(prefix):]
+ terminator = closed_tokens[len(open_tokens):len(open_tokens) + 1]
+ if not body or not terminator:
+ raise UnsupportedFeatureError(
+ f"openai-chat: key {key!r} yields no scorable tokens (empty key or no end-of-turn token in the template)",
+ provider="openai-chat", feature="config.response_format",
+ )
+ paths[key] = tuple(body) + tuple(terminator)
+ return paths
+
+ @staticmethod
+ def _judgment_nodes(paths: dict[str, tuple[int, ...]]) -> dict[tuple[int, ...], set[int]]:
+ nodes: dict[tuple[int, ...], set[int]] = {}
+ for seq in paths.values():
+ for i in range(len(seq)):
+ nodes.setdefault(seq[:i], set()).add(seq[i])
+ return nodes
+
+ def _judgment_fold(self, request: Request, found: "dict[str, Judgment]", per_judgment: list[tuple["Judgment", dict[str, tuple[int, ...]], dict[tuple[int, ...], dict[int, float]]]],
+ usage: Usage, model: str | None, n_nodes: int, tokenize_calls: int) -> Response:
+ value: dict[str, Any] = {}
+ probabilities: dict[str, dict[str, float]] = {}
+ coverage: dict[str, float] = {}
+ for j, paths, table in per_judgment:
+ raw = {key: sum(table[seq[:i]][seq[i]] for i in range(len(seq))) for key, seq in paths.items()}
+ if not any(math.isfinite(v) for v in raw.values()):
+ raise ProviderError(
+ f"judgment {j.name!r} has zero likelihood for every declared key; cannot normalize",
+ provider=self.provider,
+ )
+ coverage[j.name] = sum(math.exp(v) for v in raw.values())
+ dist = normalize_logprobs(raw)
+ probabilities[j.name] = dist
+ best = max(dist, key=dist.get)
+ value[j.name] = (best == "true") if j.kind == "boolean" else (int(best) if j.ordered else best)
+ part = DataPart(value=value, probabilities=probabilities, method="candidate_sequence_likelihood")
+ return Response(
+ id=None,
+ model=str(model or request.model),
+ message=Message(role="assistant", parts=(part,)),
+ finish_reason="stop",
+ usage=usage,
+ provider_data={"coverage": coverage, "judgments": {"nodes": n_nodes, "tokenize_calls": tokenize_calls, "method": "candidate_sequence_likelihood"}},
+ )
+
+ def _judgments_via_token_scoring(self, request: Request) -> bool:
+ return (self._scores_named_tokens(request.model) and request.config.probabilities in ("if_available", "required")
+ and bool(request_judgments(request)))
+
+ def _validate_judgment_scoring(self, request: Request) -> None:
+ """Harmful omissions are refusals, not silent scoring adaptations."""
+ def refuse(feature: str, reason: str) -> None:
+ raise UnsupportedFeatureError(
+ f"{self.provider}: {reason}; use generated JSON with probabilities='off' "
+ "or a separate scoring request",
+ provider=self.provider, feature=feature,
+ )
+
+ if request.tools:
+ refuse("tools", "candidate scoring cannot execute tools; the program may depend on their results")
+ if request.config.tool_choice is not None:
+ refuse("config.tool_choice", "candidate scoring cannot preserve tool/action semantics")
+ if request.config.cache is not None and request.config.cache.resource is not None:
+ refuse("config.cache.resource", "candidate scoring cannot read a stored cache object; omitting it would lose prompt content")
+ n = (request.config.extensions or {}).get("n")
+ if isinstance(n, (int, float)) and not isinstance(n, bool) and n > 1:
+ refuse("config.extensions.n", "n > 1 has no canonical multiple-response representation")
+ for name in ("store", "user_id", "service_tier"):
+ if getattr(request.config, name) is not None:
+ refuse(f"config.{name}", "measurement endpoints have no established mapping for this privacy, safety or billing control")
+ cache = request.config.cache
+ if cache is not None:
+ if cache.mode == "off":
+ refuse("config.cache.mode", "measurement endpoints cannot guarantee cache writes are disabled")
+ if cache.retention is not None:
+ refuse("config.cache.retention", "measurement endpoints cannot preserve cache lifetime and billing intent")
+ harmless = {"temperature", "top_p", "top_k", "seed", "frequency_penalty", "presence_penalty"}
+ for name, value in (request.config.extensions or {}).items():
+ numeric = type(value) is int or (isinstance(value, float) and math.isfinite(value))
+ if (name == "n" and numeric and value == 1) or (name in harmless and numeric):
+ continue
+ refuse(f"config.extensions.{name}", "unknown measurement extension semantics; dropping it could lose privacy, money or action controls")
+
+ @staticmethod
+ def _judgment_mixed(request: Request) -> bool:
+ return bool(non_judgment_properties(request.config.response_format["schema"], request_judgments(request)))
+
+ @staticmethod
+ def _judgment_generated_request(request: Request) -> Request:
+ return replace(request, config=replace(request.config, probabilities="off"))
+
+ def _judgment_stream_policy(self, request: Request) -> None:
+ if request.config.probabilities == "required":
+ raise UnsupportedFeatureError(
+ f"{self.provider}: candidate scoring produces a non-streamable DataPart; "
+ "use complete() for required probabilities or a separate scoring request",
+ provider=self.provider, feature="config.probabilities",
+ )
+ adapt("config.probabilities", "dropped",
+ "stream() uses generated JSON, not candidate scoring; the answer carries an unmeasured pick only; use complete() for scoring",
+ asked=request.config.probabilities, provider=self.provider)
+
+ def _judgment_adaptations(self, request: Request, *, policy: AdaptationPolicy | None = None) -> "tuple[Adaptation, ...]":
+ # Shared offline preflight for plan, complete and async complete. No
+ # tokenization builder, credential provider or transport runs here.
+ self._validate_judgment_scoring(request)
+ with collecting(check_policy(policy if policy is not None else self.adaptations), provider=self.provider, planning=True) as scope:
+ from ..serde import config_to_dict
+
+ mixed = self._judgment_mixed(request)
+ if mixed:
+ adapt("config.response_format", "client_side",
+ "an additional structured-output call answers ordinary properties, which are never scored",
+ provider=self.provider)
+ config = config_to_dict(request.config)
+ for name in ("max_tokens", "temperature", "top_p", "top_k", "stop", "seed", "frequency_penalty",
+ "presence_penalty", "reasoning", "logprobs", "cache", "extensions"):
+ if name in config:
+ adapt(f"config.{name}", "dropped",
+ "candidate likelihood measures unmodified next-token probabilities with max_tokens=1 per trie node; "
+ "this generation setting has no measurement slot (any generated JSON call still uses its usual mapping)",
+ asked=config[name], provider=self.provider)
+ if mixed:
+ self._payload(self._judgment_generated_request(request), stream=False)
+ self._build_messages(replace(request, config=Config()), self._compat_for(request.model))
+ return tuple(scope.records)
+
+ def plan(self, request: Request, *, policy: AdaptationPolicy | None = None) -> "tuple[Adaptation, ...]":
+ wire_request = self._wire_request(request)
+ if self._judgments_via_token_scoring(wire_request):
+ return self._judgment_adaptations(wire_request, policy=policy)
+ return BaseProviderLM.plan(self, request, policy=policy)
+
+ def complete(self, request: Request) -> Response:
+ wire_request = self._wire_request(request)
+ if not self._judgments_via_token_scoring(wire_request):
+ return BaseProviderLM.complete(self, request)
+ adaptations = self._judgment_adaptations(wire_request)
+ found = request_judgments(request)
+ plan = self._judgment_plan(wire_request)
+ tokenized: list[tuple["Judgment", dict[str, tuple[int, ...]], list[int]]] = []
+ calls = 0
+ for entry in plan:
+ prefix = self._judgment_tokens_from_body(self._send_ok(entry["prefill"])); calls += 1
+ keys = {}
+ for key, (open_req, closed_req) in entry["keys"].items():
+ keys[key] = (self._judgment_tokens_from_body(self._send_ok(open_req)),
+ self._judgment_tokens_from_body(self._send_ok(closed_req))); calls += 2
+ tokenized.append((entry["judgment"], self._judgment_paths(prefix, keys), prefix))
+ return self._judgment_score_and_fold(request, found, tokenized, calls, adaptations)
+
+ def _send_ok(self, req: TransportRequest) -> HttpResponse:
+ resp = self._send(req)
+ if resp.status >= 400:
+ raise self._http_error(resp)
+ return resp
+
+ def _judgment_score_and_fold(self, request: Request, found, tokenized, calls: int, adaptations) -> Response:
+ wire_request = self._wire_request(request)
+ prompts: list[list[int]] = []
+ meta: list[tuple[int, tuple[int, ...]]] = []
+ union: set[int] = set()
+ nodes_per: list[dict[tuple[int, ...], set[int]]] = []
+ for index, (j, paths, prefix) in enumerate(tokenized):
+ nodes = self._judgment_nodes(paths)
+ nodes_per.append(nodes)
+ for node_prefix, children in nodes.items():
+ prompts.append(list(prefix) + list(node_prefix))
+ meta.append((index, node_prefix))
+ union |= children
+ req = self._judgment_score_request(wire_request.model, prompts, sorted(union))
+ resp = self._send_ok(req)
+ scores, usage, model = self._judgment_scores_from_body(resp, len(prompts))
+ tables: list[dict[tuple[int, ...], dict[int, float]]] = [{} for _ in tokenized]
+ for (index, node_prefix), got in zip(meta, scores):
+ children = nodes_per[index][node_prefix]
+ if any(t not in got for t in children):
+ return self._judgment_unmeasured(request, adaptations, usage)
+ tables[index][node_prefix] = {t: got[t] for t in children}
+ per = [(j, paths, tables[i]) for i, (j, paths, _) in enumerate(tokenized)]
+ try:
+ response = self._judgment_fold(wire_request, found, per, usage, model, len(prompts), calls)
+ except ProviderError as error:
+ error.status = resp.status
+ _attach_error_metadata(error, resp.headers)
+ raise
+ if self._judgment_mixed(request):
+ generated, _ = self._judgment_generate(request)
+ response = self._judgment_merge(response, generated)
+ return replace(response, adaptations=self._visible(adaptations))
+
+ def _judgment_generate(self, request: Request, *, unmeasured: bool = False):
+ from .base import _client_side_stop
+ from ..result import materialize_response
+
+ generated_request = self._judgment_generated_request(request)
+ wire, built = self._build(generated_request, stream=False)
+ if _client_side_stop(built):
+ # Preserve the ordinary driver's close-at-stop billing semantics.
+ plain = replace(generated_request, config=replace(generated_request.config, response_format=None))
+ response = materialize_response(self.stream(generated_request), plain)
+ return self._judgment_generated_value(generated_request, response, unmeasured=unmeasured), built
+ reply = self._send_ok(wire)
+ return self._judgment_generated_response(generated_request, reply, built, unmeasured=unmeasured), built
+
+ def _judgment_generated_response(self, request: Request, reply: HttpResponse, adaptations, *, policy=None, unmeasured: bool = False) -> Response:
+ """A strict semantic boundary: never repair an incomplete JSON answer."""
+ try:
+ # Read raw text first: the general judgment fold is deliberately lenient.
+ plain = replace(request, config=replace(request.config, response_format=None))
+ body = reply.json()
+ if isinstance(body, dict) and isinstance(body.get("error"), dict):
+ self.parse_response(plain, reply) # preserve in-band provider errors
+ choices = body.get("choices") if isinstance(body, dict) else None
+ if (not isinstance(choices, list) or len(choices) != 1 or not isinstance(choices[0], dict)
+ or choices[0].get("finish_reason") != "stop"):
+ raise ValueError("generated judgment reply needs one complete choice with finish_reason='stop'")
+ response = self.parse_response(plain, reply)
+ response = self._finish_response(request, response, adaptations, policy=policy)
+ return self._judgment_generated_value(request, response, unmeasured=unmeasured)
+ except ProviderError as error:
+ error.status = reply.status
+ _attach_error_metadata(error, reply.headers)
+ raise
+ except (ValueError, TypeError, KeyError, AttributeError, IndexError, OverflowError) as error:
+ raise self._judgment_reply_error(reply, str(error)) from error
+
+ def _judgment_generated_value(self, request: Request, response: Response, *, unmeasured: bool = False) -> Response:
+ try:
+ if response.finish_reason != "stop":
+ raise ValueError("generated judgment answer did not finish completely")
+ texts = [p for p in response.message.parts if isinstance(p, TextPart)]
+ if len(texts) != 1:
+ raise ValueError("generated judgment answer needs one JSON object")
+ def invalid_constant(value):
+ raise ValueError(f"non-finite JSON constant {value}")
+ value = json.loads(texts[0].text, parse_constant=invalid_constant)
+ if not isinstance(value, dict):
+ raise ValueError("generated judgment answer needs a JSON object")
+ schema = request.config.response_format["schema"]
+ measured_fields = request_judgments(request)
+ for name in schema.get("required", ()):
+ if (unmeasured or name not in measured_fields) and name not in value:
+ raise ValueError(f"generated answer is missing required property {name!r}")
+ part = DataPart(value=value, continuation=texts[0].continuation)
+ parts = tuple(part if p is texts[0] else p for p in response.message.parts)
+ return replace(response, message=replace(response.message, parts=parts), adaptations=())
+ except (ValueError, TypeError, OverflowError) as error:
+ raise ProviderError(f"malformed generated judgment JSON: {error}", provider=self.provider) from error
+
+ @staticmethod
+ def _judgment_sum_usage(scoring: Usage, generated: Usage) -> Usage:
+ return Usage(**{name: (getattr(scoring, name) + getattr(generated, name)
+ if getattr(scoring, name) is not None and getattr(generated, name) is not None else None)
+ for name in Usage.__dataclass_fields__})
+
+ def _judgment_merge(self, measured: Response, generated: Response) -> Response:
+ from ..serde import response_to_dict, usage_to_dict
+
+ original = generated.message.first(DataPart)
+ scored = measured.message.first(DataPart)
+ part = replace(scored, value={**original.value, **scored.value}, continuation=original.continuation)
+ return replace(measured, id=generated.id, finish_reason=generated.finish_reason,
+ message=replace(generated.message, parts=tuple(part if p is original else p for p in generated.message.parts)),
+ usage=self._judgment_sum_usage(measured.usage, generated.usage),
+ provider_data={**(measured.provider_data or {}), "scoring_usage": usage_to_dict(measured.usage),
+ "generated_response": response_to_dict(generated, include_provider_data=True)})
+
+ def _judgment_fallback_usage(self, generated: Response, usage: Usage) -> Response:
+ from ..serde import usage_to_dict
+
+ return replace(generated, usage=self._judgment_sum_usage(usage, generated.usage),
+ provider_data={**(generated.provider_data or {}), "scoring_usage": usage_to_dict(usage)})
+
+ def _judgment_unmeasured(self, request: Request, adaptations, usage: Usage) -> Response:
+ """The server answered 200 without the requested token ids: it dropped
+ ``logprob_token_ids`` (receipted on vLLM 0.25.1). ``required`` refuses;
+ ``if_available`` answers by structured output instead and records it."""
+ if request.config.probabilities == "required":
+ raise UnsupportedFeatureError(
+ f"{self.provider}: config.probabilities='required' but this server ignored logprob_token_ids "
+ "(vLLM < 0.29?); no distribution can be measured here",
+ provider=self.provider, feature="config.probabilities",
+ )
+ with collecting(check_policy(self.adaptations), provider=self.provider) as scope:
+ adapt("config.probabilities", "dropped",
+ "the server accepted the request and returned no log-probs for the requested token ids (logprob_token_ids ignored); "
+ "answered by structured output instead", asked=request.config.probabilities, provider=self.provider)
+ response, built = self._judgment_generate(request, unmeasured=True)
+ response = self._judgment_fallback_usage(response, usage)
+ records = tuple(adaptations) + tuple(scope.records) + tuple(a for a in built if a not in adaptations)
+ return replace(response, adaptations=self._visible(records))
+
+ def _scores_named_tokens(self, model: str | None = None) -> bool:
+ """Whether the selected model can deliver a measured distribution."""
+ compat = self._compat_for(model) if model is not None else self._resolved_compat
+ return getattr(compat, "token_scoring", "none") == "logprob_token_ids"
+
+ def response_from_openai_chat(self, body: Mapping[str, Any], *, model: str | None = None, choice: int | None = None,
+ response_format: Mapping[str, Any] | None = None) -> Response:
"""A Chat Completions response body → canonical :class:`Response`
under this adapter's provider name and error mapping; see
- :func:`response_from_openai_chat`."""
- return _response_from_chat_body(self.provider, body, model=model, choice=choice, on_error=self._response_error)
+ :func:`response_from_openai_chat`. ``response_format`` (the
+ request's) folds a judgment answer into a DataPart (MAP-14)."""
+ resp = _response_from_chat_body(self.provider, body, model=model, choice=choice, on_error=self._response_error)
+ return _fold_judgments(resp, response_format)
# ─── Stream parsing ──────────────────────────────────────────────
def parse_stream_events(self, request: Request, raw_event: SSEEvent) -> Iterator[StreamEvent]:
+ request = self._wire_request(request)
if not raw_event.data:
return
if raw_event.data == "[DONE]":
diff --git a/dspy/_vendor/lm15/providers/typesafe.py b/dspy/_vendor/lm15/providers/typesafe.py
new file mode 100644
index 000000000..0206501c9
--- /dev/null
+++ b/dspy/_vendor/lm15/providers/typesafe.py
@@ -0,0 +1,341 @@
+"""TypeSafe System One (Jev) — provider ``typesafe``.
+
+changes/2026-09-17-judgments.md. One ``POST /v1/systemone`` per Request:
+the messages become Jev's ``state`` (D6), the judgment properties of the
+``json_schema`` become its ``questions`` (MAP-14 §2), and the answers come
+back as one ``DataPart`` with the distribution per judgment and
+``method="provider_classification"`` (§3). Jev generates no text: a
+request without judgments, with tools, or with media is refused before
+the wire (D8). Wire facts: receipts/2026-09-17-judgments/ (jev-*.json).
+"""
+from __future__ import annotations
+
+import json
+import math
+import os
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Callable, ClassVar, Iterator, Mapping
+
+from ..access import TYPESAFE_API
+from ..adaptation import AdaptationPolicy, adapt, check_policy
+from ..errors import (
+ AuthError,
+ InvalidRequestError,
+ ProviderError,
+ RateLimitError,
+ ServerError,
+ UnsupportedFeatureError,
+ UnsupportedModelError,
+ map_http_error,
+)
+from ..features import ProviderManifest
+from ..judgments import MAX_CHOICE_KEYS, MAX_ORDERED_LEVELS, Judgment, non_judgment_properties, request_judgments
+from ..transports import TransportRequest
+from ..types import DataPart, Message, Request, Response, StreamEvent, TextPart, Usage
+from .base import BaseProviderLM, Credential, HttpResponse, SyncTransport, default_transport, _attach_error_metadata
+from .common import model_infos_from_entries
+from ..sse import SSEEvent
+
+_DEFAULT_BASE_URL = "https://api.typesafe.ai"
+
+# Config knobs with no home on the systemone wire (D8): dropped with a record.
+_DROPPED_KNOBS: tuple[str, ...] = (
+ "max_tokens", "temperature", "top_p", "top_k", "stop", "seed", "frequency_penalty",
+ "presence_penalty", "reasoning", "logprobs", "store", "user_id", "service_tier", "cache",
+)
+
+
+@dataclass
+class TypeSafeLM(BaseProviderLM):
+ """TypeSafe System One dialect (``POST /v1/systemone``)."""
+
+ api_key: Credential | None = field(default=None, repr=False)
+ transport: SyncTransport = field(default_factory=default_transport)
+ base_url: str = _DEFAULT_BASE_URL
+ access: ProviderManifest | None = None
+ credentials_path: "str | os.PathLike[str] | None" = field(default=None, repr=False)
+ settings: "Mapping[str, str] | None" = None
+ clock: "Callable[[], datetime] | None" = field(default=None, repr=False)
+ adaptations: AdaptationPolicy = field(default="note", kw_only=True)
+ provider: str = field(default="typesafe", init=False)
+ account_id: str | None = field(default=None, init=False, repr=False)
+ manifest: ClassVar[ProviderManifest] = TYPESAFE_API
+
+ def __post_init__(self) -> None:
+ check_policy(self.adaptations)
+ self._bind_access(self.access, credentials_path=self.credentials_path,
+ default_base_url=_DEFAULT_BASE_URL, settings=self.settings)
+
+ # ─── Request building (pure) ────────────────────────────────────
+
+ def _refuse(self, feature: str, why: str) -> UnsupportedFeatureError:
+ return UnsupportedFeatureError(f"{self.provider}: {why}", provider=self.provider, feature=feature)
+
+ def _state(self, request: Request) -> Any:
+ """changes/2026-09-19-jev-state.md D1/D2: the state is the one user
+ part, verbatim — a text's string or a data part's value. Jev has
+ no system prompt and no conversation; anything else is refused
+ with the native place named, never merged into a shape of ours.
+ A media part is refused first, as the specific fault it is (MAP-10)."""
+ for m_index, message in enumerate(request.messages):
+ for p_index, part in enumerate(message.parts):
+ if not isinstance(part, (TextPart, DataPart)):
+ raise self._refuse(
+ f"messages[{m_index}].parts[{p_index}]",
+ f"a {part.type} part has no slot on the systemone wire (MAP-10); Jev reads text or data",
+ )
+ if request.system is not None:
+ raise self._refuse(
+ "system",
+ "Jev has no system prompt; put context in the state as a named key "
+ "(Message.user(data({\"policy\": ..., \"note\": ...}))), or the framing in each "
+ "question's description (changes/2026-09-19-jev-state.md D2)",
+ )
+ if len(request.messages) != 1:
+ raise self._refuse(
+ "messages",
+ f"Jev judges one state, got {len(request.messages)} messages; put a transcript in the "
+ "state as an array or object (Message.user(data({\"messages\": [...]}))), where a "
+ "question can point at a turn with a backtick path (changes/2026-09-19-jev-state.md D2)",
+ )
+ message = request.messages[0]
+ if message.role != "user":
+ raise self._refuse("messages[0].role", f"Jev's state is a user message, got role {message.role!r}")
+ if len(message.parts) != 1:
+ raise self._refuse(
+ "messages[0].parts",
+ f"Jev's state is one text or data part, got {len(message.parts)} parts; put several pieces "
+ "in one data part as named keys",
+ )
+ only = message.parts[0]
+ return only.text if isinstance(only, TextPart) else only.value # type: ignore[union-attr]
+
+ def _questions(self, request: Request) -> dict[str, Any]:
+ fmt = request.config.response_format
+ if not isinstance(fmt, dict) or fmt.get("type") != "json_schema":
+ raise self._refuse(
+ "config.response_format",
+ "Jev answers declared judgments only; give a json_schema response_format whose "
+ "properties are enums / booleans / ordered levels (MAP-14), e.g. lm15.judgments(...)",
+ )
+ found = request_judgments(request)
+ extra = non_judgment_properties(fmt.get("schema"), found)
+ if not found or extra:
+ what = f"properties {list(extra)} are free-form" if extra else "no property declares a judgment"
+ raise self._refuse(
+ "config.response_format",
+ f"{what}; Jev cannot generate values, only pick among declared keys (MAP-14 §1)",
+ )
+ questions: dict[str, Any] = {}
+ for name, j in found.items():
+ instruction = j.instruction
+ if instruction is None:
+ adapt(
+ f"config.response_format.schema.properties.{name}.description",
+ "defaulted",
+ "a judgment without a description: the property name goes as the instruction (Jev never sees property names)",
+ applied=name,
+ provider=self.provider,
+ )
+ instruction = name
+ if j.kind == "boolean":
+ questions[name] = {"type": "noul", "instructions": instruction}
+ elif j.kind == "choice":
+ if len(j.keys) > MAX_CHOICE_KEYS:
+ raise self._refuse(f"config.response_format.schema.properties.{name}",
+ f"a Jev choice takes at most {MAX_CHOICE_KEYS} keys, got {len(j.keys)}")
+ questions[name] = {"type": "choice", "instructions": instruction,
+ "criteria": {k: j.descriptions.get(k) for k in j.keys}}
+ else:
+ if len(j.keys) > MAX_ORDERED_LEVELS:
+ raise self._refuse(f"config.response_format.schema.properties.{name}",
+ f"a Jev score takes at most {MAX_ORDERED_LEVELS} levels, got {len(j.keys)}")
+ criteria = [j.descriptions.get(k) or k for k in j.keys]
+ questions[name] = {"type": "score", "instructions": instruction, "criteria": criteria}
+ return questions
+
+ def _payload(self, request: Request) -> dict[str, Any]:
+ if request.tools:
+ raise self._refuse("tools", "tools have no slot on the systemone wire")
+ cfg = request.config
+ if cfg.tool_choice is not None:
+ raise self._refuse("config.tool_choice", "tool_choice has no slot on the systemone wire")
+ for name in _DROPPED_KNOBS:
+ value = getattr(cfg, name)
+ if value is None or value == ():
+ continue
+ adapt(f"config.{name}", "dropped", "no such control on the systemone wire (Jev returns decisions, not samples)",
+ asked=value if isinstance(value, (int, float, str, bool)) else str(value), provider=self.provider)
+ questions = self._questions(request)
+ payload: dict[str, Any] = {"model": request.model, "state": self._state(request), "questions": questions}
+ if cfg.extensions:
+ for key, value in cfg.extensions.items():
+ if key == "n" and isinstance(value, (int, float)) and value > 1:
+ raise self._refuse("config.extensions.n", "n > 1 has no canonical multiple-response representation")
+ payload[key] = value
+ return payload
+
+ def build_request(self, request: Request, stream: bool) -> TransportRequest:
+ request = self._wire_request(request)
+ if stream:
+ raise self._refuse("stream", "systemone answers in one piece; there is no stream to wrap")
+ return self._emit(
+ method="POST",
+ url=f"{self.base_url.rstrip('/')}/v1/systemone",
+ endpoint="systemone",
+ model=request.model,
+ headers={"Content-Type": "application/json"},
+ payload=self._payload(request),
+ )
+
+ # ─── Response parsing (pure) ────────────────────────────────────
+
+ def parse_response(self, request: Request, response: HttpResponse) -> Response:
+ request = self._wire_request(request)
+ data = response.json()
+ found = request_judgments(request)
+
+ def invalid(path: str, detail: str) -> ProviderError:
+ error = ProviderError(
+ f"malformed systemone reply at {path}: {detail}",
+ provider=self.provider, status=response.status,
+ request_id=self._request_id(response),
+ )
+ _attach_error_metadata(error, response.headers)
+ return error
+
+ def probability(raw: Any, path: str) -> float:
+ # Check bounds before converting: arbitrarily large JSON integers
+ # must be provider faults too, not float-conversion OverflowError.
+ if (isinstance(raw, bool) or not isinstance(raw, (int, float))
+ or not 0 <= raw <= 1 or not math.isfinite(raw)):
+ raise invalid(path, "expected a finite number in [0, 1]")
+ return float(raw)
+
+ if not isinstance(data, dict):
+ raise invalid("$", "expected an object")
+ answers = data.get("answers")
+ if not isinstance(answers, dict):
+ raise invalid("answers", "expected an object containing every declared judgment")
+ if set(answers) != set(found):
+ raise invalid("answers", "keys must match the declared judgments exactly")
+ value: dict[str, Any] = {}
+ probabilities: dict[str, dict[str, float]] = {}
+ for name, j in found.items():
+ answer = answers[name]
+ path = f"answers.{name}"
+ if not isinstance(answer, dict):
+ raise invalid(path, "expected an answer object")
+ expected = {"boolean": "noul", "choice": "choice", "ordered": "score"}[j.kind]
+ if answer.get("type") != expected:
+ raise invalid(f"{path}.type", f"expected {expected!r}")
+ if j.kind == "boolean":
+ p = probability(answer.get("noul"), f"{path}.noul")
+ value[name] = p >= 0.5
+ probabilities[name] = {"true": p, "false": 1.0 - p}
+ continue
+ dist = answer.get("probabilities")
+ if not isinstance(dist, dict) or set(dist) != set(j.keys):
+ raise invalid(f"{path}.probabilities", "expected one probability for every declared key, and no other keys")
+ # INV-052: validate measurements individually, NEVER their total.
+ probs = {k: probability(dist[k], f"{path}.probabilities.{k}") for k in j.keys}
+ probabilities[name] = probs
+ if j.kind == "choice":
+ pick = answer.get("choice")
+ if not isinstance(pick, str) or pick not in j.keys:
+ raise invalid(f"{path}.choice", "expected a declared choice key")
+ value[name] = pick
+ else:
+ value[name] = int(max(probs, key=probs.get))
+ try:
+ part = DataPart(value=value, probabilities=probabilities or None,
+ method="provider_classification" if probabilities else None)
+ except (TypeError, ValueError, OverflowError) as exc:
+ raise invalid("answers", str(exc)) from exc
+ usage_raw = data.get("usage")
+ if usage_raw is None:
+ usage_raw = {}
+ if not isinstance(usage_raw, dict):
+ raise invalid("usage", "expected an object or null")
+ try:
+ usage = Usage(input_tokens=usage_raw.get("input_tokens"), output_tokens=usage_raw.get("output_tokens"))
+ except (TypeError, ValueError, OverflowError) as exc:
+ raise invalid("usage", str(exc)) from exc
+ model = data.get("model")
+ if model is not None and (not isinstance(model, str) or not model):
+ raise invalid("model", "expected a non-empty string")
+ provider_data: dict[str, Any] = {"typesafe": {"answers": answers}}
+ try:
+ return Response(
+ id=self._request_id(response),
+ model=model if model is not None else request.model,
+ message=Message(role="assistant", parts=(part,)),
+ finish_reason="stop",
+ usage=usage,
+ provider_data=provider_data,
+ )
+ except (TypeError, ValueError, OverflowError) as exc:
+ raise invalid("$", str(exc)) from exc
+
+ @staticmethod
+ def _request_id(response: HttpResponse) -> str | None:
+ for key, val in response.headers:
+ if key.lower() == "x-typesafe-request-id" and val:
+ return val
+ return None
+
+ def parse_stream_events(self, request: Request, raw_event: SSEEvent) -> Iterator[StreamEvent]:
+ raise self._refuse("stream", "systemone has no stream")
+
+ # ─── Errors ─────────────────────────────────────────────────────
+
+ def normalize_error(self, status: int, body: str) -> ProviderError:
+ message = body.strip()[:500] or f"HTTP {status}"
+ code: str | None = None
+ try:
+ payload = json.loads(body)
+ except (ValueError, TypeError):
+ payload = None
+ detail = payload.get("detail") if isinstance(payload, dict) else None
+ if isinstance(detail, dict):
+ code = detail.get("error_type") if isinstance(detail.get("error_type"), str) else None
+ if isinstance(detail.get("message"), str):
+ message = detail["message"]
+ elif isinstance(detail, list) and detail:
+ # pydantic validation: [{type, loc, msg, input}]
+ first = detail[0] if isinstance(detail[0], dict) else {}
+ loc = ".".join(str(x) for x in first.get("loc", []) if x != "body")
+ message = f"{loc}: {first.get('msg', 'validation error')}" if loc else str(first.get("msg", message))
+ kwargs: dict[str, Any] = {"provider": self.provider, "provider_code": code, "status": status}
+ if status == 401 or code == "authentication_error":
+ return AuthError(message, env_keys=self.access.env_keys, **kwargs)
+ if status == 429:
+ return RateLimitError(message, **kwargs)
+ if status == 400 and "unknown model" in message.lower():
+ return UnsupportedModelError(message, **kwargs)
+ if status in (400, 422):
+ return InvalidRequestError(message, **kwargs)
+ if status >= 500:
+ return ServerError(message, **kwargs)
+ return self._with_login_hint(map_http_error(status, message, provider=self.provider,
+ env_keys=self.access.env_keys, provider_code=code))
+
+ # ─── Models ─────────────────────────────────────────────────────
+
+ def _models_request(self) -> TransportRequest:
+ return self._emit(
+ method="GET",
+ url=f"{self.base_url.rstrip('/')}/v1/models",
+ headers={"Content-Type": "application/json"},
+ )
+
+ def _models_from_body(self, body: str):
+ data = json.loads(body)
+ entries = data.get("models") if isinstance(data, dict) else None
+ return model_infos_from_entries(
+ entries, provider=self.provider, api_family="typesafe_systemone", id_of=lambda e: e.get("name"),
+ )
+
+
+__all__ = ["TypeSafeLM"]
diff --git a/dspy/_vendor/lm15/providers/xai.py b/dspy/_vendor/lm15/providers/xai.py
index 1919531b1..404c868a8 100644
--- a/dspy/_vendor/lm15/providers/xai.py
+++ b/dspy/_vendor/lm15/providers/xai.py
@@ -145,14 +145,14 @@ class XaiLM(OpenAIChatLM):
provider=self.provider,
)
if not request.images:
- return self._emit(method="POST", url=f"{base}/images/generations", headers=self._headers(), payload=payload, read_timeout=300.0)
+ return self._emit(method="POST", url=f"{base}/images/generations", headers=self._headers(), payload=payload)
if len(request.images) > 1:
raise UnsupportedFeatureError(
"xai: image edits take exactly one input image; the wire has no slot for more",
provider=self.provider,
)
payload["image"] = _xai_image_input(request.images[0], self.provider)
- return self._emit(method="POST", url=f"{base}/images/edits", headers=self._headers(), payload=payload, read_timeout=300.0)
+ return self._emit(method="POST", url=f"{base}/images/edits", headers=self._headers(), payload=payload)
def _image_generation_from_response(self, request: ImageGenerationRequest, resp: HttpResponse) -> ImageGenerationResponse:
data = resp.json()
@@ -204,7 +204,7 @@ class XaiLM(OpenAIChatLM):
payload: dict[str, Any] = {"model": request.model, "prompt": request.prompt, **(request.extensions or {})}
return self._emit(
method="POST", url=f"{self.base_url.rstrip('/')}/videos/generations",
- headers=self._headers(), payload=payload, read_timeout=120.0,
+ headers=self._headers(), payload=payload,
)
def _video_job_from_body(self, body: str, video_id: "str | None" = None) -> VideoJobInfo:
@@ -220,7 +220,7 @@ class XaiLM(OpenAIChatLM):
def _video_status_request(self, video_id: str) -> TransportRequest:
return self._emit(
method="GET", url=f"{self.base_url.rstrip('/')}/videos/{path_id(video_id)}",
- headers=self._headers(), read_timeout=60.0,
+ headers=self._headers(),
)
def _video_status_info(self, video_id: str, data: "dict[str, Any]") -> VideoJobInfo:
diff --git a/dspy/_vendor/lm15/rate_limits.py b/dspy/_vendor/lm15/rate_limits.py
new file mode 100644
index 000000000..83512e84d
--- /dev/null
+++ b/dspy/_vendor/lm15/rate_limits.py
@@ -0,0 +1,94 @@
+"""Bounded provider evidence, not a quota model or a retry policy.
+
+Contract: docs/error-diagnostics.md (2026-09-19). Values retain their vendor
+units and duplicates. No credential/header outside the closed set is copied.
+"""
+from __future__ import annotations
+
+import json
+import math
+import re
+from types import MappingProxyType
+from typing import Iterable, Mapping, Sequence
+
+RATE_LIMIT_HEADERS = frozenset({
+ "retry-after", "retry-after-ms", "x-ms-retry-after-ms",
+ "x-ratelimit-type", "x-ratelimit-abusepenalty-active",
+ *(f"x-ratelimit-{field}-{unit}"
+ for field in ("limit", "remaining", "reset", "renewalperiod")
+ for unit in ("requests", "tokens")),
+ *(f"anthropic-ratelimit-{unit}-{field}"
+ for unit in ("requests", "tokens", "input-tokens", "output-tokens")
+ for field in ("limit", "remaining", "reset")),
+})
+
+
+def capture_rate_limits(headers: Iterable[tuple[str, str]]) -> Mapping[str, tuple[str, ...]]:
+ out: dict[str, list[str]] = {}
+ for name, value in headers:
+ if not isinstance(name, str) or not isinstance(value, str):
+ continue
+ name = name.lower()
+ if name not in RATE_LIMIT_HEADERS or not 1 <= len(value) <= 256:
+ continue
+ if any(ord(c) < 32 or ord(c) > 126 for c in value):
+ continue
+ values = out.setdefault(name, [])
+ if len(values) < 4:
+ values.append(value)
+ return MappingProxyType({name: tuple(values) for name, values in out.items()})
+
+
+def freeze_rate_limits(snapshot: Mapping[str, Sequence[str]] | None) -> Mapping[str, tuple[str, ...]]:
+ if not isinstance(snapshot, Mapping):
+ return capture_rate_limits(())
+ return capture_rate_limits((name, value) for name, values in snapshot.items()
+ if isinstance(values, (list, tuple)) for value in values)
+
+
+def milliseconds_seconds(value: object) -> float | None:
+ if not isinstance(value, str) or len(value) > 256:
+ return None
+ if not re.fullmatch(r"\+?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?", value.strip(), flags=re.ASCII):
+ return None
+ number = float(value)
+ return number / 1000 if math.isfinite(number) and number >= 0 else None
+
+
+def normalize_http_response(value: object) -> dict:
+ """Canonical ErrorDetail handshake block: three optional fields only."""
+ if not isinstance(value, dict):
+ raise TypeError("ErrorDetail.http_response must be an object")
+ if set(value) - {"request_id", "retry_after", "rate_limit_headers"}:
+ raise ValueError("unknown ErrorDetail.http_response field")
+ out = {}
+ request_id = value.get("request_id")
+ if request_id is not None:
+ if not isinstance(request_id, str) or not request_id:
+ raise ValueError("http_response.request_id must be a non-empty string")
+ out["request_id"] = request_id
+ wait = value.get("retry_after")
+ if wait is not None:
+ if isinstance(wait, bool) or not isinstance(wait, (int, float)) or not math.isfinite(wait) or wait < 0:
+ raise ValueError("http_response.retry_after must be finite nonnegative seconds")
+ out["retry_after"] = float(wait)
+ if "rate_limit_headers" in value:
+ headers = value["rate_limit_headers"]
+ if not isinstance(headers, dict) or any(not isinstance(v, (list, tuple)) or any(not isinstance(s, str) for s in v) for v in headers.values()):
+ raise TypeError("http_response.rate_limit_headers must map names to string arrays")
+ snapshot = freeze_rate_limits(headers)
+ if snapshot:
+ out["rate_limit_headers"] = {k: list(v) for k, v in snapshot.items()}
+ return out
+
+
+def diagnostics_text(snapshot: Mapping[str, Sequence[str]], retry_after: float | None) -> str:
+ pieces = []
+ if isinstance(retry_after, (int, float)) and not isinstance(retry_after, bool) and math.isfinite(retry_after) and retry_after >= 0:
+ pieces.append(f"Retry advice: {retry_after:g} seconds (not a guarantee).")
+ if snapshot:
+ raw = json.dumps(dict(snapshot), sort_keys=True, ensure_ascii=True)
+ if len(raw) > 2048:
+ raw = raw[:2048] + "... [full retained values in rate_limit_headers]"
+ pieces.append("Provider rate-limit headers (raw; advisory): " + raw)
+ return "\n\n " + "\n ".join(pieces) if pieces else ""
diff --git a/dspy/_vendor/lm15/registry.py b/dspy/_vendor/lm15/registry.py
index ff8051093..d17ee5ca8 100644
--- a/dspy/_vendor/lm15/registry.py
+++ b/dspy/_vendor/lm15/registry.py
@@ -67,12 +67,14 @@ from .providers import (
AsyncOpenAIChatLM,
AsyncOpenAICodexLM,
AsyncOpenAILM,
+ AsyncTypeSafeLM,
AsyncXaiLM,
ClaudeCodeLM,
GeminiLM,
OpenAIChatLM,
OpenAICodexLM,
OpenAILM,
+ TypeSafeLM,
XaiLM,
)
@@ -87,7 +89,7 @@ __all__ = [
# The wire formats lm15 speaks. A dialect is a class; a provider is a
# dialect plus an access policy (plus a compat preset for the chat dialect).
-Dialect = Literal["openai-responses", "openai-chat", "anthropic", "gemini"]
+Dialect = Literal["openai-responses", "openai-chat", "anthropic", "gemini", "typesafe"]
# A compat value: a preset name for a registry entry (validated against
# the dialect's table below), or the object itself for a declared entry.
@@ -413,6 +415,11 @@ _DEFINITIONS: tuple[ProviderDefinition, ...] = (
console_url="https://console.x.ai",
note="xAI Grok (Chat Completions dialect; XAI_API_KEY or subscription OAuth)",
),
+ _adapter_owned(
+ "typesafe", "typesafe", TypeSafeLM, AsyncTypeSafeLM,
+ console_url="https://console.typesafe.ai/keys",
+ note="TypeSafe System One (Jev): judgments over declared keys with probabilities; no text generation",
+ ),
_adapter_owned(
"claude-code", "anthropic", ClaudeCodeLM, AsyncClaudeCodeLM,
note="Claude subscription through the local `claude` CLI login",
@@ -487,17 +494,17 @@ _DEFINITIONS: tuple[ProviderDefinition, ...] = (
_hosted(
_access.AZURE, "openai-responses", OpenAILM, AsyncOpenAILM,
console_url="https://portal.azure.com/",
- note="Azure OpenAI v1 Responses wire ({resource}.openai.azure.com; model = deployment name; api-key or Entra token)",
+ note="Azure OpenAI v1 Responses wire ({resource}.openai.azure.com, or AZURE_OPENAI_ENDPOINT = the Foundry root the console shows; model = deployment name; api-key or Entra token)",
),
_hosted(
_access.AZURE_CHAT, "openai-chat", OpenAIChatLM, AsyncOpenAIChatLM, compat="openai",
console_url="https://portal.azure.com/",
- note="Azure OpenAI v1 Chat Completions wire (same resource; also Foundry-sold models such as DeepSeek and Grok)",
+ note="Azure OpenAI v1 Chat Completions wire (same resource or AZURE_OPENAI_ENDPOINT; also Foundry-sold models such as DeepSeek, Kimi and Grok)",
),
_hosted(
_access.AZURE_ANTHROPIC, "anthropic", AnthropicLM, AsyncAnthropicLM,
console_url="https://ai.azure.com/",
- note="Claude in Microsoft Foundry ({resource}.services.ai.azure.com/anthropic; api-key, x-api-key or Entra token)",
+ note="Claude in Microsoft Foundry ({resource}.services.ai.azure.com/anthropic or ANTHROPIC_FOUNDRY_BASE_URL; x-api-key or Entra token)",
),
_hosted(
_access.AWS_ANTHROPIC, "anthropic", AnthropicLM, AsyncAnthropicLM,
diff --git a/dspy/_vendor/lm15/result.py b/dspy/_vendor/lm15/result.py
index bc117decb..ebab452aa 100644
--- a/dspy/_vendor/lm15/result.py
+++ b/dspy/_vendor/lm15/result.py
@@ -258,10 +258,12 @@ class StreamAccumulator:
elif finish == "stop" and has_tool_calls:
finish = "tool_call"
+ from .judgments import replace_text_with_data, request_judgments
+ answer_parts = replace_text_with_data(parts, request_judgments(self.request))
return Response(
id=self.started_id,
model=self.started_model or self.request.model,
- message=Message(role="assistant", parts=tuple(parts), continuation=tuple(self.message_continuation)),
+ message=Message(role="assistant", parts=answer_parts, continuation=tuple(self.message_continuation)),
finish_reason=finish,
usage=self.usage or Usage(),
logprobs=tuple(self.logprob_seq) if self.logprob_seq else None,
@@ -1148,7 +1150,17 @@ def _exception_from_error(event: StreamEvent) -> Exception:
message = err.message
exc_cls = error_class_for_code(code)
if issubclass(exc_cls, LM15Error):
- return exc_cls(message, provider_code=err.provider_code)
+ import math
+
+ http = err.http_response
+ http = http if isinstance(http, dict) else {}
+ wait = http.get("retry_after")
+ if not isinstance(wait, (int, float)) or isinstance(wait, bool) or not math.isfinite(wait) or wait < 0:
+ wait = None
+ request_id = http.get("request_id")
+ return exc_cls(message, provider_code=err.provider_code,
+ request_id=request_id if isinstance(request_id, str) else None,
+ retry_after=wait, rate_limit_headers=http.get("rate_limit_headers"))
return exc_cls(message)
diff --git a/dspy/_vendor/lm15/router.py b/dspy/_vendor/lm15/router.py
index b281e86c4..28775a789 100644
--- a/dspy/_vendor/lm15/router.py
+++ b/dspy/_vendor/lm15/router.py
@@ -141,6 +141,7 @@ DEFAULT_RULES: tuple[RouteRule, ...] = (
RouteRule("sora-", "openai", note="OpenAI Sora video generation"),
RouteRule("veo-", "gemini", note="Google Veo video generation"),
RouteRule("chat-latest", "openai", note="OpenAI rolling chat alias (live /models listing 2026-09-01)"),
+ RouteRule("jev-", "typesafe", note="TypeSafe Jev (live /v1/models listing 2026-09-17: jev-latest, jev-preview; versioned ids jev-1.13.0 accepted)"),
)
@@ -308,17 +309,19 @@ def _check_provider_keyed(config: RouterConfig, adapters: Mapping[str, type]) ->
import difflib
known = sorted(set(adapters) | _bound_ids(adapters))
- for field_name in ("api_keys", "base_urls", "settings"):
+ for field_name in ("api_keys", "base_urls", "settings", "credentials"):
mapping = getattr(config, field_name)
if not mapping:
continue
seen: set[str] = set()
for key in mapping:
provider = _canonical_provider(key)
- if field_name == "api_keys" and provider in seen:
- raise NotConfiguredError(f"RouterConfig(api_keys=...): duplicate spellings for {provider!r}; use one entry")
+ if field_name in ("api_keys", "credentials") and provider in seen:
+ raise NotConfiguredError(f"RouterConfig({field_name}=...): duplicate spellings for {provider!r}; use one entry")
seen.add(provider)
if provider in known:
+ if field_name == "credentials":
+ _check_named_credential(config, provider, mapping[key], adapters)
continue
close = difflib.get_close_matches(provider, known, n=1, cutoff=0.6)
hint = f" Did you mean {close[0]!r}?" if close else ""
@@ -445,9 +448,28 @@ class RouterConfig:
``base_urls`` maps provider string -> the URL the provider's LM is
built with, replacing the adapter's (or the preset's) default: a
- proxy in front of OpenAI, a vLLM server on another port. Not for
- the cloud doors (azure, bedrock, vertex): their URL is derived from
- ``settings`` (resource, region), and an entry for one is refused.
+ proxy in front of OpenAI, a vLLM server on another port. On a cloud
+ door (azure, bedrock, vertex) the entry is the endpoint root — what
+ the console shows (``https://acct.services.ai.azure.com``), a private
+ endpoint, a gateway, a sovereign cloud — and the door appends its own
+ path (``/openai/v1``, ``/anthropic/v1``) unless the URL already ends
+ with it; the door's auth scheme, error mapping and doctor stay
+ attached. Without an entry the vendor's own variable is read
+ (``AZURE_OPENAI_ENDPOINT``, ``ANTHROPIC_FOUNDRY_BASE_URL``,
+ ``AWS_ENDPOINT_URL_BEDROCK_RUNTIME`` / ``AWS_ENDPOINT_URL``), then the
+ URL is built from ``settings`` (resource, region). With an endpoint,
+ ``resource`` is not needed; ``region`` still is on AWS (it signs).
+
+ ``credentials`` maps a cloud provider string -> one named identity:
+ ``"platform"`` (the machine's own: managed identity, instance or task
+ role, attached service account), ``"workload"`` (the federated
+ Kubernetes kind), ``"environment"`` (a service principal or static
+ keys from env variables), ``"cli"`` (``az`` / ``aws`` / ``gcloud``
+ sign-in). That rung only is used and the cloud's chain is not walked:
+ an absent named identity is a ``NotConfiguredError`` at construction,
+ never a fall-through to a developer login (spec/auth.md AUTH-1, amended
+ 2026-09-19). An ``api_keys`` entry and a ``credentials`` entry for
+ the same provider is refused: two answers to "who am I".
``providers`` declares providers the registry does not list — a
gateway, a service lm15 has not receipted — as
@@ -478,6 +500,9 @@ class RouterConfig:
# env variables in order, then its default; region and resource have
# none and raise.
settings: Mapping[str, Mapping[str, str]] | None = field(default=None, kw_only=True)
+ # Named cloud identities per provider (AUTH-1, amended 2026-09-19):
+ # {"azure": "platform"}. See the class docstring.
+ credentials: Mapping[str, str] | None = field(default=None, kw_only=True)
transport: object | None = None # SyncTransport for LMRouter, AsyncTransport
# for AsyncLMRouter; passed to every LM the
# router constructs (tests, custom pooling)
@@ -492,6 +517,16 @@ class RouterConfig:
def __post_init__(self) -> None:
check_policy(self.adaptations)
_check_declared(self.providers)
+ if self.credentials is not None:
+ from .features import NAMED_CREDENTIALS
+
+ for key, name in self.credentials.items():
+ if name not in NAMED_CREDENTIALS:
+ raise NotConfiguredError(
+ f"RouterConfig(credentials={{{key!r}: {name!r}}}): not a named credential; one of "
+ + ", ".join(repr(n) for n in NAMED_CREDENTIALS)
+ + ". A credential VALUE (a key, a token, a callable) goes in api_keys=."
+ )
if self.timeouts is not None and not isinstance(self.timeouts, Timeouts):
raise TypeError(
f"RouterConfig(timeouts=...) takes lm15.Timeouts, got {type(self.timeouts).__name__}; "
@@ -801,6 +836,53 @@ def _base_url_entry(config: RouterConfig, provider: str) -> str | None:
return None
+def _credentials_entry(config: RouterConfig, provider: str) -> str | None:
+ """The named credential for a provider (AUTH-1), matching either spelling."""
+ if config.credentials is None:
+ return None
+ for key, value in config.credentials.items():
+ if _canonical_provider(key) == provider:
+ return value
+ return None
+
+
+def _check_named_credential(config: RouterConfig, provider: str, name: str, adapters: Mapping[str, type]) -> None:
+ """A ``credentials`` entry names an identity on a cloud door only, and
+ never alongside an ``api_keys`` entry for the same provider."""
+ definition = _bound(provider, adapters)
+ if definition is None or not definition.access.cloud_chain:
+ raise NotConfiguredError(
+ f"RouterConfig(credentials={{{provider!r}: {name!r}}}): {provider!r} is not a cloud door; named "
+ "credentials (platform, workload, environment, cli) exist on the azure, bedrock and vertex doors. "
+ "Pass this provider's credential in api_keys=.",
+ )
+ if _api_keys_source(config, provider, adapters) is not None:
+ raise NotConfiguredError(
+ f"RouterConfig: both api_keys and credentials name {provider!r}; a door has one identity — pass the "
+ "credential value (api_keys) or name the identity (credentials), not both.",
+ )
+
+
+def _hosted_endpoint(config: RouterConfig, provider: str, definition: "ProviderDefinition") -> str | None:
+ """The endpoint root for a cloud door: the explicit ``base_urls`` entry,
+ else the vendor's own variable (AUTH-10, amended 2026-09-19)."""
+ from .cloud.hosts import endpoint_from_env
+
+ explicit = _base_url_entry(config, provider)
+ if explicit is not None:
+ return explicit
+ env = config.env if config.env is not None else os.environ
+ return endpoint_from_env(definition.access.host, env)
+
+
+def _set_origin(lm: object, label: str) -> None:
+ """Stamp the provenance label on a built LM (and its inner sync adapter
+ for the async mirrors)."""
+ for target in (lm, getattr(lm, "_inner", None)):
+ if target is not None and hasattr(target, "_credential_origin"):
+ target._credential_origin = label
+
+
def _env_key_for(provider: str, config: RouterConfig, adapters: Mapping[str, type]) -> str | None:
"""WHICH env var lm() would read for this provider (never the value).
@@ -830,23 +912,19 @@ def _build_lm(resolution: Resolution, config: RouterConfig, adapters: Mapping[st
extra["transport"] = config.transport
if config.adaptations != "note":
extra["adaptations"] = config.adaptations
- base_url = _base_url_entry(config, resolution.provider)
+ hosted = definition is not None and definition.hosted
+ base_url = _hosted_endpoint(config, resolution.provider, definition) if hosted else _base_url_entry(config, resolution.provider)
if base_url is not None:
- if definition is not None and definition.hosted:
- raise NotConfiguredError(
- f"RouterConfig(base_urls={{{resolution.provider!r}: ...}}): a cloud door's URL is built from its "
- f"host settings (resource, region), not given whole; set them in "
- f"RouterConfig(settings={{{resolution.provider!r}: {{...}}}}) instead.",
- )
extra["base_url"] = base_url
policy = _credential_policy(resolution.provider, adapters)
if policy == "oauth":
return cls(**extra) # self-resolving local OAuth constructor
api_key, _ = _api_keys_entry(config, resolution.provider, adapters)
- if definition is not None and definition.hosted:
- # A cloud door (AUTH-10): host settings from config, then env, then
- # defaults; the credential from the explicit entry or, for a cloud
- # chain policy, the chain's caching provider (AUTH-1/AUTH-2).
+ if hosted:
+ # A cloud door (AUTH-10): the endpoint from config or the vendor's
+ # variable, host settings from config, then env, then defaults; the
+ # credential from the explicit entry, the named identity, or the
+ # chain's caching provider (AUTH-1/AUTH-2).
from .cloud.chains import ChainContext, credential_provider
from .cloud.hosts import resolve_settings
@@ -856,15 +934,18 @@ def _build_lm(resolution: Resolution, config: RouterConfig, adapters: Mapping[st
given = (config.settings or {}).get(resolution.provider)
ctx = ChainContext.online(env)
settings = resolve_settings(definition.access.host, given, env, provider=resolution.provider,
- profile=profile_settings(definition.access, ctx))
+ profile=profile_settings(definition.access, ctx), endpoint=base_url)
ctx.settings = settings
+ named = _credentials_entry(config, resolution.provider)
+ origin: str | None = None
if api_key is None and definition.access.cloud_chain:
- api_key = credential_provider(definition.access, ctx)
+ api_key = credential_provider(definition.access, ctx, named=named)
elif api_key is None:
for key in definition.access.env_keys:
value = env.get(key)
if value:
api_key = value
+ origin = f"env ${key} (value never shown)"
break
if api_key is None:
env_keys = definition.access.env_keys
@@ -877,20 +958,26 @@ def _build_lm(resolution: Resolution, config: RouterConfig, adapters: Mapping[st
)
if definition.compat is not None:
extra["compat"] = definition.compat
- return cls(api_key=api_key, access=definition.access, settings=settings, **extra)
+ lm = cls(api_key=api_key, access=definition.access, settings=settings, **extra)
+ if origin is not None:
+ _set_origin(lm, origin)
+ return lm
if api_key is None and policy == "oauth-unless-explicit" and cls.has_stored_credential():
# A usable stored subscription login outranks ambient env keys:
# it spends no money per token (AUTH-1, oauth-unless-explicit).
return cls(**extra) # self-resolving local OAuth constructor
+ origin: str | None = None
if api_key is None:
env = config.env if config.env is not None else os.environ
for key in _declared_env_keys(resolution.provider, adapters):
value = env.get(key)
if value:
api_key = value
+ origin = f"env ${key} (value never shown)"
break
if api_key is None and definition is not None and definition.placeholder_key is not None:
api_key = definition.placeholder_key
+ origin = "the local server's placeholder key"
if not api_key and policy == "oauth-unless-explicit":
# Nothing anywhere: the constructor raises the typed login-hint error.
return cls(**extra)
@@ -908,8 +995,12 @@ def _build_lm(resolution: Resolution, config: RouterConfig, adapters: Mapping[st
# (credential header, surfaces, base_url) and compat preset bound at
# construction. The LM then names itself by the provider (errors,
# ModelInfo.provider), not by the dialect.
- return cls(api_key=api_key, compat=definition.compat, access=definition.access, **extra)
- return cls(api_key=api_key, **extra)
+ lm = cls(api_key=api_key, compat=definition.compat, access=definition.access, **extra)
+ else:
+ lm = cls(api_key=api_key, **extra)
+ if origin is not None:
+ _set_origin(lm, origin)
+ return lm
PLANNING_KEY = "lm15-planning"
@@ -930,8 +1021,9 @@ def _build_planning_lm(resolution: Resolution, config: RouterConfig, adapters: M
extra["transport"] = transport
elif config.transport is not None:
extra["transport"] = config.transport
- base_url = _base_url_entry(config, resolution.provider)
- if base_url is not None and not (definition is not None and definition.hosted):
+ hosted = definition is not None and definition.hosted
+ base_url = _hosted_endpoint(config, resolution.provider, definition) if hosted else _base_url_entry(config, resolution.provider)
+ if base_url is not None:
extra["base_url"] = base_url
account_field = getattr(cls, "__dataclass_fields__", {}).get("account_id")
if account_field is not None and account_field.init:
@@ -946,7 +1038,7 @@ def _build_planning_lm(resolution: Resolution, config: RouterConfig, adapters: M
env = config.env if config.env is not None else os.environ
given = dict((config.settings or {}).get(resolution.provider) or {})
try:
- settings = resolve_settings(definition.access.host, given, env, provider=resolution.provider)
+ settings = resolve_settings(definition.access.host, given, env, provider=resolution.provider, endpoint=base_url)
except NotConfiguredError:
placeholders = {setting.name: given.get(setting.name) or setting.default or "planning"
for setting in definition.access.host.settings}
@@ -1161,7 +1253,8 @@ class LMRouter:
def cache(self, prefix: Request, *, ttl_seconds: int | None = None, label: str | None = None):
"""``router.cache(prefix)``: the MAP-6 door, routed by the prefix's model."""
resolution = self.resolve(prefix.model)
- return self.lm(prefix.model).cache(_routed_request(prefix, resolution), ttl_seconds=ttl_seconds, label=label)
+ cached = self.lm(prefix.model).cache(_routed_request(prefix, resolution), ttl_seconds=ttl_seconds, label=label)
+ return replace(cached, provider=resolution.provider)
# ─── the OpenAI-shaped door (api-family § Ingest) ──────────────────
@@ -1297,7 +1390,8 @@ class AsyncLMRouter:
async def cache(self, prefix: Request, *, ttl_seconds: int | None = None, label: str | None = None):
resolution = self.resolve(prefix.model)
- return await self.lm(prefix.model).cache(_routed_request(prefix, resolution), ttl_seconds=ttl_seconds, label=label)
+ cached = await self.lm(prefix.model).cache(_routed_request(prefix, resolution), ttl_seconds=ttl_seconds, label=label)
+ return replace(cached, provider=resolution.provider)
resolve_openai_chat = LMRouter.resolve_openai_chat
request_from_openai_chat = LMRouter.request_from_openai_chat
diff --git a/dspy/_vendor/lm15/serde.py b/dspy/_vendor/lm15/serde.py
index 39b82aafb..b0dd33473 100644
--- a/dspy/_vendor/lm15/serde.py
+++ b/dspy/_vendor/lm15/serde.py
@@ -19,6 +19,7 @@ from .models import (
)
from .types import (
AudioDelta,
+ DataPart,
AudioFormat,
AudioPart,
BatchEntry,
@@ -208,6 +209,17 @@ def part_to_dict(part: Part) -> dict[str, Any]:
if part.is_error:
d["is_error"] = part.is_error
+ elif isinstance(part, DataPart):
+ d["value"] = part.value # opaque, always emitted (null is a value)
+ if part.probabilities is not None:
+ # canonical data, not an opaque payload: floats stay JSON floats
+ d["probabilities"] = {
+ name: {key: float(prob) for key, prob in dist.items()}
+ for name, dist in part.probabilities.items()
+ }
+ if part.method is not None:
+ d["method"] = part.method
+
continuation = _continuation_to_json(part.continuation)
if continuation is not None:
d["continuation"] = continuation
@@ -233,6 +245,12 @@ def part_from_dict(d: dict[str, Any]) -> Part:
if t == "citation":
return CitationPart(text=d.get("text"), url=d.get("url"), title=d.get("title"), continuation=continuation)
+ if t == "data":
+ if "value" not in d:
+ raise ValueError("data part requires 'value' (null is a value; absence is not)")
+ return DataPart(value=d["value"], probabilities=d.get("probabilities"), method=d.get("method"),
+ continuation=continuation)
+
if t in ("image", "audio", "video", "document", "binary"):
cls = PART_TYPES[t]
kwargs: dict[str, Any] = {
@@ -470,6 +488,7 @@ def cached_prefix_to_dict(c: CachedPrefix) -> dict[str, Any]:
return _clean_mapping({
"prefix": request_to_dict(c.prefix),
"resource": cache_info_to_dict(c.resource) if c.resource is not None else None,
+ "provider": c.provider,
})
@@ -477,6 +496,7 @@ def cached_prefix_from_dict(d: dict[str, Any]) -> CachedPrefix:
return CachedPrefix(
prefix=request_from_dict(d["prefix"]),
resource=cache_info_from_dict(d["resource"]) if isinstance(d.get("resource"), dict) else None,
+ provider=d.get("provider"),
)
@@ -498,6 +518,7 @@ def config_to_dict(c: Config) -> dict[str, Any]:
"user_id": c.user_id,
"store": c.store, # False is data (opt-out), not emptiness — emitted
"logprobs": c.logprobs, # 0 is data (chosen-only), not emptiness — emitted
+ "probabilities": c.probabilities,
"extensions": c.extensions,
})
@@ -537,6 +558,7 @@ def config_from_dict(d: dict[str, Any]) -> Config:
user_id=d.get("user_id"),
store=d.get("store"),
logprobs=d.get("logprobs"),
+ probabilities=d.get("probabilities"),
extensions=d.get("extensions"),
)
@@ -598,6 +620,7 @@ def error_detail_to_dict(e: ErrorDetail) -> dict[str, Any]:
"code": e.code,
"message": e.message,
"provider_code": e.provider_code,
+ "http_response": e.http_response,
})
@@ -606,6 +629,7 @@ def error_detail_from_dict(d: dict[str, Any]) -> ErrorDetail:
code=d["code"],
message=d.get("message", ""),
provider_code=d.get("provider_code"),
+ http_response=d.get("http_response", {}),
)
diff --git a/dspy/_vendor/lm15/transports/_fetch.py b/dspy/_vendor/lm15/transports/_fetch.py
index c0470d6b9..2d400e1f5 100644
--- a/dspy/_vendor/lm15/transports/_fetch.py
+++ b/dspy/_vendor/lm15/transports/_fetch.py
@@ -11,12 +11,12 @@ by dropping the response before its end. Every adapter's async mirror
ones the stdlib transport would send.
What a page cannot do is not hidden here: a cross-origin request goes
-only where the server's CORS headers allow it (the browser refuses
-before any bytes leave, and ``fetch`` reports a bare ``TypeError`` with
-no status — surfaced as :class:`TransportError` naming that
-possibility); a separate connect timeout does not exist (``fetch`` has
-one signal); there is no proxy configuration. The TypeScript port's
-``docs/browser.md`` states the same line.
+only where the server's CORS headers allow it (a refusal can happen
+AFTER the server served the request; ``fetch`` reports a bare
+``TypeError`` with no status — surfaced as :class:`TransportError`
+naming that possibility). Separate socket connect/write deadlines,
+pool limits, and proxy configuration are controlled by the host, not us.
+The TypeScript port's ``docs/browser.md`` describes these host limitations.
"""
from __future__ import annotations
@@ -24,7 +24,9 @@ from __future__ import annotations
import asyncio
from typing import Any, AsyncIterator
-from ._exceptions import TransportError
+from ._exceptions import ReadTimeout, TransportError
+from ._http11 import content_codings
+from ._timeouts import wait_for
from ._types import AsyncTransportResponse, TransportRequest
try: # the host bridge exists only under Pyodide
@@ -50,9 +52,11 @@ class FetchTransport:
"""The :class:`AsyncTransport` over the host's ``fetch``.
``fetch`` may be given (a test double, a wrapped ``fetch``); by default
- it is the host's global. ``read_timeout`` bounds the wait for each body
- chunk, as the stdlib transport's does; a request's own
- ``read_timeout`` overrides it.
+ it is the host's global. ``read_timeout`` bounds the initial fetch
+ (through response headers) and each body chunk, not the whole response.
+ A request's explicit ``read_timeout`` overrides it. The host decodes
+ compression; visible Content-Encoding is checked against INV-053, never
+ inflated again. CORS-hidden headers cannot be checked.
"""
def __init__(self, *, fetch: Any = None, read_timeout: float = DEFAULT_READ_TIMEOUT) -> None:
@@ -60,39 +64,78 @@ class FetchTransport:
self._fetch = fetch if fetch is not None else _js.fetch
self._read_timeout = read_timeout
self._closed = False
+ self._controllers: dict[int, Any] = {}
+ self._responses: dict[int, AsyncTransportResponse] = {}
def stream(self, request: TransportRequest) -> "_FetchStreamCM":
return _FetchStreamCM(self, request)
async def aclose(self) -> None:
self._closed = True
+ for controller in tuple(self._controllers.values()):
+ controller.abort()
+ self._controllers.clear()
+ for response in tuple(self._responses.values()):
+ await response.aclose()
async def _do_stream(self, request: TransportRequest) -> AsyncTransportResponse:
if self._closed:
raise TransportError("transport is closed")
- if request.connect_timeout is not None:
- raise TransportError("fetch has no separate connect timeout; leave connect_timeout unset")
+ for name in ("connect_timeout", "write_timeout"):
+ if getattr(request, name) is not None:
+ raise TransportError(f"fetch has no separate {name}; leave {name} unset")
+ read_timeout = self._read_timeout if request.read_timeout is None else request.read_timeout
controller = _js.AbortController.new()
- headers = _js.Headers.new()
- for name, value in request.headers:
- headers.append(name, value)
- options: dict[str, Any] = {"method": request.method, "headers": headers, "signal": controller.signal}
- if request.body:
- options["body"] = to_js(request.body)
+ self._controllers[id(controller)] = controller
+ reader = None
+
+ async def host_wait(awaitable):
+ # Abort BEFORE draining cancellation. asyncio.wait distinguishes
+ # caller cancellation even when the host promise resolves at once.
+ task = asyncio.ensure_future(awaitable)
+ try:
+ done, _ = await asyncio.wait((task,), timeout=read_timeout)
+ if not done:
+ raise asyncio.TimeoutError()
+ return task.result()
+ except BaseException:
+ controller.abort()
+ task.cancel()
+ await asyncio.gather(task, return_exceptions=True)
+ raise
+
try:
- response = await self._fetch(request.url, to_js(options, dict_converter=_js.Object.fromEntries))
- except Exception as exc: # a JS TypeError: network, or the browser's CORS refusal — fetch does not say which
- raise TransportError(
- f"{request.method} {request.url.split('?', 1)[0]}: fetch failed ({_message(exc)}); "
- "a browser reports a CORS refusal and a network failure the same way"
- ) from exc
-
- header_pairs: list[tuple[str, str]] = []
- for pair in response.headers.entries():
- header_pairs.append((str(pair[0]), str(pair[1])))
- read_timeout = request.read_timeout or self._read_timeout
- reader = response.body.getReader() if response.body is not None else None
- state = {"consumed": False}
+ headers = _js.Headers.new()
+ for name, value in request.headers:
+ headers.append(name, value)
+ if not any(name.lower() == "accept-encoding" for name, _ in request.headers):
+ # Browsers may silently strip this forbidden request header.
+ headers.append("Accept-Encoding", "identity")
+ options: dict[str, Any] = {"method": request.method, "headers": headers, "signal": controller.signal}
+ if request.body:
+ options["body"] = to_js(request.body)
+ try:
+ response = await host_wait(self._fetch(request.url, to_js(options, dict_converter=_js.Object.fromEntries)))
+ except asyncio.TimeoutError as exc:
+ raise ReadTimeout(f"response headers timed out: {read_timeout_hint(read_timeout)}") from exc
+ except Exception as exc:
+ raise TransportError(
+ f"{request.method} {request.url.split('?', 1)[0]}: fetch failed ({_message(exc)}); "
+ "a browser reports a CORS refusal and a network failure the same way"
+ ) from exc
+
+ header_pairs = [(str(pair[0]), str(pair[1])) for pair in response.headers.entries()]
+ # Fetch already decoded the body, even when it retains the coding
+ # header. Enforce the allowed vocabulary only; do not double inflate.
+ content_codings([v for k, v in header_pairs if k.lower() == "content-encoding"])
+ status = int(response.status)
+ reason = str(response.statusText or "")
+ reader = response.body.getReader() if response.body is not None else None
+ except BaseException:
+ controller.abort()
+ self._controllers.pop(id(controller), None)
+ raise
+ state = {"consumed": reader is None}
async def chunks() -> AsyncIterator[bytes]:
if reader is None:
@@ -100,10 +143,9 @@ class FetchTransport:
return
while True:
try:
- result = await asyncio.wait_for(reader.read(), read_timeout)
+ result = await host_wait(reader.read())
except asyncio.TimeoutError as exc:
- controller.abort()
- raise TransportError(f"response body read timed out: {read_timeout_hint(read_timeout)}") from exc
+ raise ReadTimeout(f"response body read timed out: {read_timeout_hint(read_timeout)}") from exc
except Exception as exc:
raise TransportError(f"response body read failed ({_message(exc)})") from exc
if result.done:
@@ -112,24 +154,35 @@ class FetchTransport:
yield bytes(result.value.to_py())
async def release(body_consumed: bool) -> None:
- # Dropping the response before its end cancels the request: the
- # socket closes, the server sees it (the browser smoke checks this).
- if not (body_consumed or state["consumed"]):
- controller.abort()
+ # Abort cancels host work, not a guarantee the server stops billing.
+ # Release the reader lock on success too, and forget ownership once.
+ try:
+ if not (body_consumed or state["consumed"]):
+ controller.abort()
+ if reader is not None:
+ try:
+ await wait_for(reader.cancel(), read_timeout)
+ except Exception:
+ pass
+ finally:
+ self._controllers.pop(id(controller), None)
+ self._responses.pop(id(controller), None)
if reader is not None:
try:
- await reader.cancel()
+ reader.releaseLock()
except Exception:
pass
- return AsyncTransportResponse(
- status=int(response.status),
- reason=str(response.statusText or ""),
+ result = AsyncTransportResponse(
+ status=status,
+ reason=reason,
headers=header_pairs,
http_version="HTTP/1.1", # fetch does not expose the negotiated version
chunks=chunks(),
release=release,
)
+ self._responses[id(controller)] = result
+ return result
class _FetchStreamCM:
diff --git a/dspy/_vendor/lm15/types.py b/dspy/_vendor/lm15/types.py
index f941f5257..3163d4a3c 100644
--- a/dspy/_vendor/lm15/types.py
+++ b/dspy/_vendor/lm15/types.py
@@ -70,10 +70,19 @@ PartType = Literal[
"thinking",
"refusal",
"citation",
+ "data",
]
ContinuationKind: TypeAlias = str
+# Judgments (changes/2026-09-17-judgments.md). ``Config.probabilities``
+# asks for a distribution over the keys a json_schema declares (MAP-14);
+# ``DataPart.method`` says how a delivered distribution was measured.
+ProbabilityPolicy = Literal["off", "if_available", "required"]
+PROBABILITY_POLICIES: tuple[str, ...] = get_args(ProbabilityPolicy)
+JudgmentMethod = Literal["provider_classification", "candidate_sequence_likelihood"]
+JUDGMENT_METHODS: tuple[str, ...] = get_args(JudgmentMethod)
+
# FinishReason values are a separate namespace from PartType values even when
# a token such as "tool_call" appears in both.
FinishReason = Literal["stop", "length", "tool_call", "content_filter", "error"]
@@ -662,6 +671,7 @@ class ToolResultPart:
"ToolResultPart.content cannot contain tool calls, nested tool "
"results, thinking parts, or refusals"
)
+ _validate_input_data_parts("tool results", self.content)
_validate_continuation_field(self)
@@ -721,6 +731,60 @@ class CitationPart:
_validate_continuation_field(self)
+def _validate_probabilities(value: Any, *, field_name: str) -> None:
+ """INV-052: ``{field: {key: float}}``, inner maps non-empty, floats in [0, 1]."""
+ if not isinstance(value, dict) or not value:
+ raise TypeError(f"{field_name} must be a non-empty mapping of field -> {{key: probability}}")
+ for name, dist in value.items():
+ if not isinstance(name, str) or not name:
+ raise TypeError(f"{field_name} keys must be non-empty strings")
+ if not isinstance(dist, dict) or not dist:
+ raise TypeError(f"{field_name}[{name!r}] must be a non-empty mapping of key -> probability")
+ for key, prob in dist.items():
+ if not isinstance(key, str) or not key:
+ raise TypeError(f"{field_name}[{name!r}] keys must be non-empty strings")
+ if isinstance(prob, bool) or not isinstance(prob, (int, float)):
+ raise TypeError(f"{field_name}[{name!r}][{key!r}] must be a number")
+ if not (0.0 <= float(prob) <= 1.0) or not _math.isfinite(float(prob)):
+ raise ValueError(f"{field_name}[{name!r}][{key!r}] must be in [0, 1]")
+
+
+@dataclass(frozen=True, slots=True)
+class DataPart:
+ """Structured data as content (changes/2026-09-17-judgments.md, D2).
+
+ In a user/system message: structured input (a provider that reads
+ JSON state takes ``value`` as such; a text-only wire gets it as JSON
+ text). In an assistant message: the answer to a ``json_schema``
+ request that declares judgments (MAP-14) — ``value`` is the model's
+ JSON object, ``probabilities`` a distribution per judgment over its
+ declared keys when one was measured, ``method`` how (JudgmentMethod).
+ ``value`` is an opaque payload: any JSON value, verbatim (INV-002).
+ """
+
+ value: JsonValue
+ probabilities: dict[str, dict[str, float]] | None = None
+ method: JudgmentMethod | None = None
+ continuation: tuple[ContinuationState, ...] = ()
+ type: Literal["data"] = field(default="data", init=False)
+
+ def __post_init__(self) -> None:
+ if not _is_json_value(self.value):
+ raise TypeError("DataPart.value must be a JSON-compatible value")
+ if self.probabilities is not None:
+ _validate_probabilities(self.probabilities, field_name="DataPart.probabilities")
+ normalized = {
+ name: {key: float(prob) for key, prob in dist.items()}
+ for name, dist in self.probabilities.items()
+ }
+ object.__setattr__(self, "probabilities", normalized)
+ if self.method is not None and self.method not in JUDGMENT_METHODS:
+ raise ValueError(f"DataPart.method must be one of {JUDGMENT_METHODS}, got {self.method!r}")
+ if (self.method is None) != (self.probabilities is None):
+ raise ValueError("DataPart.method is present iff DataPart.probabilities is (INV-052)")
+ _validate_continuation_field(self)
+
+
_TOOL_RESULT_FORBIDDEN_PARTS: tuple[type, ...] = (
ToolCallPart,
ToolResultPart,
@@ -742,6 +806,7 @@ Part: TypeAlias = (
| ThinkingPart
| RefusalPart
| CitationPart
+ | DataPart
)
# Runtime dispatch table, derived from the union so adding a Part variant has
@@ -770,7 +835,7 @@ ProviderData: TypeAlias = JsonObject
# (ToolCallPart, ToolResultPart, ThinkingPart, and RefusalPart are excluded
# both at the type level and in ``ToolResultPart.__post_init__``.)
ToolResultContentPart: TypeAlias = (
- TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | BinaryPart | CitationPart
+ TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | BinaryPart | CitationPart | DataPart
)
ToolResultContent: TypeAlias = str | ToolResultContentPart | Sequence[str | ToolResultContentPart]
@@ -778,7 +843,7 @@ ToolResultContent: TypeAlias = str | ToolResultContentPart | Sequence[str | Tool
# Excludes model/tool protocol parts which are produced by the model or
# tool runtime, never authored by the caller.
PromptPart: TypeAlias = (
- TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | BinaryPart
+ TextPart | ImagePart | AudioPart | VideoPart | DocumentPart | BinaryPart | DataPart
)
PromptContent: TypeAlias = str | PromptPart | Sequence[str | PromptPart]
SystemContent: TypeAlias = PromptContent
@@ -797,6 +862,7 @@ AssistantPart: TypeAlias = (
| ThinkingPart
| RefusalPart
| CitationPart
+ | DataPart
)
AssistantContent: TypeAlias = str | AssistantPart | Sequence[str | AssistantPart]
@@ -848,6 +914,18 @@ def citation(
return CitationPart(url=url, title=title, text=text, continuation=_normalize_continuation(continuation))
+def data(
+ value: JsonValue,
+ *,
+ probabilities: dict[str, dict[str, float]] | None = None,
+ method: JudgmentMethod | None = None,
+ continuation: Sequence[ContinuationState] | ContinuationState | None = None,
+) -> DataPart:
+ """Create a data part (structured input, or a judged answer)."""
+ return DataPart(value=value, probabilities=probabilities, method=method,
+ continuation=_normalize_continuation(continuation))
+
+
def _encode_data(data: bytes | str) -> str:
"""Ensure data is a base64 string."""
if isinstance(data, bytes):
@@ -1230,6 +1308,14 @@ def _validate_message_parts(role: Role, parts: tuple[Part, ...]) -> None:
# protocol parts and not model-emitted artifacts like citations.
if any(isinstance(p, _PROMPT_FORBIDDEN_PARTS) for p in parts):
raise TypeError(f"{role} messages cannot contain model/tool protocol parts")
+ _validate_input_data_parts(role, parts)
+
+
+def _validate_input_data_parts(where: str, parts: tuple[Part, ...]) -> None:
+ """INV-052: a distribution is a claim about an answer; input carries value alone."""
+ for p in parts:
+ if isinstance(p, DataPart) and p.probabilities is not None:
+ raise TypeError(f"{where} data parts carry value only; probabilities belong to assistant messages (INV-052)")
def _normalize_system(system: SystemContent | None) -> str | tuple[PromptPart, ...] | None:
@@ -1242,6 +1328,7 @@ def _normalize_system(system: SystemContent | None) -> str | tuple[PromptPart, .
parts = _normalize_parts(system)
if any(isinstance(p, _PROMPT_FORBIDDEN_PARTS) for p in parts):
raise TypeError("system parts cannot contain model/tool protocol parts")
+ _validate_input_data_parts("system", parts)
return parts
@@ -1446,7 +1533,7 @@ DELTA_TYPES: dict[str, type] = {_variant_type(cls): cls for cls in DELTA_CLASSES
# variants (currently ContinuationDelta) carry stream metadata that attaches to
# a Message or Part rather than materializing as content.
StreamablePart: TypeAlias = TextPart | ThinkingPart | ImagePart | AudioPart | ToolCallPart | CitationPart
-NonStreamablePart: TypeAlias = VideoPart | DocumentPart | BinaryPart | ToolResultPart | RefusalPart
+NonStreamablePart: TypeAlias = VideoPart | DocumentPart | BinaryPart | ToolResultPart | RefusalPart | DataPart
_STREAMABLE_PART_CLASSES: tuple[type, ...] = get_args(StreamablePart)
_NON_STREAMABLE_PART_CLASSES: tuple[type, ...] = get_args(NonStreamablePart)
@@ -1492,8 +1579,13 @@ class ErrorDetail:
code: ErrorCode
message: str
provider_code: str | None = None
+ # Bounded handshake diagnostics; absent means no HTTP evidence, not success.
+ http_response: JsonObject = field(default_factory=dict)
def __post_init__(self) -> None:
+ from .rate_limits import normalize_http_response
+
+ object.__setattr__(self, "http_response", normalize_http_response(self.http_response))
if self.code not in ERROR_CODES:
raise ValueError(f"unsupported error code: {self.code}")
_validate_text(self.message, field_name="ErrorDetail.message")
@@ -1820,6 +1912,11 @@ class Config:
# own InvalidRequestError. Providers without logprobs (Anthropic)
# RAISE — never silently drop.
logprobs: int | None = None
+ # probabilities: ask for a distribution over the keys the json_schema
+ # declares (MAP-14). None = off. "if_available": a wire that cannot
+ # measure one records `dropped`; "required": it refuses before the
+ # wire (changes/2026-09-17-judgments.md, D3).
+ probabilities: ProbabilityPolicy | None = None
extensions: Extensions | None = None
def __post_init__(self) -> None:
@@ -1868,6 +1965,8 @@ class Config:
_validate_non_negative(self.logprobs, field_name="logprobs")
_validate_json_field(self, "response_format")
_validate_response_format_shape(self.response_format)
+ if self.probabilities is not None and self.probabilities not in PROBABILITY_POLICIES:
+ raise ValueError(f"Config.probabilities must be one of {PROBABILITY_POLICIES}, got {self.probabilities!r}")
_validate_extensions_field(self)
@@ -2226,6 +2325,43 @@ class Response:
def tool_calls(self) -> list[ToolCallPart]:
return self.message.parts_of(ToolCallPart)
+ # ─── Judgments (changes/2026-09-17-judgments.md D12) ──────────────
+
+ @property
+ def data(self) -> Any:
+ """The answer of a judgment request: the DataPart's value.
+
+ Falls back to the parsed JSON text of a plain structured-output
+ response (``json``) so ``response.data`` reads the same on a wire
+ that answered with text; ``None`` when there is neither.
+ """
+ part = self.message.first(DataPart)
+ if part is not None:
+ return part.value
+ return self.json
+
+ @property
+ def probabilities(self) -> dict[str, dict[str, float]] | None:
+ """Per-judgment distributions over the declared keys, or None when
+ none was measured (never a fabricated one)."""
+ part = self.message.first(DataPart)
+ return None if part is None else part.probabilities
+
+ @property
+ def method(self) -> str | None:
+ part = self.message.first(DataPart)
+ return None if part is None else part.method
+
+ def expected(self, field_name: str) -> float | None:
+ """Σ p·i over an ordered judgment's levels (Jev's ``score``), or None."""
+ dist = (self.probabilities or {}).get(field_name)
+ if not dist:
+ return None
+ try:
+ return sum(float(p) * int(k) for k, p in dist.items())
+ except ValueError:
+ return None
+
@property
def citations(self) -> list[CitationPart]:
return self.message.parts_of(CitationPart)
@@ -2447,7 +2583,10 @@ class CachedPrefix:
the reusable part (its config must be default: a cached object has no
temperature). ``resource`` is the stored object on providers with
that tier, ``None`` on providers that mark blocks or cache
- automatically. ``request(messages)`` builds a Request that appends
+ automatically. Optional ``provider`` preserves a router destination;
+ prefix/resource models remain wire names, while suffix requests use
+ ``provider:wiremodel``. Reuse with the same router configuration/account.
+ ``request(messages)`` builds a Request that appends
``messages`` and sets the cache boundary at the seam; ``cached +
messages`` is Python sugar for it. The built Request and its wire
bytes are what the contract pins; the sugar is per-language.
@@ -2455,8 +2594,15 @@ class CachedPrefix:
prefix: Request
resource: CacheInfo | None = None
+ provider: str | None = field(default=None, kw_only=True)
def __post_init__(self) -> None:
+ if self.provider is not None:
+ if not isinstance(self.provider, str):
+ raise TypeError("CachedPrefix.provider must be a string")
+ if not self.provider or any(c.isspace() or c in ":/" for c in self.provider):
+ raise ValueError("CachedPrefix.provider must be a non-empty provider name without routing separators")
+ object.__setattr__(self, "provider", self.provider.replace("_", "-"))
if not isinstance(self.prefix, Request):
raise TypeError("CachedPrefix.prefix must be a Request")
if self.prefix.config != Config():
@@ -2495,9 +2641,12 @@ class CachedPrefix:
tools: the prefix owns those). ``config`` supplies generation
settings; its ``cache`` must be unset (the prefix decides).
"""
+ model = f"{self.provider}:{self.prefix.model}" if self.provider is not None else self.prefix.model
suffix: tuple[Message, ...]
if isinstance(messages, Request):
- if messages.model != self.prefix.model:
+ head, sep, rest = messages.model.partition(":")
+ same_route = self.provider is not None and sep and head.replace("_", "-") == self.provider and rest == self.prefix.model
+ if messages.model != self.prefix.model and not same_route:
raise ValueError("suffix Request model must equal the prefix model")
if messages.system is not None or messages.tools:
raise ValueError("suffix Request cannot redefine system or tools: the prefix owns them")
@@ -2518,7 +2667,7 @@ class CachedPrefix:
from dataclasses import replace as _replace
return Request(
- model=self.prefix.model,
+ model=model,
system=self.prefix.system,
tools=self.prefix.tools,
messages=self.prefix.messages + suffix,
@@ -2877,6 +3026,7 @@ class LiveClientTurnEvent:
raise TypeError("LiveClientTurnEvent.parts must contain Part objects")
if any(isinstance(p, _PROMPT_FORBIDDEN_PARTS) for p in self.parts):
raise TypeError("LiveClientTurnEvent.parts cannot contain model/tool protocol parts")
+ _validate_input_data_parts("live input", self.parts)
_validate_bool(self.turn_complete, field_name="LiveClientTurnEvent.turn_complete")
@@ -2932,6 +3082,7 @@ class LiveClientToolResultEvent:
raise TypeError("LiveClientToolResultEvent.content must contain Part objects")
if any(isinstance(p, _TOOL_RESULT_FORBIDDEN_PARTS) for p in self.content):
raise TypeError("LiveClientToolResultEvent.content cannot contain model or protocol parts")
+ _validate_input_data_parts("live tool results", self.content)
@dataclass(frozen=True, slots=True)
@@ -3107,6 +3258,8 @@ def _check_literal_vocabularies() -> None:
("ToolChoiceMode", set(get_args(ToolChoiceMode)), set(TOOL_CHOICE_MODES)),
("ReasoningEffort", set(get_args(ReasoningEffort)), set(REASONING_EFFORTS)),
("ReasoningSummary", set(get_args(ReasoningSummary)), set(REASONING_SUMMARIES)),
+ ("ProbabilityPolicy", set(get_args(ProbabilityPolicy)), set(PROBABILITY_POLICIES)),
+ ("JudgmentMethod", set(get_args(JudgmentMethod)), set(JUDGMENT_METHODS)),
("LiveClientEventType", set(get_args(LiveClientEventType)), {_variant_type(cls) for cls in LIVE_CLIENT_EVENT_CLASSES}),
("LiveServerEventType", set(get_args(LiveServerEventType)), {_variant_type(cls) for cls in LIVE_SERVER_EVENT_CLASSES}),
)
diff --git a/dspy/clients/call_result.py b/dspy/clients/call_result.py
index 3d96bdc42..b32fcf5e5 100644
--- a/dspy/clients/call_result.py
+++ b/dspy/clients/call_result.py
@@ -6,7 +6,7 @@ from typing import Any
from dspy._vendor.lm15.serde import response_from_dict, response_to_dict
from dspy.clients.legacy_outputs import plain, value
from dspy.clients.lm15_boundary import response_value
-from dspy.lm15 import Request, Response, TextPart, ThinkingPart
+from dspy.lm15 import DataPart, Request, Response, TextPart, ThinkingPart
CACHE_FORMAT = "dspy-lm15-result-v1"
@@ -35,7 +35,9 @@ def attributes(obj):
def legacy_output(response: Response, *, logprobs=False):
import json
- texts = [part.text for part in response.message.parts if isinstance(part, TextPart)]
+ # Adapters still consume JSON text; typed callers keep the original DataPart.
+ texts = [part.text if isinstance(part, TextPart) else json.dumps(part.value, ensure_ascii=False)
+ for part in response.message.parts if isinstance(part, (TextPart, DataPart))]
thinking = [part.text for part in response.message.parts if isinstance(part, ThinkingPart)]
output = {"text": "".join(texts) if texts else None}
if any(thinking):
diff --git a/dspy/clients/engines/stream_guard.py b/dspy/clients/engines/stream_guard.py
index 2b0f905d2..9045d05a8 100644
--- a/dspy/clients/engines/stream_guard.py
+++ b/dspy/clients/engines/stream_guard.py
@@ -7,8 +7,11 @@ from dspy.lm15 import StreamAssemblyError
def error_from_event(event, *, provider=None):
+ http = event.error.http_response
return error_class_for_code(event.error.code)(
event.error.message, provider=provider, provider_code=event.error.provider_code,
+ request_id=http.get("request_id"), retry_after=http.get("retry_after"),
+ rate_limit_headers=http.get("rate_limit_headers"),
)
diff --git a/dspy/clients/errors.py b/dspy/clients/errors.py
index ffdc62390..92ab8703e 100644
--- a/dspy/clients/errors.py
+++ b/dspy/clients/errors.py
@@ -95,6 +95,7 @@ def wrap_error(exc: Exception, *, model: str, provider: str | None = None) -> Ex
for name in (
"partial", "part_index", "env_keys", "credential_hint", "path", "lock_path",
"providers", "candidates", "rules_tried", "catalog_searched", "cleanup_errors",
+ "rate_limit_headers",
):
if name == "partial" and isinstance(exc, lm15.CollectionLimitError):
continue # Even hasattr() would evaluate its lazy partial property.
diff --git a/tests/clients/test_lm15_rc3_integration.py b/tests/clients/test_lm15_rc3_integration.py
index e8bf519b5..ba2a347ce 100644
--- a/tests/clients/test_lm15_rc3_integration.py
+++ b/tests/clients/test_lm15_rc3_integration.py
@@ -171,3 +171,74 @@ async def test_request_conversion_refusal_keeps_the_feature(asynchronous, monkey
def test_explicit_feature_list_is_preserved():
error = dspy.LMUnsupportedFeatureError("unsupported", feature="config.x", features=["custom"])
assert error.feature == "config.x" and error.features == ["custom"]
+
+
[email protected]("asynchronous", [False, True])
+async def test_judgment_response_preserves_json_prediction_and_typed_value(asynchronous, monkeypatch):
+ import json
+ from typing import Literal
+
+ from dspy._vendor.lm15.providers.base import HttpResponse
+ from dspy._vendor.lm15.providers.openai_chat import OpenAIChatLM
+ from dspy.clients.execution import _canonical, prepare
+
+ class Answer(dspy.Signature):
+ question: str = dspy.InputField()
+ accepted: bool = dspy.OutputField()
+ label: Literal["yes", "no"] = dspy.OutputField()
+
+ body = {"model": "gpt-4o", "choices": [{"index": 0, "message": {
+ "role": "assistant", "content": '{"accepted":false,"label":"yes"}',
+ }, "finish_reason": "stop"}]}
+ monkeypatch.setattr(OpenAIChatLM, "_send", lambda *args: HttpResponse(
+ status=200, reason="OK", headers=[], body=json.dumps(body).encode(),
+ ))
+ # Exercise the real native parser with a fake wire, including async mirrors.
+ from dspy._vendor.lm15.providers.async_base import AsyncOpenAIChatLM
+
+ async def send(*args):
+ return HttpResponse(status=200, reason="OK", headers=[], body=json.dumps(body).encode())
+
+ monkeypatch.setattr(AsyncOpenAIChatLM, "_send", send)
+ lm = dspy.LM("openai/gpt-4o", api_key="test", cache=False, num_retries=0)
+ with dspy.context(lm=lm, adapter=dspy.JSONAdapter()):
+ predict = dspy.Predict(Answer)
+ result = await predict.acall(question="test") if asynchronous else predict(question="test")
+ assert result.accepted is False and result.label == "yes"
+ request = _canonical(prepare(lm, "test", None, {"response_format": {
+ "type": "json_schema", "json_schema": {"name": "Answer", "schema": {
+ "type": "object", "properties": {"accepted": {"type": "boolean"}},
+ }},
+ }}))
+ response = await invoke(lm, asynchronous, request)
+ assert isinstance(response.message.parts[0], lm15.DataPart)
+ assert response.data == {"accepted": False, "label": "yes"}
+ assert CallResult.load(CallResult.native(response).dump()).responses[0] == response
+
+
[email protected]("asynchronous", [False, True])
[email protected]("streaming", [False, True])
+async def test_rate_limit_evidence_survives_public_boundary(asynchronous, streaming):
+ from dspy.clients.execution import _delay
+
+ class RateLimited(Engine):
+ def stream(self, request):
+ yield lm15.StreamErrorEvent(error=lm15.ErrorDetail(
+ code="rate_limit", message="wait", provider_code="limited",
+ http_response={"retry_after": 23, "request_id": "req-123",
+ "rate_limit_headers": {"retry-after": ["23"]}},
+ ))
+
+ engine = RateLimited(lm15.RateLimitError(
+ "wait", retry_after=23, request_id="req-123", provider_code="limited",
+ rate_limit_headers={"retry-after": ["23"]},
+ ))
+ lm = dspy.LM("custom", engine=engine, async_engine=AsyncEngine(engine), cache=False, num_retries=0)
+ with dspy.context(send_stream=Sink() if streaming else None), pytest.raises(dspy.LMRateLimitError) as caught:
+ await invoke(lm, asynchronous, "hello")
+ error = caught.value
+ assert error.request_id == "req-123" and error.provider_code == "limited"
+ assert error.retry_after == 23 and _delay(error, 0) == 23
+ assert error.rate_limit_headers == {"retry-after": ("23",)}