@deepstrike/sdk 0.2.52 → 0.2.60

package/dist/providers/base.js

@@ -1,3 +1,4 @@
+import { normalizeToolResultPart, projectToolOutputToText } from "./content-normalization.js";
 export class CircuitBreaker {
     openAfter;
     resetAfter;
@@ -140,11 +141,40 @@ export function toAnthropicContent(msg) {
             throw new UnsupportedModalityError("audio", "anthropic");
         }
         if (p.type === "tool_result") {
-            return { type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError };
+            return { type: "tool_result", tool_use_id: p.callId, content: toolResultAnthropicContent(p), is_error: p.isError };
         }
         return { type: "text", text: "" };
     });
 }
+/**
+ * spc_012-N-03: a `ContentBlock` inside a structured tool result → Anthropic wire block.
+ * Anthropic's `tool_result.content` natively accepts text and image blocks. Anything else
+ * (audio/video/file, `fileId`/`object` sources with no Anthropic wire form) degrades to an
+ * explicit `[modality]` placeholder visible to the model, never silently dropped (INV-012-01).
+ */
+function contentBlockToAnthropic(block) {
+    if (block.type === "text")
+        return { type: "text", text: block.text };
+    if (block.type === "image") {
+        const src = block.source;
+        if (src.kind === "base64") {
+            return { type: "image", source: { type: "base64", media_type: block.mediaType ?? "image/png", data: src.data } };
+        }
+        if (src.kind === "url") {
+            return { type: "image", source: { type: "url", url: src.url } };
+        }
+        return { type: "text", text: "[image]" };
+    }
+    return { type: "text", text: `[${block.type}]` };
+}
+/**
+ * Structured `contentParts` win when present; otherwise `output` is the text form.
+ */
+function toolResultAnthropicContent(p) {
+    if (p.contentParts !== undefined)
+        return normalizeToolResultPart(p).blocks.map(contentBlockToAnthropic);
+    return p.output;
+}
 /**
  * History turns with the volatile State turn appended as the latest turn, for
  * providers that render it inline (OpenAI-family, Gemini, Ollama). Appending
@@ -166,7 +196,7 @@ export function toAnthropicMessages(turns, nativeReplay) {
         if (msg.role === "tool") {
             const parts = (msg.contentParts ?? [])
                 .filter((p) => p.type === "tool_result")
-                .map(p => ({ type: "tool_result", tool_use_id: p.callId, content: p.output, is_error: p.isError }));
+                .map(p => ({ type: "tool_result", tool_use_id: p.callId, content: toolResultAnthropicContent(p), is_error: p.isError }));
             if (parts.length)
                 result.push({ role: "user", content: parts });
             continue;
@@ -246,10 +276,20 @@ export function toOpenAIMessageParams(context) {
     // bindings, where the state is already inside `turns`.
     for (const msg of turnsWithStateAppended(context)) {
         if (msg.role === "tool") {
+            // spc_012-N-04: OpenAI **chat completions** tool-role messages accept text only — no
+            // structured tool_result content exists on this wire. Explicit text-only degradation:
+            // `output` is the constructor's text projection, which carries a visible `[modality]`
+            // placeholder for any structured block (INV-012-01 — degraded, not silently dropped).
+            // The Responses API (openai-responses.ts) does have native structured support and uses it.
             const parts = (msg.contentParts ?? [])
                 .filter((p) => p.type === "tool_result");
             for (const p of parts) {
-                result.push({ role: "tool", tool_call_id: p.callId, content: p.output });
+                const canonical = normalizeToolResultPart(p);
+                result.push({
+                    role: "tool",
+                    tool_call_id: p.callId,
+                    content: projectToolOutputToText(canonical.blocks),
+                });
             }
             continue;
         }

package/dist/providers/capability-router.d.ts

@@ -0,0 +1,29 @@
+import type { CreateProviderOptions } from "./catalog.js";
+import type { InputModality, ResolvedProviderRuntime } from "./model-registry.js";
+export interface CapabilityRequirement {
+    requiredInputModalities?: readonly InputModality[];
+    tools?: boolean;
+    reasoning?: boolean;
+    minimumContextWindow?: number;
+}
+export type CapabilityRouteResult = {
+    ok: true;
+    runtime: ResolvedProviderRuntime;
+} | {
+    ok: false;
+    error: {
+        code: "no_capable_model";
+        requirement: CapabilityRequirement;
+        candidates: Array<{
+            model: string;
+            rejectedBy: string[];
+        }>;
+    };
+};
+/**
+ * Deliberately policy-free first-match router. Unknown capability evidence stays eligible for
+ * forward compatibility; only evidence of unsupported capability rejects a candidate.
+ */
+export declare class CapabilityRouter {
+    route(requirement: CapabilityRequirement, candidates: readonly CreateProviderOptions[]): Promise<CapabilityRouteResult>;
+}

