@intx/inference-discovery-google-genai 0.2.2 → 0.4.0

package/README.md

@@ -9,12 +9,17 @@ for the runtime, the plug-in contract, and the `discover` CLI.
 
 ## Models
 
-- `gemini-2.5-flash` — text, vision, audio, video, document,
-  function calling (multi-turn and with-thinking), code execution,
-  grounding, and the files API. Streaming and non-streaming
-  variants of each.
-- `gemini-2.5-flash-image` — image output, streaming and
-  non-streaming.
+- `gemini-2.5-flash` / `gemini-3.5-flash` — text multimodal surface
+  (vision, audio, video, document, function calling, code execution,
+  grounding, safety classification, structured output, files API).
+  Streaming and non-streaming variants of each. These models accept
+  a zero thinking budget when the probe wants thinking suppressed.
+- `gemini-3.6-flash` / `gemini-2.5-pro` — same text multimodal
+  surface, but they reject a zero thinking budget, so the request
+  builder uses the dynamic thinking budget (`-1`) on the suppress
+  path.
+- `gemini-2.5-flash-image` / `gemini-3.1-flash-image` — image
+  output, streaming and non-streaming.
 
 The full per-capability list is in `SUPPORT_MATRIX` in
 `@intx/inference-discovery/catalog`.
@@ -57,7 +62,8 @@ runner writes the bundle:
   `function-calling-with-thinking`,
   `function-calling-with-thinking-streaming`) — turn 1 is sent as
   usual; the plug-in extracts the model's assistant content from
