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.txtindex 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.gitversion=1.0.0rc3-commit=a550dab27333a1cb6a4a163c20577edab9fa872e-contract=7677980e36c8bd0b14ae9bfc79e49446f403ad22-split=8c8b885e05738b141cbc4a2691f0772966927f0c+commit=55fce2e61a04ed3193acfeb8797b7c58d1b55398+contract=b721ce4f03877d72a91431b3a5ce653ffc0b3e38+split=63b6bb319f38ad1d31060138da54cb8ac8718711diff --git a/dspy/_vendor/lm15/__init__.py b/dspy/_vendor/lm15/__init__.pyindex 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,# toolsFunctionTool,BuiltinTool,@@ -177,6 +178,7 @@ from .providers import (ClaudeCodeLM,OpenAICodexLM,XaiLM,+ TypeSafeLM,)from .providers.openai_chat import request_from_openai_chat, response_from_openai_chatfrom .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.pyindex 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 errnoimport hashlibimport jsonimport os+import statimport tempfileimport time+from collections import dequefrom contextlib import contextmanagerfrom pathlib import Pathfrom 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 excdef _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 Windowstry: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 excdef _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.pyindex 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.pyindex 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 atrequest 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 ElementTreefrom ..credentials import ApiKey, AwsCredentials, BearerToken, CredentialValue, parse_rfc3339from ..errors import AuthError, NotConfiguredError-from ..features import RUNG_KINDS, AccessPolicy+from ..features import NAMED_CREDENTIALS, RUNG_KINDS, AccessPolicyfrom . 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 = Falseif explicit:@@ -1160,7 +1305,7 @@ def explain(policy: AccessPolicy, ctx: ChainContext, *, explicit: bool) -> tupleselected = Trueelse: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) -> tuplereturn 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:continueraiseif 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 = policyself._ctx = ctx+ self._named = namedself._lock = threading.Lock()self._value: CredentialValue | None = None+ self.source: CredentialSource | None = None++ @property+ def named(self) -> str | None:+ return self._nameddef __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 = sourceif 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.pyindex 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), thendefaults. 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 thatbase URL; this applies the host's closed set of rewrites (endpoint pathoverride, model into the path, ``anthropic_version`` into the body,@@ -23,7 +28,7 @@ from __future__ import annotationsfrom dataclasses import dataclassfrom datetime import datetime, timezoneimport re-from urllib.parse import quote+from urllib.parse import quote, urlsplitfrom typing import Any, Callable, Mappingfrom ..credentials import ApiKey, AwsCredentials, CredentialValue@@ -31,7 +36,8 @@ from ..errors import NotConfiguredError, UnsupportedFeatureErrorfrom ..features import AccessPolicy, HostSpecfrom . 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.defaultif not value:+ if setting.name in relaxed:+ continuehint = 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_templatetry:- 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.pyindex 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 = Noneforced_tool_choice: OpenAIChatForcedToolChoice | None = Nonejson_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 = Noneextensions: 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 = Noneextensions: 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.pyindex 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: boolsettings: 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@propertydef 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_keysif 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_pathstep = _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_settingsdefinition = _bound_definition(canonical)policy = definition.accessenvironment = 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 Noneresolved: 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.pyindex f7c24c267..ff51751d7 100644--- a/dspy/_vendor/lm15/errors.py+++ b/dspy/_vendor/lm15/errors.py@@ -30,7 +30,9 @@ Hierarchy:from __future__ import annotationsimport builtins-from typing import TYPE_CHECKING+from typing import TYPE_CHECKING, Mapping, Sequence++from .rate_limits import diagnostics_text, freeze_rate_limitsif TYPE_CHECKING: # pragma: no coverfrom .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 = messageself.code = code or self.default_codeself.provider = provider@@ -244,11 +248,10 @@ class ProviderError(LM15Error):if item)base = self.message or self.code- if not context:- return basehead, 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 = Noneif 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.pyindex 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 everyrequest 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}")@propertydef 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.pynew file mode 100644index 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__.pyindex 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 GeminiLMfrom .openai import OpenAILMfrom .openai_chat import OpenAIChatLMfrom .openai_codex import OpenAICodexLM+from .typesafe import TypeSafeLMfrom .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.pyindex 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_APIfrom ..compat import ANTHROPIC_PRESET_BASE_URLS, AnthropicCompat, ResolvedAnthropicCompat, preset_base_url, resolve_anthropic_compatfrom ..features import ProviderManifest+from ..judgments import anthropic_schema, note_unmeasurable_probabilities, replace_text_with_data, request_judgmentsfrom ..sse import SSEEventfrom ..transports import TransportRequestfrom ..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 = Nonecredentials_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 payloaddef 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:returnpayload = 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"] = cursorreturn 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.pyindex 0c3fd381c..05441387b 100644--- a/dspy/_vendor/lm15/providers/async_base.py+++ b/dspy/_vendor/lm15/providers/async_base.py@@ -21,7 +21,8 @@ import osfrom dataclasses import dataclass, fieldfrom 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_judgmentsfrom ..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, ClaudeCodeLMfrom .gemini import GeminiLMfrom .openai import OpenAILM@@ -58,6 +62,7 @@ from .openai_codex import (DEFAULT_CODEX_ORIGINATOR,OpenAICodexLM,)+from .typesafe import TypeSafeLMfrom .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)+ raisedef 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_stopreq, 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)+ raiseexcept 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 = Noneupload_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)+ raisetexts = []- 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 Noneif 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)+ raisefetched = Noneif 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 = Noneadaptations: 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.pyindex 6ecbd2744..9f599e4bd 100644--- a/dspy/_vendor/lm15/providers/base.py+++ b/dspy/_vendor/lm15/providers/base.py@@ -3,9 +3,9 @@ from __future__ import annotationsimport jsonimport mathimport os-from dataclasses import dataclass+from dataclasses import dataclass, replacefrom 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, TypeVarif TYPE_CHECKING: # pragma: no cover - import cycle guard for annotationsfrom ..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 thedialects' 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+ returndef _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 excdef _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: strsupports: 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+@propertydef 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 forthe key), and ``base_url``: the policy's own, or the host templaterendered 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_credentialfrom ..cloud.hosts import render_base_url, resolve_settings@@ -308,26 +442,67 @@ class BaseProviderLM:policy = access if access is not None else type(self).manifestself.access = policyself.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 = Noneif 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 adialect 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)+ raisedef 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_stopreq, 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 errorlines = 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)+ raiseexcept 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 wasthe 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_hintif 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 errordef 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)+ raisefetched = Noneif 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 Nonedef _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)+ raiseresp = 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)+ raisetexts = []- 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 textdef 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 theboundary; `cached + messages` places the mark or sends nothing."""+ wire = self._wire_request(prefix)+ provider = self.provider if wire.model != prefix.model else Noneif 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 thediff --git a/dspy/_vendor/lm15/providers/common.py b/dspy/_vendor/lm15/providers/common.pyindex 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.dataif 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[strif 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, Aif 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.pyindex 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_APIfrom ..features import ProviderManifest+from ..judgments import gemini_schema, note_unmeasurable_probabilities, replace_text_with_data, request_judgmentsfrom ..live import WebSocketLiveSession, require_websocket_sync_connectfrom ..sse import SSEEventfrom ..transports import TransportRequestfrom ..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.logprobsif 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.reasoninglevel_class = gemini_level_class(request.model)@@ -845,6 +862,7 @@ class GeminiLM(BaseProviderLM):return payloaddef 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 partsdef 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:returnpayload = 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)returnyield 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"] = cursorreturn 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"] = labelreturn 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"] = cursorreturn 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].modelbatch: 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.pyindex 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_headerfrom ..auth import extract_chatgpt_account_idfrom ..compat import OPENAI_RESPONSES_PRESET_BASE_URLS, OpenAIResponsesCompat, preset_base_urlfrom ..features import ProviderManifest+from ..judgments import note_unmeasurable_probabilities, replace_text_with_data, request_judgmentsfrom ..result import materialize_responsefrom ..live import WebSocketLiveSession, require_websocket_sync_connectfrom ..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.parallelif 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 payloaddef 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 Noneif 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"] = cursorreturn 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.voiceif 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.pyindex 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 annotationsfrom datetime import datetimeimport json+import mathimport mimetypesimport osfrom 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_effortfrom ..errors import ProviderError, ServerError, UnsupportedFeatureErrorfrom ..access import OPENAI_CHAT_APIfrom ..features import ProviderManifest+from ..judgments import Judgment, judgments_in_schema, non_judgment_properties, normalize_logprobs, note_unmeasurable_probabilities, replace_text_with_data, request_judgmentsfrom ..sse import SSEEventfrom ..transports import TransportRequestfrom ..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_metadatafrom .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: stparts = [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 partout: 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 = Nocls = 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 recordpayload: 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 payloaddef 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 mappeddef 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:returnif raw_event.data == "[DONE]":diff --git a/dspy/_vendor/lm15/providers/typesafe.py b/dspy/_vendor/lm15/providers/typesafe.pynew file mode 100644index 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.pyindex 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.pynew file mode 100644index 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.pyindex 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.pyindex 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.messageexc_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.pyindex 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 difflibknown = 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:continueseen: 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)continueclose = 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 isbuilt 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 — agateway, 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[stextra["transport"] = config.transportif 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_urlpolicy = _credential_policy(resolution.provider, adapters)if policy == "oauth":return cls(**extra) # self-resolving local OAuth constructorapi_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_providerfrom .cloud.hosts import resolve_settings@@ -856,15 +934,18 @@ def _build_lm(resolution: Resolution, config: RouterConfig, adapters: Mapping[stgiven = (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 = Noneif 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)"breakif 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 lmif 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 = Noneif api_key is None:env = config.env if config.env is not None else os.environfor key in _declared_env_keys(resolution.provider, adapters):value = env.get(key)if value:api_key = value+ origin = f"env ${key} (value never shown)"breakif 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 lmPLANNING_KEY = "lm15-planning"@@ -930,8 +1021,9 @@ def _build_planning_lm(resolution: Resolution, config: RouterConfig, adapters: Mextra["transport"] = transportelif 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_urlaccount_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: Menv = config.env if config.env is not None else os.environgiven = 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_chatrequest_from_openai_chat = LMRouter.request_from_openai_chatdiff --git a/dspy/_vendor/lm15/serde.py b/dspy/_vendor/lm15/serde.pyindex 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.pyindex 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 mirrorones 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 annotationsimport asynciofrom typing import Any, AsyncIterator-from ._exceptions import TransportError+from ._exceptions import ReadTimeout, TransportError+from ._http11 import content_codings+from ._timeouts import wait_forfrom ._types import AsyncTransportResponse, TransportRequesttry: # 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.fetchself._read_timeout = read_timeoutself._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_timeoutcontroller = _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:returnwhile 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 excexcept Exception as exc:raise TransportError(f"response body read failed ({_message(exc)})") from excif 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 versionchunks=chunks(),release=release,)+ self._responses[id(controller)] = result+ return resultclass _FetchStreamCM:diff --git a/dspy/_vendor/lm15/types.py b/dspy/_vendor/lm15/types.pyindex 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: ErrorCodemessage: strprovider_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 = Noneextensions: Extensions | None = Nonedef __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+@propertydef 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 notemperature). ``resource`` is the stored object on providers withthat 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 wirebytes are what the contract pins; the sugar is per-language.@@ -2455,8 +2594,15 @@ class CachedPrefix:prefix: Requestresource: 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 generationsettings; its ``cache`` must be unset (the prefix decides)."""+ model = f"{self.provider}:{self.prefix.model}" if self.provider is not None else self.prefix.modelsuffix: 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 _replacereturn 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.pyindex 3d96bdc42..b32fcf5e5 100644--- a/dspy/clients/call_result.py+++ b/dspy/clients/call_result.py@@ -6,7 +6,7 @@ from typing import Anyfrom dspy._vendor.lm15.serde import response_from_dict, response_to_dictfrom dspy.clients.legacy_outputs import plain, valuefrom dspy.clients.lm15_boundary import response_value-from dspy.lm15 import Request, Response, TextPart, ThinkingPart+from dspy.lm15 import DataPart, Request, Response, TextPart, ThinkingPartCACHE_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.pyindex 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 StreamAssemblyErrordef error_from_event(event, *, provider=None):+ http = event.error.http_responsereturn 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.pyindex 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) -> Exfor 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.pyindex 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, monkeydef 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",)}