@deepstrike/sdk 0.2.52 → 0.2.61

package/dist/providers/endpoints.d.ts

@@ -0,0 +1,137 @@
+export type ProviderId = "anthropic" | "openai" | "minimax" | "deepseek" | "kimi" | "qwen" | "gemini" | "glm" | "baai" | "ollama";
+export type EndpointProtocol = "anthropic-messages" | "openai-chat" | "openai-responses" | "openai-embeddings" | "dashscope-multimodal-embeddings" | "gemini" | "gemini-embeddings" | "self-hosted-embeddings" | "ollama-chat";
+export interface EndpointProfile {
+    id: string;
+    providerId: ProviderId;
+    protocol: EndpointProtocol;
+    baseURL: string;
+}
+export declare const endpointProfiles: {
+    readonly "anthropic.messages": {
+        readonly id: "anthropic.messages";
+        readonly providerId: "anthropic";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.anthropic.com";
+    };
+    readonly "openai.chat": {
+        readonly id: "openai.chat";
+        readonly providerId: "openai";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "openai.responses": {
+        readonly id: "openai.responses";
+        readonly providerId: "openai";
+        readonly protocol: "openai-responses";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "openai.embeddings": {
+        readonly id: "openai.embeddings";
+        readonly providerId: "openai";
+        readonly protocol: "openai-embeddings";
+        readonly baseURL: "https://api.openai.com/v1";
+    };
+    readonly "minimax.anthropic": {
+        readonly id: "minimax.anthropic";
+        readonly providerId: "minimax";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.minimaxi.com/anthropic";
+    };
+    readonly "minimax.openai": {
+        readonly id: "minimax.openai";
+        readonly providerId: "minimax";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.minimaxi.com/v1";
+    };
+    readonly "deepseek.anthropic": {
+        readonly id: "deepseek.anthropic";
+        readonly providerId: "deepseek";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.deepseek.com/anthropic";
+    };
+    readonly "deepseek.openai": {
+        readonly id: "deepseek.openai";
+        readonly providerId: "deepseek";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.deepseek.com";
+    };
+    readonly "kimi.anthropic": {
+        readonly id: "kimi.anthropic";
+        readonly providerId: "kimi";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://api.moonshot.cn/anthropic";
+    };
+    readonly "kimi.openai": {
+        readonly id: "kimi.openai";
+        readonly providerId: "kimi";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://api.moonshot.cn/v1";
+    };
+    readonly "qwen.anthropic": {
+        readonly id: "qwen.anthropic";
+        readonly providerId: "qwen";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://dashscope-intl.aliyuncs.com/apps/anthropic";
+    };
+    readonly "qwen.dashscope": {
+        readonly id: "qwen.dashscope";
+        readonly providerId: "qwen";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    };
+    readonly "qwen.dashscope.embeddings": {
+        readonly id: "qwen.dashscope.embeddings";
+        readonly providerId: "qwen";
+        readonly protocol: "openai-embeddings";
+        readonly baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1";
+    };
+    readonly "qwen.dashscope.multimodal-embeddings": {
+        readonly id: "qwen.dashscope.multimodal-embeddings";
+        readonly providerId: "qwen";
+        readonly protocol: "dashscope-multimodal-embeddings";
+        readonly baseURL: "https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding";
+    };
+    readonly "gemini.google": {
+        readonly id: "gemini.google";
+        readonly providerId: "gemini";
+        readonly protocol: "gemini";
+        readonly baseURL: "https://generativelanguage.googleapis.com";
+    };
+    readonly "gemini.google.embeddings": {
+        readonly id: "gemini.google.embeddings";
+        readonly providerId: "gemini";
+        readonly protocol: "gemini-embeddings";
+        readonly baseURL: "https://generativelanguage.googleapis.com";
+    };
+    readonly "glm.anthropic": {
+        readonly id: "glm.anthropic";
+        readonly providerId: "glm";
+        readonly protocol: "anthropic-messages";
+        readonly baseURL: "https://open.bigmodel.cn/api/anthropic";
+    };
+    readonly "glm.openai": {
+        readonly id: "glm.openai";
+        readonly providerId: "glm";
+        readonly protocol: "openai-chat";
+        readonly baseURL: "https://open.bigmodel.cn/api/paas/v4";
+    };
+    readonly "glm.openai.embeddings": {
+        readonly id: "glm.openai.embeddings";
+        readonly providerId: "glm";
+        readonly protocol: "openai-embeddings";
+        readonly baseURL: "https://open.bigmodel.cn/api/paas/v4";
+    };
+    readonly "baai.self-hosted.embeddings": {
+        readonly id: "baai.self-hosted.embeddings";
+        readonly providerId: "baai";
+        readonly protocol: "self-hosted-embeddings";
+        readonly baseURL: "https://huggingface.co/BAAI";
+    };
+    readonly "ollama.local": {
+        readonly id: "ollama.local";
+        readonly providerId: "ollama";
+        readonly protocol: "ollama-chat";
+        readonly baseURL: "http://localhost:11434";
+    };
+};
+export type EndpointProfileId = keyof typeof endpointProfiles;

package/dist/providers/endpoints.js

@@ -0,0 +1,128 @@
+export const endpointProfiles = {
+    "anthropic.messages": {
+        id: "anthropic.messages",
+        providerId: "anthropic",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.anthropic.com",
+    },
+    "openai.chat": {
+        id: "openai.chat",
+        providerId: "openai",
+        protocol: "openai-chat",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "openai.responses": {
+        id: "openai.responses",
+        providerId: "openai",
+        protocol: "openai-responses",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "openai.embeddings": {
+        id: "openai.embeddings",
+        providerId: "openai",
+        protocol: "openai-embeddings",
+        baseURL: "https://api.openai.com/v1",
+    },
+    "minimax.anthropic": {
+        id: "minimax.anthropic",
+        providerId: "minimax",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.minimaxi.com/anthropic",
+    },
+    "minimax.openai": {
+        id: "minimax.openai",
+        providerId: "minimax",
+        protocol: "openai-chat",
+        baseURL: "https://api.minimaxi.com/v1",
+    },
+    "deepseek.anthropic": {
+        id: "deepseek.anthropic",
+        providerId: "deepseek",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.deepseek.com/anthropic",
+    },
+    "deepseek.openai": {
+        id: "deepseek.openai",
+        providerId: "deepseek",
+        protocol: "openai-chat",
+        baseURL: "https://api.deepseek.com",
+    },
+    "kimi.anthropic": {
+        id: "kimi.anthropic",
+        providerId: "kimi",
+        protocol: "anthropic-messages",
+        baseURL: "https://api.moonshot.cn/anthropic",
+    },
+    "kimi.openai": {
+        id: "kimi.openai",
+        providerId: "kimi",
+        protocol: "openai-chat",
+        baseURL: "https://api.moonshot.cn/v1",
+    },
+    "qwen.anthropic": {
+        id: "qwen.anthropic",
+        providerId: "qwen",
+        protocol: "anthropic-messages",
+        baseURL: "https://dashscope-intl.aliyuncs.com/apps/anthropic",
+    },
+    "qwen.dashscope": {
+        id: "qwen.dashscope",
+        providerId: "qwen",
+        protocol: "openai-chat",
+        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    },
+    "qwen.dashscope.embeddings": {
+        id: "qwen.dashscope.embeddings",
+        providerId: "qwen",
+        protocol: "openai-embeddings",
+        baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    },
+    "qwen.dashscope.multimodal-embeddings": {
+        id: "qwen.dashscope.multimodal-embeddings",
+        providerId: "qwen",
+        protocol: "dashscope-multimodal-embeddings",
+        baseURL: "https://dashscope.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding",
+    },
+    "gemini.google": {
+        id: "gemini.google",
+        providerId: "gemini",
+        protocol: "gemini",
+        baseURL: "https://generativelanguage.googleapis.com",
+    },
+    "gemini.google.embeddings": {
+        id: "gemini.google.embeddings",
+        providerId: "gemini",
+        protocol: "gemini-embeddings",
+        baseURL: "https://generativelanguage.googleapis.com",
+    },
+    "glm.anthropic": {
+        id: "glm.anthropic",
+        providerId: "glm",
+        protocol: "anthropic-messages",
+        baseURL: "https://open.bigmodel.cn/api/anthropic",
+    },
+    "glm.openai": {
+        id: "glm.openai",
+        providerId: "glm",
+        protocol: "openai-chat",
+        baseURL: "https://open.bigmodel.cn/api/paas/v4",
+    },
+    "glm.openai.embeddings": {
+        id: "glm.openai.embeddings",
+        providerId: "glm",
+        protocol: "openai-embeddings",
+        baseURL: "https://open.bigmodel.cn/api/paas/v4",
+    },
+    "baai.self-hosted.embeddings": {
+        id: "baai.self-hosted.embeddings",
+        providerId: "baai",
+        protocol: "self-hosted-embeddings",
+        baseURL: "https://huggingface.co/BAAI",
+    },
+    "ollama.local": {
+        id: "ollama.local",
+        providerId: "ollama",
+        protocol: "ollama-chat",
+        baseURL: "http://localhost:11434",
+    },
+};

package/dist/providers/factories.js

@@ -1,33 +1,49 @@
 import { PROVIDER_REGISTRY } from "./registry.js";
 import { OllamaProvider } from "./ollama.js";
-function build(providerId, protocol, o) {
-    return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, o.model, o.retry, o.baseURL);
+import { defaultEndpointForProvider, defaultModelForProvider, getRuntimePolicy, isKnownProviderId } from "./model-registry.js";
+import { endpointProfiles } from "./endpoints.js";
+function build(providerId, o) {
+    if (!isKnownProviderId(providerId))
+        throw new Error(`Unknown provider: ${providerId}`);
+    const defaultProtocol = endpointProfiles[defaultEndpointForProvider(providerId)].protocol;
+    const protocol = o.protocol === "openai"
+        ? "openai-chat"
+        : o.protocol === "anthropic"
+            ? "anthropic-messages"
+            : defaultProtocol;
+    if (protocol !== "openai-chat" && protocol !== "anthropic-messages") {
+        throw new Error(`Provider ${providerId} does not use an OpenAI- or Anthropic-compatible default`);
+    }
+    const model = o.model ?? defaultModelForProvider(providerId);
+    return PROVIDER_REGISTRY[`${providerId}:${protocol}`](o.apiKey, model, o.retry, o.baseURL, getRuntimePolicy(providerId, model));
 }
 /** DeepSeek. Defaults to the OpenAI-compatible wire (richer reasoning-replay handling). */
 export function deepseek(o) {
-    return build("deepseek", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("deepseek", o);
 }
 /** Moonshot Kimi. Defaults to the OpenAI-compatible wire. */
 export function kimi(o) {
-    return build("kimi", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("kimi", o);
 }
 /** Alibaba Qwen / DashScope. Defaults to the OpenAI-compatible (DashScope) wire. */
 export function qwen(o) {
-    return build("qwen", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("qwen", o);
 }
 /** Zhipu GLM. Defaults to the OpenAI-compatible wire. */
 export function glm(o) {
-    return build("glm", o.protocol === "anthropic" ? "anthropic-messages" : "openai-chat", o);
+    return build("glm", o);
 }
 /** MiniMax. Defaults to the Anthropic-compatible wire (the primary M2.x path). */
 export function minimax(o) {
-    return build("minimax", o.protocol === "openai" ? "openai-chat" : "anthropic-messages", o);
+    return build("minimax", o);
 }
 /** Google Gemini (single wire). */
 export function gemini(o) {
-    return PROVIDER_REGISTRY["gemini:gemini"](o.apiKey, o.model, o.retry, o.baseURL);
+    const model = o.model ?? defaultModelForProvider("gemini");
+    return PROVIDER_REGISTRY["gemini:gemini"](o.apiKey, model, o.retry, o.baseURL, getRuntimePolicy("gemini", model));
 }
 /** Local Ollama (single wire, no API key). */
 export function ollama(o = {}) {
-    return new OllamaProvider(o.model, o.baseURL);
+    const model = o.model ?? defaultModelForProvider("ollama");
+    return new OllamaProvider(model, o.baseURL, getRuntimePolicy("ollama", model));
 }

package/dist/providers/gemini-adapter.d.ts

@@ -0,0 +1,33 @@
+import type { Content, GenerateContentRequest, GenerateContentResponse, ModelParams, Tool } from "@google/generative-ai";
+import type { Message, ProviderUsage } from "../types.js";
+import type { CanonicalAdapterInput } from "./content-normalization.js";
+import { type AdapterDecodeInput, type AdapterOutput, type AdapterStreamInput, type CanonicalStopReason, type ProtocolAdapter } from "./protocol-adapter.js";
+export interface GeminiRequestPlan {
+    modelParams: ModelParams & Record<string, unknown>;
+    request: GenerateContentRequest;
+}
+export interface GeminiStreamState {
+    readonly input: CanonicalAdapterInput;
+    readonly toolCalls: Array<{
+        name: string;
+        args: Record<string, unknown>;
+    }>;
+}
+export declare function canonicalGeminiContents(context: CanonicalAdapterInput["context"]): Content[];
+export declare function geminiVendorConfig(extensions: Readonly<Record<string, unknown>>): {
+    tools?: Tool[];
+    generationConfig?: Record<string, unknown>;
+};
+export declare class GeminiAdapter implements ProtocolAdapter<GeminiRequestPlan, GenerateContentResponse, GenerateContentResponse, GeminiStreamState, GenerateContentResponse> {
+    readonly protocol: "gemini";
+    readonly protocolCapabilities: import("./protocol-capabilities.js").ProtocolRuntimeCapabilities;
+    buildRequest(input: CanonicalAdapterInput): GeminiRequestPlan;
+    decodeComplete(raw: GenerateContentResponse, _input: AdapterDecodeInput): {
+        message: Message;
+    };
+    createStreamState(input: AdapterStreamInput): GeminiStreamState;
+    pushStreamChunk(chunk: GenerateContentResponse, state: GeminiStreamState): AdapterOutput;
+    finishStream(state: GeminiStreamState, final: GenerateContentResponse): AdapterOutput;
+    normalizeUsage(raw: unknown): ProviderUsage | undefined;
+    normalizeStopReason(raw: string | undefined): CanonicalStopReason | undefined;
+}

package/dist/providers/gemini-adapter.js

@@ -0,0 +1,264 @@
+import { projectToolOutputToText } from "./content-normalization.js";
+import { normalizeToolCall } from "./base.js";
+import { normalizeGeminiUsage } from "./usage-normalizer.js";
+import { ProtocolResponseError, GEMINI_PROTOCOL_CAPABILITIES, } from "./protocol-adapter.js";
+// Google Generate Content streams response chunks, while @google/generative-ai 0.24.1 exposes
+// a separate promise for the aggregated response. Candidate finishReason and aggregate usage are
+// therefore decoded only by finishStream.
+// Source: https://ai.google.dev/api/generate-content#method:-models.streamgeneratecontent
+// Source: https://github.com/google-gemini/deprecated-generative-ai-js/blob/v0.24.1/types/responses.ts
+function parseArguments(argumentsJson) {
+    try {
+        const value = JSON.parse(argumentsJson);
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function toolName(callId, messages) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const match = messages[index].toolCalls?.find(call => call.id === callId);
+        if (match)
+            return match.name;
+    }
+    return callId;
+}
+function toolResultPart(result, messages) {
+    return {
+        functionResponse: {
+            name: toolName(result.callId, messages),
+            response: { output: projectToolOutputToText(result.blocks) },
+        },
+    };
+}
+function contentPart(block) {
+    if (block.type === "text")
+        return block.text ? { text: block.text } : undefined;
+    if (block.type === "image" || block.type === "audio") {
+        if (block.source.kind === "base64") {
+            return {
+                inlineData: {
+                    mimeType: block.mediaType ?? (block.type === "image" ? "image/png" : "audio/wav"),
+                    data: block.source.data,
+                },
+            };
+        }
+        if (block.source.kind === "url") {
+            return {
+                fileData: {
+                    mimeType: block.mediaType ?? (block.type === "image" ? "image/png" : "audio/wav"),
+                    fileUri: block.source.url,
+                },
+            };
+        }
+    }
+    if (block.type === "video" || block.type === "file") {
+        throw new ProtocolResponseError("gemini", `cannot serialize ${block.type}`);
+    }
+    throw new ProtocolResponseError("gemini", `cannot serialize ${block.type} source`);
+}
+export function canonicalGeminiContents(context) {
+    const messages = context.stateTurn ? [...context.turns, context.stateTurn] : context.turns;
+    const contents = [];
+    for (const message of messages) {
+        const parts = [];
+        for (const call of message.toolCalls ?? []) {
+            parts.push({
+                functionCall: { name: call.name, args: parseArguments(call.arguments) },
+            });
+        }
+        for (const block of message.blocks) {
+            if (block.type === "tool_result") {
+                parts.push(toolResultPart(block, messages));
+            }
+            else {
+                const part = contentPart(block);
+                if (part)
+                    parts.push(part);
+            }
+        }
+        if (!parts.length)
+            continue;
+        contents.push({
+            role: message.role === "assistant" ? "model" : "user",
+            parts,
+        });
+    }
+    return contents;
+}
+function buildTools(tools) {
+    if (!tools.length)
+        return [];
+    return [{
+            functionDeclarations: tools.map(tool => ({
+                name: tool.name,
+                description: tool.description,
+                parameters: JSON.parse(tool.parameters),
+            })),
+        }];
+}
+function modelExtensions(extensions) {
+    const { model: _model, systemInstruction: _systemInstruction, tools: _tools, google_search: _googleSearch, response_mime_type: _responseMimeType, response_schema: _responseSchema, generationConfig: _generationConfig, ...rest } = extensions;
+    return rest;
+}
+export function geminiVendorConfig(extensions) {
+    const tools = [];
+    if (extensions.google_search) {
+        tools.push({
+            googleSearch: typeof extensions.google_search === "object"
+                ? extensions.google_search
+                : {},
+        });
+    }
+    const generationConfig = {
+        ...extensions.generationConfig,
+    };
+    if (extensions.response_mime_type != null) {
+        generationConfig.responseMimeType = extensions.response_mime_type;
+    }
+    if (extensions.response_schema != null) {
+        generationConfig.responseSchema = extensions.response_schema;
+    }
+    return {
+        ...(tools.length ? { tools } : {}),
+        ...(Object.keys(generationConfig).length ? { generationConfig } : {}),
+    };
+}
+function decodeParts(raw) {
+    const candidate = raw.candidates?.[0];
+    let content = "";
+    const toolCalls = [];
+    for (const part of candidate?.content.parts ?? []) {
+        if (part.text)
+            content += part.text;
+        else if (part.functionCall) {
+            const call = normalizeToolCall(part.functionCall.name, part.functionCall.name, part.functionCall.args);
+            if (call)
+                toolCalls.push(call);
+        }
+    }
+    return { content, toolCalls };
+}
+function numberField(raw, field) {
+    const value = raw[field];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new ProtocolResponseError("gemini", `usage.${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
+export class GeminiAdapter {
+    protocol = "gemini";
+    protocolCapabilities = GEMINI_PROTOCOL_CAPABILITIES;
+    buildRequest(input) {
+        const extensions = input.extensions;
+        const vendor = geminiVendorConfig(extensions);
+        const tools = [...buildTools(input.tools), ...(vendor.tools ?? [])];
+        return {
+            modelParams: {
+                ...modelExtensions(extensions),
+                model: input.resolved.identity.modelId,
+                ...(input.context.systemText ? { systemInstruction: input.context.systemText } : {}),
+                ...(tools.length ? { tools } : {}),
+                ...(vendor.generationConfig ? { generationConfig: vendor.generationConfig } : {}),
+            },
+            request: { contents: canonicalGeminiContents(input.context) },
+        };
+    }
+    decodeComplete(raw, _input) {
+        const decoded = decodeParts(raw);
+        const usage = this.normalizeUsage(raw.usageMetadata);
+        const rawUsage = raw.usageMetadata;
+        const tokenCount = usage?.outputTokens
+            ?? (rawUsage ? numberField(rawUsage, "totalTokenCount") : undefined);
+        return {
+            message: {
+                role: "assistant",
+                content: decoded.content,
+                ...(tokenCount !== undefined ? { tokenCount } : {}),
+                toolCalls: decoded.toolCalls,
+            },
+        };
+    }
+    createStreamState(input) {
+        return { input: input.input, toolCalls: [] };
+    }
+    pushStreamChunk(chunk, state) {
+        const events = [];
+        for (const part of chunk.candidates?.[0]?.content.parts ?? []) {
+            if (part.text)
+                events.push({ type: "text_delta", delta: part.text });
+            else if (part.functionCall) {
+                state.toolCalls.push({
+                    name: part.functionCall.name,
+                    args: part.functionCall.args,
+                });
+            }
+        }
+        return { events };
+    }
+    finishStream(state, final) {
+        const events = state.toolCalls.map((call, index) => ({
+            type: "tool_call",
+            id: `call_${index + 1}`,
+            name: call.name,
+            arguments: call.args,
+        }));
+        const usage = this.normalizeUsage(final.usageMetadata);
+        const rawStopReason = final.candidates?.[0]?.finishReason;
+        const stopReason = this.normalizeStopReason(rawStopReason);
+        if (usage) {
+            const raw = final.usageMetadata;
+            const totalTokens = numberField(raw, "totalTokenCount")
+                ?? usage.inputTokens + usage.outputTokens;
+            events.push({
+                type: "usage",
+                totalTokens,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                ...(usage.cacheReadInputTokens
+                    ? { cacheReadInputTokens: usage.cacheReadInputTokens }
+                    : {}),
+                ...(usage.cacheTelemetryStatus ? { cacheTelemetryStatus: usage.cacheTelemetryStatus } : {}),
+                ...(usage.cacheTelemetrySource ? { cacheTelemetrySource: usage.cacheTelemetrySource } : {}),
+                providerUsage: usage,
+                ...(stopReason ? { stopReason } : {}),
+                ...(rawStopReason ? { rawStopReason } : {}),
+            });
+        }
+        return { events };
+    }
+    normalizeUsage(raw) {
+        if (raw === undefined || raw === null)
+            return undefined;
+        if (typeof raw !== "object" || Array.isArray(raw)) {
+            throw new ProtocolResponseError("gemini", "usage must be an object");
+        }
+        const usage = raw;
+        numberField(usage, "totalTokenCount");
+        return normalizeGeminiUsage(usage);
+    }
+    normalizeStopReason(raw) {
+        if (raw === undefined)
+            return undefined;
+        switch (raw) {
+            case "STOP":
+            case "FINISH_REASON_STOP":
+                return "end_turn";
+            case "MAX_TOKENS":
+                return "max_tokens";
+            case "SAFETY":
+            case "RECITATION":
+            case "BLOCKLIST":
+            case "PROHIBITED_CONTENT":
+            case "SPII":
+                return "content_filter";
+            default:
+                return "other";
+        }
+    }
+}

package/dist/providers/gemini.d.ts

@@ -1,21 +1,33 @@
 import { type Content } from "@google/generative-ai";
-import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy } from "../types.js";
+import type { Message, RenderedContext, ToolSchema, StreamEvent, LLMProvider, RuntimePolicy, PromptMeasurement } from "../types.js";
+import { type CanonicalAdapterInput } from "./content-normalization.js";
+type ResolvedGeminiRuntime = CanonicalAdapterInput["resolved"];
 export declare function buildContents(turns: Message[]): Content[];
 export declare class GeminiProvider implements LLMProvider {
     private readonly model;
+    private resolvedRuntime?;
     private genAI;
     private circuit;
     private maxRetries;
     private baseDelay;
     private requestOptions;
+    private readonly resolvedRuntimePolicy;
+    private readonly adapter;
     constructor(apiKey: string, model?: string, retry?: {
         maxRetries: number;
         baseDelay: number;
-    }, baseURL?: string);
+    }, baseURL?: string, runtimePolicy?: RuntimePolicy, resolvedRuntime?: ResolvedGeminiRuntime | undefined);
     runtimePolicy(): RuntimePolicy;
+    bindResolvedRuntime(resolved: ResolvedGeminiRuntime): void;
+    private adapterInput;
     complete(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<Message>;
     stream(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): AsyncIterable<StreamEvent>;
-    private modelExtensions;
+    /**
+     * spc_011-C-05: preflight native token count via `GenerativeModel.countTokens` — reuses the
+     * same contents/tools/vendorConfig construction `complete()` uses so the counted request and
+     * the sent request never diverge.
+     */
+    countTokens(context: RenderedContext, tools: ToolSchema[], extensions?: Record<string, unknown>): Promise<PromptMeasurement>;
     /**
      * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
      * extension keys for a consistent cross-SDK API):
@@ -29,3 +41,4 @@ export declare class GeminiProvider implements LLMProvider {
         generationConfig?: Record<string, unknown>;
     };
 }
+export {};