-  the parsed response, derives a tool follow-up from the intent's
+  the parsed response (reconstructing it from the SSE stream when
+  turn-1 is streamed), derives a tool follow-up from the intent's
   `followUp` (or synthesises one from the intent's tools), and
   sends a turn-2 body that echoes the assistant turn verbatim and
   appends the tool response. Each turn writes its own `turn-1/` and

package/dist/index.d.ts

@@ -1,6 +1,12 @@
-import type { CaptureStep, CapturedResponse, IterateCaptureStepsOpts, ProviderPlugin } from "@intx/inference-discovery";
+import { type CaptureStep, type CapturedResponse, type IterateCaptureStepsOpts, type ProviderPlugin } from "@intx/inference-discovery";
+import { type GeminiModelClass } from "./request-body.js";
+export type { GeminiModelClass } from "./request-body.js";
+export { isKnownModel } from "./request-body.js";
 export interface GoogleGenaiPluginOptions {
     apiKey: string;
+    modelClass?: GeminiModelClass | undefined;
 }
-export declare function iterateCaptureSteps(opts: IterateCaptureStepsOpts): Generator<CaptureStep, void, CapturedResponse>;
+export declare function iterateCaptureSteps(opts: IterateCaptureStepsOpts & {
+    modelClass?: GeminiModelClass | undefined;
+}): Generator<CaptureStep, void, CapturedResponse>;
 export declare function createGoogleGenaiPlugin(opts: GoogleGenaiPluginOptions): ProviderPlugin;

package/dist/index.js

@@ -1,10 +1,22 @@
 import { readFileSync } from "node:fs";
 import { resolveMediaPath, } from "@intx/inference-discovery/catalog";
+import { resolveTurn1Response, } from "@intx/inference-discovery";
 import { buildAuthHeaders } from "./auth.js";
 import { buildEndpointURL } from "./endpoint.js";
 import { buildRequestBody } from "./request-body.js";
+import { reconstructResponseFromSSE } from "./sse.js";
+export { isKnownModel } from "./request-body.js";
 const PROVIDER_NAME = "google-genai";
-const MODELS = ["gemini-2.5-flash", "gemini-2.5-flash-image"];
+const MODELS = [
+    "gemini-2.5-flash",
+    "gemini-2.5-flash-image",
+    "gemini-2.5-pro",
+    "gemini-3.6-flash",
+    "gemini-3.5-flash",
+    "gemini-3.1-flash-image",
+    "gemini-3-flash-preview",
+    "gemini-3.1-pro-preview",
+];
 const REDACT_REQUEST_HEADERS = ["x-goog-api-key"];
 const REDACT_RESPONSE_HEADERS = [];
 const FILES_API_UPLOAD_URL = "https://generativelanguage.googleapis.com/upload/v1beta/files";
@@ -172,12 +184,11 @@ function buildMultiTurnTurn2Body(opts) {
     return body;
 }
 export function* iterateCaptureSteps(opts) {
-    const { model, capability, intent } = opts;
+    const { model, capability, intent, modelClass } = opts;
     if (FILES_API_CAPABILITIES.has(capability)) {
         const upload = buildUploadDescriptor(intent);
         const uploadResponse = yield {
             kind: "raw",
-            subdir: "upload",
             url: upload.url,
             method: "POST",
             contentType: upload.mimeType,
@@ -196,18 +207,21 @@ export function* iterateCaptureSteps(opts) {
         });
         yield {
             kind: "json",
-            subdir: "generate",
             url: buildEndpointURL({ model, capability }),
             body: generateBody,
         };
         return;
     }
     if (MULTI_TURN_CAPABILITIES.has(capability)) {
-        const turn1Body = buildRequestBody({ model, capability, intent });
+        const turn1Body = buildRequestBody({
+            model,
+            capability,
+            intent,
+            modelClass,
+        });
         const url = buildEndpointURL({ model, capability });
         const turn1Response = yield {
             kind: "json",
-            subdir: "turn-1",
             url,
             body: turn1Body,
         };
@@ -215,11 +229,10 @@ export function* iterateCaptureSteps(opts) {
             capability,
             intent,
             turn1Body,
-            turn1Response: turn1Response.parsed,
+            turn1Response: resolveTurn1Response(turn1Response, reconstructResponseFromSSE),
         });
         yield {
             kind: "json",
-            subdir: "turn-2",
             url,
             body: turn2Body,
         };
@@ -227,19 +240,18 @@ export function* iterateCaptureSteps(opts) {
     }
     yield {
         kind: "json",
-        subdir: null,
         url: buildEndpointURL({ model, capability }),
-        body: buildRequestBody({ model, capability, intent }),
+        body: buildRequestBody({ model, capability, intent, modelClass }),
     };
 }
 export function createGoogleGenaiPlugin(opts) {
-    const apiKey = opts.apiKey;
+    const { apiKey, modelClass } = opts;
     return {
         name: PROVIDER_NAME,
         models: MODELS,
         redactRequestHeaders: REDACT_REQUEST_HEADERS,
         redactResponseHeaders: REDACT_RESPONSE_HEADERS,
         buildAuthHeaders: () => buildAuthHeaders(apiKey),
-        iterateCaptureSteps,
+        iterateCaptureSteps: (stepOpts) => iterateCaptureSteps({ ...stepOpts, modelClass }),
     };
 }

package/dist/request-body.d.ts

@@ -1,4 +1,6 @@
 import { type Capability, type CapabilityIntent, type ToolDecl } from "@intx/inference-discovery/catalog";
+export declare const TEXT_MODELS: ReadonlySet<string>;
+export declare const IMAGE_MODELS: ReadonlySet<string>;
 interface GeminiTextPart {
     text: string;
 }
@@ -57,9 +59,12 @@ interface GeminiRequestBody {
     toolConfig?: GeminiToolConfig;
     generationConfig?: GeminiGenerationConfig;
 }
+export type GeminiModelClass = "text" | "image";
+export declare function isKnownModel(model: string): boolean;
 export declare function buildRequestBody(opts: {
     model: string;
     capability: Capability;
     intent: CapabilityIntent;
+    modelClass?: GeminiModelClass | undefined;
 }): GeminiRequestBody;
 export {};

package/dist/request-body.js

@@ -1,7 +1,20 @@
 import { readFileSync } from "node:fs";
-import { resolveMediaPath, } from "@intx/inference-discovery/catalog";
-const TEXT_MODEL = "gemini-2.5-flash";
-const IMAGE_MODEL = "gemini-2.5-flash-image";
+import { CapabilityNotBuildableError, resolveMediaPath, } from "@intx/inference-discovery/catalog";
+// Text models share the full multimodal text capability surface; only
+// thinking-budget handling differs for models that cannot disable thinking
+// (see minimalThinkingBudget). Image models are output-only.
+export const TEXT_MODELS = new Set([
+    "gemini-2.5-flash",
+    "gemini-2.5-pro",
+    "gemini-3.6-flash",
+    "gemini-3.5-flash",
+    "gemini-3-flash-preview",
+    "gemini-3.1-pro-preview",
+]);
+export const IMAGE_MODELS = new Set([
+    "gemini-2.5-flash-image",
+    "gemini-3.1-flash-image",
+]);
 const TEXT_MODEL_CAPABILITIES = new Set([
     "plain-text",
     "plain-text-streaming",
@@ -47,20 +60,26 @@ const EXTENSION_TO_MIME_TYPE = {
     webm: "video/webm",
     pdf: "application/pdf",
 };
-function modelSupportsCapability(model, capability) {
-    if (model === TEXT_MODEL) {
-        if (!TEXT_MODEL_CAPABILITIES.has(capability)) {
-            throw new Error(`google-genai: model ${model} does not support capability ${capability}`);
-        }
-        return;
-    }
-    if (model === IMAGE_MODEL) {
-        if (!IMAGE_MODEL_CAPABILITIES.has(capability)) {
-            throw new Error(`google-genai: model ${model} does not support capability ${capability}`);
-        }
-        return;
+function classifyModel(model, override) {
+    if (TEXT_MODELS.has(model))
+        return "text";
+    if (IMAGE_MODELS.has(model))
+        return "image";
+    return override ?? "text";
+}
+// True when the model's class is known from set membership, so its request
+// shape is not a guess. A caller (the probe) uses this to tell an operator when
+// it is defaulting an unknown model to the text class rather than classifying a
+// known one — the default is deliberate, but it should never be silent.
+export function isKnownModel(model) {
+    return TEXT_MODELS.has(model) || IMAGE_MODELS.has(model);
+}
+function assertCapabilityBuildable(model, capability, modelClass) {
+    const resolved = classifyModel(model, modelClass);
+    const supported = resolved === "image" ? IMAGE_MODEL_CAPABILITIES : TEXT_MODEL_CAPABILITIES;
+    if (!supported.has(capability)) {
+        throw new CapabilityNotBuildableError(capability, `google-genai: ${resolved}-class model ${model} does not support capability ${capability}`);
     }
-    throw new Error(`google-genai: unknown model ${model}`);
 }
 function extensionFor(path) {
     const dot = path.lastIndexOf(".");
@@ -114,18 +133,38 @@ function userTextContent(prompt) {
         parts: [{ text: prompt }],
     };
 }
+// Gemini's "dynamic" thinking budget sentinel: the model decides how much to
+// think and no cap is imposed.
+const DYNAMIC_THINKING_BUDGET = -1;
+// gemini-2.5-pro rejects thinkingConfig.thinkingBudget: 0 with HTTP 400
+// "Budget 0 is invalid. This model only works in thinking mode." The budget can
+// only be chosen by model identity, because the API surfaces the constraint
+// solely as a runtime 400 with no build-time signal. Add a model here when its
+// API rejects a zero thinking budget.
+const THINKING_MANDATORY_MODELS = new Set([
+    "gemini-2.5-pro",
+    "gemini-3.6-flash",
+    "gemini-3.1-pro-preview",
+]);
+// The thinking budget to request when a probe wants thinking suppressed: 0
+// (fully off) for models that allow it, or the dynamic budget for models that
+// cannot be set to 0. includeThoughts stays false in both cases, so no thought
+// parts are returned either way.
+function minimalThinkingBudget(model) {
+    return THINKING_MANDATORY_MODELS.has(model) ? DYNAMIC_THINKING_BUDGET : 0;
+}
 function plainTextBody(intent) {
     return {
         contents: [userTextContent(intent.prompt)],
     };
 }
-function plainTextStreamingBody(intent) {
+function plainTextStreamingBody(intent, model) {
     return {
         contents: [userTextContent(intent.prompt)],
         generationConfig: {
             maxOutputTokens: 400,
             thinkingConfig: {
-                thinkingBudget: 0,
+                thinkingBudget: minimalThinkingBudget(model),
             },
         },
     };
@@ -238,16 +277,16 @@ function structuredOutputBody(intent) {
     return body;
 }
 export function buildRequestBody(opts) {
-    modelSupportsCapability(opts.model, opts.capability);
+    assertCapabilityBuildable(opts.model, opts.capability, opts.modelClass);
     switch (opts.capability) {
         case "plain-text":
             return plainTextBody(opts.intent);
         case "plain-text-streaming":
-            return plainTextStreamingBody(opts.intent);
+            return plainTextStreamingBody(opts.intent, opts.model);
         case "function-calling-multi-turn":
         case "function-calling-multi-turn-streaming":
             return functionCallingBody(opts.intent, {
-                budget: 0,
+                budget: minimalThinkingBudget(opts.model),
                 includeThoughts: false,
             });
         case "function-calling-with-thinking":
@@ -288,7 +327,8 @@ export function buildRequestBody(opts) {
         case "reasoning-content-streaming":
         case "redacted-thinking":
         case "redacted-thinking-streaming":
-            throw new Error(`google-genai: capability ${opts.capability} is not supported by any google-genai model`);
+        case "structured-output-refusal-streaming":
+            throw new CapabilityNotBuildableError(opts.capability, `google-genai: capability ${opts.capability} is not supported by any google-genai model`);
         default: {
             const exhaustive = opts.capability;
             throw new Error(`google-genai: unhandled capability ${String(exhaustive)}`);

package/dist/sse.d.ts

@@ -0,0 +1 @@
+export declare function reconstructResponseFromSSE(bytes: Uint8Array): unknown;

package/dist/sse.js

@@ -0,0 +1,109 @@
+// Gemini streams generateContent as Server-Sent Events: each `data: {json}`
+// line is a full GenerateContentResponse chunk whose candidates[0].content.parts
+// carry incremental deltas. To build a turn-2 multi-turn body for a streaming
+// capability, the assistant content has to be reconstructed from those chunks.
+//
+// Reconstruction flattens every chunk's parts in order and coalesces
+// consecutive text deltas that share the same shape — plain text (`{text}`)
+// with plain text, and thought text (`{text, thought: true}`) with thought
+// text — but never across shapes. Every non-text part (a functionCall, or any
+// part carrying a thoughtSignature) is emitted as-is, in order, so the
+// signature the API requires on an echoed thinking turn survives.
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// The coalescing signature of a streamed text delta, or null when the part is
+// not a plain text delta (a functionCall, a thoughtSignature-bearing part, …)
+// and must therefore stand as its own part.
+function textDeltaSignature(part) {
+    if (typeof part.text !== "string")
+        return null;
+    const keys = Object.keys(part);
+    if (keys.length === 1)
+        return "text";
+    if (keys.length === 2 && part.thought === true)
+        return "thought-text";
+    // A text delta carrying any further key (notably a thoughtSignature) is not
+    // coalescible: it stays its own part so the signature's exact placement in
+    // the thought stream survives verbatim into the echoed turn-2 content.
+    return null;
+}
+function sseDataPayloads(bytes) {
+    const text = new TextDecoder().decode(bytes);
+    const payloads = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (!line.startsWith("data:"))
+            continue;
+        const payload = line.slice("data:".length).trim();
+        if (payload.length > 0 && payload !== "[DONE]")
+            payloads.push(payload);
+    }
+    return payloads;
+}
+// Reconstructs the shape a non-streaming turn-1 response would have —
+// `{ candidates: [{ content: { role, parts } }] }` — from a Gemini SSE stream,
+// so the multi-turn turn-2 builder consumes it unchanged.
+export function reconstructResponseFromSSE(bytes) {
+    const payloads = sseDataPayloads(bytes);
+    if (payloads.length === 0) {
+        throw new Error("google-genai SSE: stream carried no data payloads to reconstruct");
+    }
+    let role;
+    const parts = [];
+    let lastSignature = null;
+    for (const payload of payloads) {
+        const chunk = JSON.parse(payload);
+        if (!isRecord(chunk)) {
+            throw new Error("google-genai SSE: chunk is not a JSON object");
+        }
+        const candidates = chunk.candidates;
+        // Some trailing chunks carry only usageMetadata and no candidates.
+        if (candidates === undefined)
+            continue;
+        if (!Array.isArray(candidates) || candidates.length === 0) {
+            throw new Error("google-genai SSE: chunk.candidates is not a non-empty array");
+        }
+        const first = candidates[0];
+        if (!isRecord(first)) {
+            throw new Error("google-genai SSE: candidates[0] is not an object");
+        }
+        const content = first.content;
+        // A finishReason-only chunk closes the candidate without new content.
+        if (content === undefined)
+            continue;
+        if (!isRecord(content)) {
+            throw new Error("google-genai SSE: candidates[0].content is not an object");
+        }
+        if (typeof content.role === "string")
+            role = content.role;
+        const chunkParts = content.parts;
+        if (chunkParts === undefined)
+            continue;
+        if (!Array.isArray(chunkParts)) {
+            throw new Error("google-genai SSE: candidates[0].content.parts is not an array");
+        }
+        for (const part of chunkParts) {
+            if (!isRecord(part)) {
+                throw new Error("google-genai SSE: a content part is not an object");
+            }
+            const signature = textDeltaSignature(part);
+            const previous = parts[parts.length - 1];
+            if (signature !== null &&
+                signature === lastSignature &&
+                previous !== undefined) {
+                previous.text = `${String(previous.text)}${String(part.text)}`;
+            }
+            else {
+                parts.push({ ...part });
+                lastSignature = signature;
+            }
+        }
+    }
+    // The assistant role must come off the wire; defaulting it would fabricate a
+    // turn-1 shape the model never sent and mask a provider change the probe
+    // exists to catch. Gemini emits role on the first content-bearing chunk.
+    if (role === undefined) {
+        throw new Error("google-genai SSE: no candidate content carried a role; cannot reconstruct the assistant turn");
+    }
+    return { candidates: [{ content: { role, parts } }] };
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@intx/inference-discovery-google-genai",
-  "version": "0.2.2",
+  "description": "Google GenAI provider plug-in for the inference discovery rig",
+  "version": "0.4.0",
   "license": "LGPL-2.1-only",
   "type": "module",
   "exports": {
@@ -11,7 +12,7 @@
     }
   },
   "dependencies": {
-    "@intx/inference-discovery": "0.2.2",
+    "@intx/inference-discovery": "0.4.0",
     "arktype": "^2.1.29"
   },
   "files": [