package/dist/providers/capability-router.js

@@ -0,0 +1,43 @@
+import { resolveProviderRuntimeAsync } from "./catalog.js";
+/**
+ * Deliberately policy-free first-match router. Unknown capability evidence stays eligible for
+ * forward compatibility; only evidence of unsupported capability rejects a candidate.
+ */
+export class CapabilityRouter {
+    async route(requirement, candidates) {
+        const rejected = [];
+        for (const candidate of candidates) {
+            let runtime;
+            try {
+                runtime = await resolveProviderRuntimeAsync(candidate);
+            }
+            catch {
+                rejected.push({ model: candidate.model, rejectedBy: ["unavailable"] });
+                continue;
+            }
+            const rejectedBy = rejects(requirement, runtime);
+            if (rejectedBy.length === 0)
+                return { ok: true, runtime };
+            rejected.push({ model: candidate.model, rejectedBy });
+        }
+        return { ok: false, error: { code: "no_capable_model", requirement, candidates: rejected } };
+    }
+}
+function rejects(requirement, runtime) {
+    const result = [];
+    for (const modality of requirement.requiredInputModalities ?? []) {
+        if (runtime.effectiveCapabilities.inputModalities[modality].state === "unsupported") {
+            result.push(`input:${modality}`);
+        }
+    }
+    if (requirement.tools && runtime.effectiveCapabilities.tools.state === "unsupported")
+        result.push("tools");
+    if (requirement.reasoning && runtime.effectiveCapabilities.reasoning.state === "unsupported")
+        result.push("reasoning");
+    if (requirement.minimumContextWindow !== undefined
+        && runtime.model.contextWindow !== undefined
+        && runtime.model.contextWindow < requirement.minimumContextWindow) {
+        result.push("context");
+    }
+    return result;
+}

package/dist/providers/catalog.d.ts

@@ -1,9 +1,17 @@
 import type { LLMProvider } from "../types.js";
