@deepstrike/sdk 0.2.52 → 0.2.60

package/dist/providers/gemini-adapter.js

@@ -0,0 +1,272 @@
+import { projectToolOutputToText } from "./content-normalization.js";
+import { normalizeToolCall } from "./base.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.isFinite(value) || value < 0) {
+        throw new ProtocolResponseError("gemini", `usage.${field} must be a non-negative finite number`);
+    }
+    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 }
+                    : {}),
+                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;
+        const inputTokens = numberField(usage, "promptTokenCount");
+        const outputTokens = numberField(usage, "candidatesTokenCount");
+        numberField(usage, "totalTokenCount");
+        const cacheReadInputTokens = numberField(usage, "cachedContentTokenCount");
+        if (inputTokens === undefined
+            && outputTokens === undefined
+            && cacheReadInputTokens === undefined)
+            return undefined;
+        return {
+            inputTokens: inputTokens ?? 0,
+            outputTokens: outputTokens ?? 0,
+            ...(cacheReadInputTokens ? { cacheReadInputTokens } : {}),
+        };
+    }
+    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 {};

package/dist/providers/gemini.js

@@ -1,163 +1,98 @@
 import { GoogleGenerativeAI } from "@google/generative-ai";
 import { withServerRuntimeGuard } from "../runtime/server.js";
-import { CircuitBreaker, normalizeToolCall, turnsWithStateAppended } from "./base.js";
-import { endpointProfiles } from "./profiles.js";
-import { UnsupportedModalityError } from "./base.js";
+import { CircuitBreaker } from "./base.js";
+import { endpointProfiles } from "./endpoints.js";
+import { normalizeCanonicalAdapterInput, normalizeCanonicalContext, } from "./content-normalization.js";
+import { GeminiAdapter, canonicalGeminiContents, geminiVendorConfig } from "./gemini-adapter.js";
+import { circuitOpenError, classifyProviderError } from "./provider-error.js";
 const GEMINI_BASE = endpointProfiles["gemini.google"].baseURL;