-import { endpointProfiles, type ModelProfileId, type ProviderId } from "./profiles.js";
-export type EndpointProfileId = keyof typeof endpointProfiles;
+import { type ResolvedProviderRuntime } from "./model-registry.js";
+import { type EndpointProfileId, type ProviderId } from "./endpoints.js";
+import { type CredentialOptions } from "./credentials.js";
+import type { ModelCatalog } from "./model-catalog.js";
+export type { EndpointProfileId } from "./endpoints.js";
 export interface CreateProviderOptions {
-    model: ModelProfileId | string;
-    apiKey: string;
+    model: string;
+    /** Explicit credential; resolver-backed construction can omit it. */
+    apiKey?: string;
+    bearerToken?: string;
+    credentialResolver?: CredentialOptions["credentialResolver"];
+    /** Host-provided catalog used only for lookup; it never carries routing policy. */
+    modelCatalog?: ModelCatalog;
     provider?: ProviderId;
     endpoint?: EndpointProfileId;
     retry?: {
@@ -13,3 +21,7 @@ export interface CreateProviderOptions {
     baseURL?: string;
 }
 export declare function createProvider(options: CreateProviderOptions): LLMProvider;
+export declare function resolveProviderRuntime(options: CreateProviderOptions): ResolvedProviderRuntime;
+/** I/O-capable equivalent for host credential resolvers and dynamic catalogs. */
+export declare function resolveProviderRuntimeAsync(options: CreateProviderOptions): Promise<ResolvedProviderRuntime>;
+export declare function createProviderAsync(options: CreateProviderOptions): Promise<LLMProvider>;

package/dist/providers/catalog.js

@@ -1,9 +1,44 @@
-import { PROVIDER_REGISTRY, providerRegistryKey } from "./registry.js";
-import { endpointProfiles, getModelProfile, modelProfiles } from "./profiles.js";
+import { PROVIDER_REGISTRY, providerRegistryKey, supportsBearerCredential } from "./registry.js";
+import { endpointCapabilitiesFor, generationProtocol, modelRegistry, normalizeModelId, resolveEffectiveModelCapabilities, } from "./model-registry.js";
+import { endpointProfiles } from "./endpoints.js";
+import { resolveCredential, resolveCredentialSync, CredentialResolutionError, } from "./credentials.js";
 export function createProvider(options) {
-    const profile = isModelProfileId(options.model) ? getModelProfile(options.model) : undefined;
+    return resolveProviderRuntime(options).adapter;
+}
+export function resolveProviderRuntime(options) {
+    const draft = resolveRuntimeDraft(options);
+    const credential = draft.providerId === "ollama"
+        ? { type: "api_key", value: "" }
+        : resolveCredentialSync(draft.credentialRequest, options);
+    return constructResolvedRuntime(draft, credential, options);
+}
+/** I/O-capable equivalent for host credential resolvers and dynamic catalogs. */
+export async function resolveProviderRuntimeAsync(options) {
+    const draft = await resolveRuntimeDraftAsync(options);
+    const credential = draft.providerId === "ollama"
+        ? { type: "api_key", value: "" }
+        : await resolveCredential(draft.credentialRequest, options);
+    return constructResolvedRuntime(draft, credential, options);
+}
+export async function createProviderAsync(options) {
+    return (await resolveProviderRuntimeAsync(options)).adapter;
+}
+function resolveRuntimeDraft(options) {
     const parsedProviderId = providerPrefix(options.model);
-    const endpointId = (options.endpoint ?? profile?.defaultEndpointId ?? defaultEndpointForProvider(options.provider ?? parsedProviderId));
+    const providerHint = options.provider ?? parsedProviderId;
+    const initialRegistration = modelRegistry.resolve(options.model, providerHint);
+    return resolveRuntimeDraftWithRegistration(options, parsedProviderId, initialRegistration);
+}
+async function resolveRuntimeDraftAsync(options) {
+    const parsedProviderId = providerPrefix(options.model);
+    const providerHint = options.provider ?? parsedProviderId;
+    const fromCatalog = options.modelCatalog ? await options.modelCatalog.get(options.model) : undefined;
+    const initialRegistration = fromCatalog ?? modelRegistry.resolve(options.model, providerHint);
+    return resolveRuntimeDraftWithRegistration(options, parsedProviderId, initialRegistration);
+}
+function resolveRuntimeDraftWithRegistration(options, parsedProviderId, initialRegistration) {
+    const providerHint = options.provider ?? parsedProviderId;
+    const endpointId = (options.endpoint ?? initialRegistration?.defaultEndpointId ?? defaultEndpointForProvider(providerHint));
     if (!endpointId) {
         throw new Error(`Unknown model profile: ${options.model}. Pass provider or endpoint for custom model names.`);
     }
@@ -11,26 +46,84 @@ export function createProvider(options) {
     if (!endpoint) {
         throw new Error(`Unknown endpoint profile: ${endpointId}`);
     }
-    const providerId = profile?.providerId ?? options.provider ?? parsedProviderId ?? endpoint.providerId;
-    if (profile && options.provider && options.provider !== profile.providerId) {
-        throw new Error(`Model ${profile.id} belongs to provider ${profile.providerId}, not ${options.provider}`);
-    }
+    const providerId = (initialRegistration?.descriptor.providerId ?? options.provider ?? parsedProviderId ?? endpoint.providerId);
+    const registration = initialRegistration ?? modelRegistry.resolve(options.model, providerId);
+    if (!registration)
+        throw new Error(`Unable to resolve model ${options.model} for provider ${providerId}`);
     if (parsedProviderId && options.provider && parsedProviderId !== options.provider) {
         throw new Error(`Model ${options.model} uses provider prefix ${parsedProviderId}, not ${options.provider}`);
     }
     if (endpoint.providerId !== providerId) {
         throw new Error(`Endpoint ${endpoint.id} does not belong to provider ${providerId}`);
     }
-    const model = modelNameForProvider(options.model, providerId);
-    const baseURL = options.baseURL ?? endpoint.baseURL;
-    // Single data-driven dispatch: one registry keyed by (providerId, protocol).
-    const make = PROVIDER_REGISTRY[providerRegistryKey(providerId, endpoint.protocol)];
-    if (make)
-        return make(options.apiKey, model, options.retry, baseURL);
-    throw new Error(`No Node provider factory for ${options.model} on ${endpoint.id}`);
+    const model = normalizeModelId(providerId, options.model);
+    return {
+        providerId,
+        model,
+        endpointId,
+        endpoint,
+        registration,
+        credentialRequest: { providerId, modelId: model, endpointId, protocol: endpoint.protocol },
+    };
+}
+function constructResolvedRuntime(draft, credential, options) {
+    if (credential.type === "bearer" && !supportsBearerCredential(draft.providerId, draft.endpoint.protocol)) {
+        throw new CredentialResolutionError("credential_auth_mode_unsupported", draft.providerId);
+    }
+    const make = PROVIDER_REGISTRY[providerRegistryKey(draft.providerId, draft.endpoint.protocol)];
+    if (!make)
+        throw new Error(`No Node provider factory for ${draft.model} on ${draft.endpoint.id}`);
+    const protocol = generationProtocol(draft.endpoint.protocol);
+    if (!protocol)
+        throw new Error(`No Node provider factory for ${draft.model} on ${draft.endpoint.id}`);
+    const adapter = make(credential.value, draft.model, options.retry, options.baseURL ?? draft.endpoint.baseURL, draft.registration.recommendedRuntimePolicy, credential.type);
+    const resolved = {
+        identity: { providerId: draft.providerId, modelId: draft.model, endpointId: draft.endpointId, protocol },
+        model: draft.registration.descriptor,
+        endpoint: draft.endpoint,
+        adapter,
+        effectiveCapabilities: resolveEffectiveModelCapabilities({
+            model: draft.registration.descriptor,
+            protocol,
+            endpointCapabilities: endpointCapabilitiesFor(draft.endpointId, options.baseURL === undefined || options.endpoint !== undefined),
+        }),
+        ...(draft.registration.recommendedRuntimePolicy ? { runtimePolicy: draft.registration.recommendedRuntimePolicy } : {}),
+    };
+    const bind = adapter.bindResolvedRuntime;
+    bind?.call(adapter, resolved);
+    const requestPlanIdentity = {
+        providerId: resolved.identity.providerId,
+        modelId: resolved.identity.modelId,
+        endpoint: {
+            id: resolved.identity.endpointId,
+            protocol: resolved.identity.protocol,
+            baseURL: safeEndpointBaseURL(options.baseURL ?? draft.endpoint.baseURL),
+        },
+        ...(resolved.effectiveCapabilities.nativeTokenCounting.state === "supported"
+            && resolved.effectiveCapabilities.nativeTokenCounting.value === true
+            ? { nativeTokenCounting: true }
+            : {}),
+    };
+    adapter
+        .requestPlanIdentity = () => ({
+        ...requestPlanIdentity,
+        endpoint: { ...requestPlanIdentity.endpoint },
+    });
+    return resolved;
 }
-function isModelProfileId(model) {
-    return Object.prototype.hasOwnProperty.call(modelProfiles, model);
+function safeEndpointBaseURL(baseURL) {
+    try {
+        const parsed = new URL(baseURL);
+        parsed.username = "";
+        parsed.password = "";
+        parsed.search = "";
+        parsed.hash = "";
+        return parsed.toString().replace(/\/$/, "");
+    }
+    catch {
+        // Provider construction has already accepted this opaque endpoint. Do not invent a replacement.
+        return baseURL;
+    }
 }
 function providerPrefix(model) {
     const [prefix] = model.split("/", 1);
@@ -51,10 +144,8 @@ function defaultEndpointForProvider(providerId) {
         qwen: "qwen.anthropic",
         gemini: "gemini.google",
         glm: "glm.anthropic",
+        baai: "baai.self-hosted.embeddings",
+        ollama: "ollama.local",
     };
     return defaults[providerId];
 }
-function modelNameForProvider(model, providerId) {
-    const prefix = `${providerId}/`;
-    return model.startsWith(prefix) ? model.slice(prefix.length) : model;
-}

package/dist/providers/content-normalization.d.ts

@@ -0,0 +1,57 @@
+import type { Message, RenderedContext, ToolOutputBlock, ToolResultPart, ToolSchema, ToolCall, ProviderReplay } from "../types.js";
+import type { ResolvedProviderRuntime } from "./model-registry.js";
+export declare class ContentValidationError extends Error {
+    constructor(message: string);
+}
+export declare class ToolResultProjectionConflictError extends ContentValidationError {
+    constructor(callId: string);
+}
+export interface CanonicalToolResult {
+    readonly type: "tool_result";
+    readonly callId: string;
+    readonly blocks: readonly ToolOutputBlock[];
+    readonly isError: boolean;
+    /** Preserves the caller's explicit text-vs-block wire intent without duplicating content. */
+    readonly contentForm?: "text" | "blocks";
+}
+export type CanonicalMessageBlock = ToolOutputBlock | CanonicalToolResult;
+export interface CanonicalMessage {
+    readonly role: Message["role"];
+    readonly blocks: readonly CanonicalMessageBlock[];
+    /** `blocks` remains authoritative; this only preserves an observable wire-shape distinction. */
+    readonly contentForm?: "text" | "blocks";
+    readonly toolCalls?: readonly ToolCall[];
+    readonly tokenCount?: number;
+    readonly providerReplay?: ProviderReplay;
+}
+export interface CanonicalRenderedContext {
+    readonly systemText: string;
+    readonly systemStable?: string;
+    readonly systemKnowledge?: string;
+    readonly turns: readonly CanonicalMessage[];
+    readonly stateTurn?: CanonicalMessage;
+    readonly frozenPrefixLen?: number;
+    readonly budgetOverflow?: RenderedContext["budgetOverflow"];
+}
+export interface CanonicalAdapterInput {
+    readonly context: CanonicalRenderedContext;
+    readonly tools: readonly ToolSchema[];
+    readonly resolved: ResolvedProviderRuntime<unknown>;
+    readonly extensions: Readonly<Record<string, unknown>>;
+}
+export declare function validateToolOutputBlocks(blocks: readonly ToolOutputBlock[]): void;
+export declare function projectToolOutputToText(blocks: readonly ToolOutputBlock[]): string;
+export declare function normalizeToolResultPart(part: ToolResultPart): CanonicalToolResult;
+/** Attach process-local blocks only within the operation that produced them. */
+export declare function attachToolOutputOverlay(context: RenderedContext, overlay: ReadonlyMap<string, readonly ToolOutputBlock[]>): RenderedContext;
+export declare function normalizeCanonicalContext(context: RenderedContext, replayForMessage?: (message: Message) => ProviderReplay | undefined): CanonicalRenderedContext;
+/** Full-tree validation uses the resolved operation capabilities. Unknown stays unknown/fail-open. */
+export declare function validateCanonicalAdapterInput(input: CanonicalAdapterInput): void;
+export declare function normalizeCanonicalAdapterInput(input: {
+    context: RenderedContext;
+    tools: readonly ToolSchema[];
+    resolved: ResolvedProviderRuntime<unknown>;
+    extensions?: Readonly<Record<string, unknown>>;
+    replayForMessage?: (message: Message) => ProviderReplay | undefined;
+}): CanonicalAdapterInput;
+export declare function normalizeToolResultContent(callId: string, output: string, isError: boolean, contentParts: readonly ToolOutputBlock[] | undefined): CanonicalToolResult;

package/dist/providers/content-normalization.js

@@ -0,0 +1,238 @@
+import { requireContentDisposition } from "./content-policy.js";
+export class ContentValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ContentValidationError";
+    }
+}
+export class ToolResultProjectionConflictError extends ContentValidationError {
+    constructor(callId) {
+        super(`Tool result projection conflict for ${callId}: output does not match contentParts`);
+        this.name = "ToolResultProjectionConflictError";
+    }
+}
+function requireNonEmpty(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new ContentValidationError(`${label} must be a non-empty string`);
+    }
+}
+function requireBase64(value, label) {
+    requireNonEmpty(value, label);
+    if (value.length % 4 !== 0
+        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)) {
+        throw new ContentValidationError(`${label} is not valid base64`);
+    }
+}
+function validateSource(source, modality) {
+    if (!source || typeof source !== "object") {
+        throw new ContentValidationError(`${modality} source is required`);
+    }
+    switch (source.kind) {
+        case "url":
+            requireNonEmpty(source.url, `${modality} URL`);
+            return;
+        case "base64":
+            requireBase64(source.data, `${modality} base64 data`);
+            return;
+        case "fileId":
+            requireNonEmpty(source.id, `${modality} file id`);
+            return;
+        case "object":
+            requireNonEmpty(source.handle, `${modality} object handle`);
+            return;
+        default: throw new ContentValidationError(`${modality} source kind is invalid`);
+    }
+}
+export function validateToolOutputBlocks(blocks) {
+    for (const raw of blocks) {
+        if (!raw || typeof raw !== "object")
+            throw new ContentValidationError("tool output block must be an object");
+        const block = raw;
+        switch (block.type) {
+            case "text":
+                if (typeof block.text !== "string")
+                    throw new ContentValidationError("tool output text must be a string");
+                break;
+            case "image":
+            case "audio":
+            case "video":
+            case "file":
+                validateSource(block.source, String(block.type));
+                break;
+            case "tool_result":
+                throw new ContentValidationError("nested tool_result blocks are forbidden");
+            default:
+                throw new ContentValidationError(`unknown tool output block type: ${String(block.type)}`);
+        }
+    }
+}
+export function projectToolOutputToText(blocks) {
+    validateToolOutputBlocks(blocks);
+    return blocks.map(block => block.type === "text" ? block.text : `[${block.type}]`).join("\n");
+}
+export function normalizeToolResultPart(part) {
+    if (part.contentParts === undefined) {
+        return {
+            type: "tool_result",
+            callId: part.callId,
+            blocks: [{ type: "text", text: part.output }],
+            isError: part.isError,
+            contentForm: "text",
+        };
+    }
+    const projection = projectToolOutputToText(part.contentParts);
+    if (projection !== part.output)
+        throw new ToolResultProjectionConflictError(part.callId);
+    return {
+        type: "tool_result",
+        callId: part.callId,
+        blocks: part.contentParts,
+        isError: part.isError,
+        contentForm: "blocks",
+    };
+}
+function attachMessage(message, overlay) {
+    const needs = message.contentParts?.some(part => part.type === "tool_result" && part.contentParts === undefined && overlay.has(part.callId));
+    if (!needs)
+        return message;
+    return {
+        ...message,
+        contentParts: message.contentParts.map(part => part.type === "tool_result" && part.contentParts === undefined && overlay.has(part.callId)
+            ? { ...part, contentParts: [...overlay.get(part.callId)] }
+            : part),
+    };
+}
+/** Attach process-local blocks only within the operation that produced them. */
+export function attachToolOutputOverlay(context, overlay) {
+    if (overlay.size === 0)
+        return context;
+    const turns = context.turns.map(message => attachMessage(message, overlay));
+    const stateTurn = context.stateTurn ? attachMessage(context.stateTurn, overlay) : undefined;
+    if (turns.every((turn, index) => turn === context.turns[index]) && stateTurn === context.stateTurn)
+        return context;
+    return { ...context, turns, ...(stateTurn ? { stateTurn } : {}) };
+}
+function assertSupported(modality, capabilities, providerId) {
+    if (capabilities.inputModalities[modality].state === "unsupported") {
+        throw new ContentValidationError(`UnsupportedModality: ${modality} is not supported by ${providerId}`);
+    }
+}
+function validateSourceAffinity(modality, source, capabilities, resolved) {
+    const key = modality === "image"
+        ? source.kind === "url" ? "imageUrl" : source.kind === "base64" ? "imageBase64" : source.kind === "fileId" ? "fileId" : undefined
+        : modality === "audio"
+            ? source.kind === "url" ? "audioUrl" : source.kind === "base64" ? "audioBase64" : source.kind === "fileId" ? "fileId" : undefined
+            : source.kind === "fileId" ? "fileId" : undefined;
+    if (key && capabilities.mediaForms[key].state === "unsupported") {
+        throw new ContentValidationError(`Unsupported media source ${source.kind} for ${modality} on ${resolved.identity.providerId}`);
+    }
+    validateFileAffinity(source, resolved);
+}
+function validateFileAffinity(source, resolved) {
+    if (source.kind === "fileId" && source.affinity) {
+        if (source.affinity.providerId !== resolved.identity.providerId
+            || source.affinity.endpointId !== resolved.identity.endpointId) {
+            throw new ContentValidationError(`Provider file ${source.id} belongs to ${source.affinity.providerId}/${source.affinity.endpointId}, `
+                + `not ${resolved.identity.providerId}/${resolved.identity.endpointId}`);
+        }
+    }
+}
+function normalizeMessage(message, replayForMessage) {
+    const providerReplay = replayForMessage?.(message);
+    const blocks = message.contentParts === undefined
+        ? [{ type: "text", text: message.content }]
+        : message.contentParts.map(part => {
+            if (part.type === "text")
+                return { type: "text", text: part.text };
+            if (part.type === "image") {
+                if ((part.url === undefined) === (part.data === undefined)) {
+                    throw new ContentValidationError("image requires exactly one of url or data");
+                }
+                return {
+                    type: "image",
+                    source: part.data !== undefined
+                        ? { kind: "base64", data: part.data }
+                        : { kind: "url", url: part.url },
+                    ...(part.mediaType ? { mediaType: part.mediaType } : {}),
+                    ...(part.detail ? { providerOptions: { openai_detail: part.detail } } : {}),
+                };
+            }
+            if (part.type === "audio") {
+                return {
+                    type: "audio",
+                    source: { kind: "base64", data: part.data },
+                    mediaType: part.mediaType,
+                };
+            }
+            return normalizeToolResultPart(part);
+        });
+    return {
+        role: message.role,
+        blocks,
+        contentForm: message.contentParts === undefined ? "text" : "blocks",
+        ...(message.toolCalls ? { toolCalls: message.toolCalls } : {}),
+        ...(message.tokenCount !== undefined ? { tokenCount: message.tokenCount } : {}),
+        ...(providerReplay ? { providerReplay } : {}),
+    };
+}
+export function normalizeCanonicalContext(context, replayForMessage) {
+    return {
+        systemText: context.systemText,
+        ...(context.systemStable !== undefined ? { systemStable: context.systemStable } : {}),
+        ...(context.systemKnowledge !== undefined ? { systemKnowledge: context.systemKnowledge } : {}),
+        turns: context.turns.map(message => normalizeMessage(message, replayForMessage)),
+        ...(context.stateTurn ? { stateTurn: normalizeMessage(context.stateTurn, replayForMessage) } : {}),
+        ...(context.frozenPrefixLen !== undefined ? { frozenPrefixLen: context.frozenPrefixLen } : {}),
+        ...(context.budgetOverflow !== undefined ? { budgetOverflow: context.budgetOverflow } : {}),
+    };
+}
+function validateCanonicalMessage(message, resolved) {
+    for (const item of message.blocks) {
+        const placement = item.type === "tool_result" ? "tool_result" : "message";
+        const blocks = item.type === "tool_result" ? item.blocks : [item];
+        validateToolOutputBlocks(blocks);
+        for (const block of blocks) {
+            if (block.type === "text")
+                continue;
+            // Protocol policy is the stable user-visible reason for document/video refusal; a model
+            // capability cannot make a protocol-level unsupported shape serializable.
+            const disposition = requireContentDisposition(resolved.identity.protocol, block.type, placement);
+            // Current bridge implementations exist only for document/video tool output: their
+            // serializers send the deterministic visible text projection instead of the source.
+            // Audio and message content retain their source-form checks because their wires have
+            // different native constraints and no generic text bridge carrier.
+            if (disposition === "bridge" && placement === "tool_result" && (block.type === "file" || block.type === "video")) {
+                validateFileAffinity(block.source, resolved);
+                continue;
+            }
+            assertSupported(block.type, resolved.effectiveCapabilities, resolved.identity.providerId);
+            validateSourceAffinity(block.type, block.source, resolved.effectiveCapabilities, resolved);
+        }
+    }
+}
+/** Full-tree validation uses the resolved operation capabilities. Unknown stays unknown/fail-open. */
+export function validateCanonicalAdapterInput(input) {
+    for (const message of input.context.turns)
+        validateCanonicalMessage(message, input.resolved);
+    if (input.context.stateTurn)
+        validateCanonicalMessage(input.context.stateTurn, input.resolved);
+}
+export function normalizeCanonicalAdapterInput(input) {
+    const canonical = {
+        context: normalizeCanonicalContext(input.context, input.replayForMessage),
+        tools: input.tools,
+        resolved: input.resolved,
+        extensions: input.extensions ?? {},
+    };
+    validateCanonicalAdapterInput(canonical);
+    return canonical;
+}
+export function normalizeToolResultContent(callId, output, isError, contentParts) {
+    return normalizeToolResultPart({
+        type: "tool_result",
+        callId,
+        output,
+        isError,
+        ...(contentParts === undefined ? {} : { contentParts: [...contentParts] }),
+    });
+}

package/dist/providers/content-policy.d.ts

@@ -0,0 +1,16 @@
+import type { InputModality } from "./protocol-capabilities.js";
+export type ContentPlacement = "message" | "tool_result";
+export type ContentDisposition = "native" | "bridge" | "unsupported";
+/**
+ * Provider serialization policy for canonical content. `bridge` means the protocol has no
+ * structured equivalent for that placement, but serializers may send the visible text projection.
+ * It never permits dropping a block or replacing it with an empty string.
+ */
+export declare function contentDispositionFor(protocol: string, modality: InputModality, placement: ContentPlacement): ContentDisposition;
+export declare class ContentPolicyError extends Error {
+    readonly protocol: string;
+    readonly modality: InputModality;
+    readonly placement: ContentPlacement;
+    constructor(protocol: string, modality: InputModality, placement: ContentPlacement);
+}
+export declare function requireContentDisposition(protocol: string, modality: InputModality, placement: ContentPlacement): ContentDisposition;