-const GEMINI_POLICIES = {
-    "gemini-3-pro-preview": { maxTurns: 50 },
-    "gemini-3-flash-preview": { maxTurns: 25 },
-    "gemini-3.5-flash": { maxTurns: 30 },
-    "gemini-2.5-pro": { maxTurns: 35 },
-    "gemini-2.5-flash": { maxTurns: 20 },
-    "gemini-2.0-flash": { maxTurns: 15 },
-    "gemini-2.0-flash-lite": { maxTurns: 10 },
-    "gemini-1.5-pro": { maxTurns: 30 },
-    "gemini-1.5-flash": { maxTurns: 15 },
-};
 export function buildContents(turns) {
-    const contents = [];
-    for (const msg of turns) {
-        if (msg.role === "tool") {
-            const parts = (msg.contentParts ?? [])
-                .filter(p => p.type === "tool_result")
-                .map(p => {
-                if (p.type !== "tool_result")
-                    return { text: "" };
-                let toolName = p.callId;
-                for (let i = turns.length - 1; i >= 0; i--) {
-                    const turn = turns[i];
-                    if (turn.role === "assistant" && turn.toolCalls) {
-                        const matched = turn.toolCalls.find(tc => tc.id === p.callId);
-                        if (matched) {
-                            toolName = matched.name;
-                            break;
-                        }
-                    }
-                }
-                return {
-                    functionResponse: { name: toolName, response: { output: p.output } },
-                };
-            });
-            if (parts.length)
-                contents.push({ role: "user", parts });
-            continue;
-        }
-        const role = msg.role === "assistant" ? "model" : "user";
-        const parts = [];
-        if (msg.toolCalls?.length) {
-            for (const tc of msg.toolCalls) {
-                let args = {};
-                try {
-                    args = JSON.parse(tc.arguments);
-                }
-                catch {
-                    args = {};
-                }
-                parts.push({ functionCall: { name: tc.name, args } });
-            }
-        }
-        // Multimodal: render contentParts (text + image) when present, else the plain
-        // text body. Without this, image inputs to Gemini were silently dropped.
-        if (msg.contentParts?.length) {
-            for (const p of msg.contentParts) {
-                if (p.type === "text")
-                    parts.push({ text: p.text });
-                else if (p.type === "image") {
-                    if (p.data)
-                        parts.push({ inlineData: { mimeType: p.mediaType ?? "image/png", data: p.data } });
-                    else if (p.url)
-                        parts.push({ fileData: { mimeType: p.mediaType ?? "image/png", fileUri: p.url } });
-                }
-                else if (p.type === "audio") {
-                    if (!p.data)
-                        throw new UnsupportedModalityError("audio", "gemini");
-                    parts.push({ inlineData: { mimeType: p.mediaType ?? "audio/wav", data: p.data } });
-                }
-                else if (p.type === "tool_result") {
-                    // tool results are handled via functionResponse on tool role messages
-                }
-                else {
-                    throw new UnsupportedModalityError(String(p.type ?? "unknown"), "gemini");
-                }
-            }
-        }
-        else if (msg.content) {
-            parts.push({ text: msg.content });
-        }
-        if (parts.length)
-            contents.push({ role, parts });
-    }
-    return contents;
-}
-function buildTools(tools) {
-    if (!tools.length)
-        return [];
-    return [{
-            functionDeclarations: tools.map(t => ({
-                name: t.name,
-                description: t.description,
-                parameters: JSON.parse(t.parameters),
-            })),
-        }];
+    return canonicalGeminiContents(normalizeCanonicalContext({ systemText: "", turns }));
 }
 export class GeminiProvider {
     model;
+    resolvedRuntime;
     genAI;
     circuit;
     maxRetries;
     baseDelay;
     requestOptions;
-    constructor(apiKey, model = "gemini-2.0-flash", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = GEMINI_BASE) {
+    resolvedRuntimePolicy;
+    adapter = new GeminiAdapter();
+    constructor(apiKey, model = "gemini-2.0-flash", retry = { maxRetries: 3, baseDelay: 1000 }, baseURL = GEMINI_BASE, runtimePolicy = {}, resolvedRuntime) {
         this.model = model;
+        this.resolvedRuntime = resolvedRuntime;
         this.genAI = withServerRuntimeGuard(() => new GoogleGenerativeAI(apiKey));
         this.circuit = new CircuitBreaker();
         this.maxRetries = retry.maxRetries;
         this.baseDelay = retry.baseDelay;
         this.requestOptions = { baseUrl: baseURL };
+        this.resolvedRuntimePolicy = runtimePolicy;
     }
     runtimePolicy() {
-        return GEMINI_POLICIES[this.model] ?? {};
+        return this.resolvedRuntimePolicy;
+    }
+    bindResolvedRuntime(resolved) {
+        if (resolved.identity.protocol !== "gemini"
+            || resolved.identity.modelId !== this.model) {
+            throw new Error("GeminiProvider received a mismatched resolved runtime");
+        }
+        this.resolvedRuntime = resolved;
+    }
+    adapterInput(context, tools, extensions) {
+        if (!this.resolvedRuntime) {
+            // Direct class construction is a published compatibility path. A-07 replaces it with
+            // injected runtime profiles; until then this local descriptor contains no Registry lookup.
+            const resolved = {
+                identity: {
+                    providerId: "gemini",
+                    modelId: this.model,
+                    endpointId: "gemini.google",
+                    protocol: "gemini",
+                },
+                model: { id: `gemini/${this.model}`, providerId: "gemini", kind: "generation", intrinsic: {} },
+                endpoint: endpointProfiles["gemini.google"],
+                adapter: this,
+                effectiveCapabilities: {
+                    inputModalities: Object.fromEntries(["text", "image", "audio", "video", "file"].map(modality => [modality, { state: modality === "video" || modality === "file" ? "unsupported" : "unknown", evidence: [] }])),
+                    outputModalities: Object.fromEntries(["text", "image", "audio", "embedding"].map(modality => [modality, { state: "unknown", evidence: [] }])),
+                    tools: { state: "unknown", evidence: [] },
+                    reasoning: { state: "unknown", evidence: [] },
+                    parallelToolCalls: { state: "unknown", evidence: [] },
+                    structuredOutput: { state: "unknown", evidence: [] },
+                    promptCaching: { state: "unknown", evidence: [] },
+                    nativeTokenCounting: { state: "unknown", evidence: [] },
+                    mediaForms: Object.fromEntries(["imageUrl", "imageBase64", "fileId", "audioUrl", "audioBase64"].map(form => [form, { state: "unknown", evidence: [] }])),
+                },
+            };
+            return normalizeCanonicalAdapterInput({ context, tools, resolved, extensions });
+        }
+        return normalizeCanonicalAdapterInput({
+            context,
+            tools,
+            resolved: this.resolvedRuntime,
+            extensions,
+        });
     }
     async complete(context, tools, extensions) {
         if (this.circuit.isOpen())
-            throw new Error("Circuit breaker open");
-        const system = context.systemText || undefined;
-        const contents = buildContents(turnsWithStateAppended(context));
-        const geminiTools = buildTools(tools);
+            throw circuitOpenError("gemini");
+        let input;
+        let plan;
+        try {
+            input = this.adapterInput(context, tools, extensions);
+            plan = this.adapter.buildRequest(input);
+        }
+        catch (error) {
+            throw classifyProviderError("gemini", error);
+        }
         let lastErr;
         for (let i = 0; i < this.maxRetries; i++) {
             try {
-                const vc = this.vendorConfig(extensions);
-                const allTools = [...geminiTools, ...(vc.tools ?? [])];
-                const m = this.genAI.getGenerativeModel({
-                    ...this.modelExtensions(extensions),
-                    model: this.model,
-                    ...(system ? { systemInstruction: system } : {}),
-                    ...(allTools.length ? { tools: allTools } : {}),
-                    ...(vc.generationConfig ? { generationConfig: vc.generationConfig } : {}),
-                }, this.requestOptions);
-                const resp = await m.generateContent({ contents });
+                const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
+                const resp = await m.generateContent(plan.request);
                 this.circuit.recordSuccess();
-                const candidate = resp.response.candidates?.[0];
-                let content = "";
-                const toolCalls = [];
-                for (const part of candidate?.content.parts ?? []) {
-                    if (part.text)
-                        content += part.text;
-                    else if (part.functionCall) {
-                        const tc = normalizeToolCall(part.functionCall.name, part.functionCall.name, part.functionCall.args);
-                        if (tc)
-                            toolCalls.push(tc);
-                    }
-                }
-                const usage = resp.response.usageMetadata;
-                return {
-                    role: "assistant",
-                    content,
-                    tokenCount: usage?.candidatesTokenCount ?? usage?.totalTokenCount,
-                    toolCalls,
-                };
+                return this.adapter.decodeComplete(resp.response, { input }).message;
             }
             catch (err) {
                 lastErr = err;
@@ -166,60 +101,40 @@ export class GeminiProvider {
                     await new Promise(r => setTimeout(r, this.baseDelay * 2 ** i));
             }
         }
-        throw lastErr;
+        throw classifyProviderError("gemini", lastErr);
     }
     async *stream(context, tools, extensions) {
-        const system = context.systemText || undefined;
-        const contents = buildContents(turnsWithStateAppended(context));
-        const geminiTools = buildTools(tools);
-        const vc = this.vendorConfig(extensions);
-        const allTools = [...geminiTools, ...(vc.tools ?? [])];
-        const m = this.genAI.getGenerativeModel({
-            ...this.modelExtensions(extensions),
-            model: this.model,
-            ...(system ? { systemInstruction: system } : {}),
-            ...(allTools.length ? { tools: allTools } : {}),
-            ...(vc.generationConfig ? { generationConfig: vc.generationConfig } : {}),
-        }, this.requestOptions);
-        const result = await m.generateContentStream({ contents });
-        const toolCalls = [];
-        for await (const chunk of result.stream) {
-            for (const part of chunk.candidates?.[0]?.content.parts ?? []) {
-                if (part.text)
-                    yield { type: "text_delta", delta: part.text };
-                else if (part.functionCall) {
-                    const { name, args } = part.functionCall;
-                    toolCalls.push({ id: `call_${toolCalls.length + 1}`, name, args: args });
-                }
+        try {
+            const input = this.adapterInput(context, tools, extensions);
+            const plan = this.adapter.buildRequest(input);
+            const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
+            const result = await m.generateContentStream(plan.request);
+            const state = this.adapter.createStreamState({ input });
+            for await (const chunk of result.stream) {
+                for (const event of this.adapter.pushStreamChunk(chunk, state).events)
+                    yield event;
             }
+            for (const event of this.adapter.finishStream(state, await result.response).events)
+                yield event;
         }
-        for (const tc of toolCalls) {
-            yield { type: "tool_call", id: tc.id, name: tc.name, arguments: tc.args };
-        }
-        const usage = (await result.response).usageMetadata;
-        if (usage?.totalTokenCount) {
-            // Gemini implicit/explicit cache hits are reported as cachedContentTokenCount,
-            // a subset of promptTokenCount (which stays the full prompt for accounting).
-            const cachedTokens = usage.cachedContentTokenCount ?? 0;
-            yield {
-                type: "usage",
-                totalTokens: usage.totalTokenCount,
-                inputTokens: usage.promptTokenCount ?? 0,
-                outputTokens: usage.candidatesTokenCount ?? 0,
-                ...(cachedTokens > 0 ? { cacheReadInputTokens: cachedTokens } : {}),
-            };
+        catch (error) {
+            throw classifyProviderError("gemini", error);
         }
     }
-    modelExtensions(extensions) {
-        if (!extensions)
-            return {};
-        // Strip keys handled explicitly elsewhere (incl. the vendor server-tool / structured-output keys
-        // consumed by `vendorConfig`) so they never leak raw into getGenerativeModel.
-        // Strip keys handled explicitly: the SDK fields set below + the named vendor keys consumed by
-        // `vendorConfig`. A caller-provided raw `generationConfig` still passes through (and is merged with
-        // any structured-output config at the call site).
-        const { model: _model, systemInstruction: _systemInstruction, tools: _tools, google_search: _gs, response_mime_type: _rmt, response_schema: _rs, ...rest } = extensions;
-        return rest;
+    /**
+     * 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.
+     */
+    async countTokens(context, tools, extensions) {
+        const plan = this.adapter.buildRequest(this.adapterInput(context, tools, extensions));
+        const m = this.genAI.getGenerativeModel(plan.modelParams, this.requestOptions);
+        const resp = await m.countTokens(plan.request);
+        return {
+            inputTokens: resp.totalTokens,
+            source: { kind: "native", provider: "gemini" },
+            confidence: "exact",
+        };
     }
     /**
      * Gemini vendor features from extensions, mapped to the Node SDK shape (mirrors the Python provider's
@@ -230,19 +145,6 @@ export class GeminiProvider {
      *    pairing this with google_search).
      */
     vendorConfig(extensions) {
-        const ext = extensions ?? {};
-        const tools = [];
-        if (ext.google_search)
-            tools.push({ googleSearch: typeof ext.google_search === "object" ? ext.google_search : {} });
-        // Seed from any caller-provided raw generationConfig, then layer the named structured-output keys.
-        const gc = { ...ext.generationConfig };
-        if (ext.response_mime_type != null)
-            gc.responseMimeType = ext.response_mime_type;
-        if (ext.response_schema != null)
-            gc.responseSchema = ext.response_schema;
-        return {
-            ...(tools.length ? { tools } : {}),
-            ...(Object.keys(gc).length ? { generationConfig: gc } : {}),
-        };
+        return geminiVendorConfig(extensions ?? {});
     }
 }