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

package/dist/request-body.js

@@ -0,0 +1,297 @@
+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";
+const TEXT_MODEL_CAPABILITIES = new Set([
+    "plain-text",
+    "plain-text-streaming",
+    "function-calling-multi-turn",
+    "function-calling-multi-turn-streaming",
+    "function-calling-with-thinking",
+    "function-calling-with-thinking-streaming",
+    "vision-input",
+    "vision-input-streaming",
+    "audio-input",
+    "audio-input-streaming",
+    "video-input",
+    "video-input-streaming",
+    "document-input",
+    "document-input-streaming",
+    "code-execution",
+    "code-execution-streaming",
+    "grounding",
+    "grounding-streaming",
+    "files-api-reference",
+    "files-api-reference-streaming",
+    "safety-classification",
+    "safety-classification-streaming",
+    "structured-output",
+    "structured-output-streaming",
+]);
+const IMAGE_MODEL_CAPABILITIES = new Set([
+    "image-output",
+    "image-output-streaming",
+]);
+const EXTENSION_TO_MIME_TYPE = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    wav: "audio/wav",
+    mp3: "audio/mpeg",
+    ogg: "audio/ogg",
+    flac: "audio/flac",
+    mp4: "video/mp4",
+    mov: "video/quicktime",
+    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;
+    }
+    throw new Error(`google-genai: unknown model ${model}`);
+}
+function extensionFor(path) {
+    const dot = path.lastIndexOf(".");
+    if (dot < 0 || dot === path.length - 1) {
+        throw new Error(`google-genai: cannot infer media MIME type, no extension in path: ${path}`);
+    }
+    return path.slice(dot + 1).toLowerCase();
+}
+function mimeTypeFor(ref) {
+    const ext = extensionFor(ref.path);
+    const mime = EXTENSION_TO_MIME_TYPE[ext];
+    if (mime === undefined) {
+        throw new Error(`google-genai: no MIME type mapping for extension .${ext} (path ${ref.path})`);
+    }
+    return mime;
+}
+function readMediaBase64(ref) {
+    const absolute = resolveMediaPath(ref);
+    const bytes = readFileSync(absolute);
+    return bytes.toString("base64");
+}
+function expectSingleMedia(intent) {
+    if (intent.media === undefined || intent.media.length === 0) {
+        throw new Error("google-genai: media-input capability requires intent.media to be non-empty");
+    }
+    if (intent.media.length !== 1) {
+        throw new Error(`google-genai: media-input capability expects exactly one media reference, got ${String(intent.media.length)}`);
+    }
+    const [media] = intent.media;
+    if (media === undefined) {
+        throw new Error("google-genai: media-input capability: media[0] is unexpectedly undefined");
+    }
+    return media;
+}
+function expectSingleTool(intent) {
+    if (intent.tools === undefined || intent.tools.length === 0) {
+        throw new Error("google-genai: function-calling capability requires intent.tools to be non-empty");
+    }
+    if (intent.tools.length !== 1) {
+        throw new Error(`google-genai: function-calling capability expects exactly one tool declaration, got ${String(intent.tools.length)}`);
+    }
+    const [tool] = intent.tools;
+    if (tool === undefined) {
+        throw new Error("google-genai: function-calling capability: tools[0] is unexpectedly undefined");
+    }
+    return tool;
+}
+function userTextContent(prompt) {
+    return {
+        role: "user",
+        parts: [{ text: prompt }],
+    };
+}
+function plainTextBody(intent) {
+    return {
+        contents: [userTextContent(intent.prompt)],
+    };
+}
+function plainTextStreamingBody(intent) {
+    return {
+        contents: [userTextContent(intent.prompt)],
+        generationConfig: {
+            maxOutputTokens: 400,
+            thinkingConfig: {
+                thinkingBudget: 0,
+            },
+        },
+    };
+}
+function functionToolFromDecl(decl) {
+    return {
+        functionDeclarations: [
+            {
+                name: decl.name,
+                description: decl.description,
+                parameters: decl.parameters,
+            },
+        ],
+    };
+}
+function functionCallingBody(intent, thinking) {
+    const decl = expectSingleTool(intent);
+    const thinkingConfig = thinking.includeThoughts
+        ? { thinkingBudget: thinking.budget, includeThoughts: true }
+        : { thinkingBudget: thinking.budget };
+    return {
+        contents: [userTextContent(intent.prompt)],
+        tools: [functionToolFromDecl(decl)],
+        toolConfig: {
+            functionCallingConfig: {
+                mode: "ANY",
+                allowedFunctionNames: [decl.name],
+            },
+        },
+        generationConfig: {
+            thinkingConfig,
+        },
+    };
+}
+function inlineMediaBody(intent) {
+    const media = expectSingleMedia(intent);
+    return {
+        contents: [
+            {
+                role: "user",
+                parts: [
+                    { text: intent.prompt },
+                    {
+                        inlineData: {
+                            mimeType: mimeTypeFor(media),
+                            data: readMediaBase64(media),
+                        },
+                    },
+                ],
+            },
+        ],
+    };
+}
+function imageOutputBody(intent) {
+    return {
+        contents: [userTextContent(intent.prompt)],
+        generationConfig: {
+            responseModalities: ["TEXT", "IMAGE"],
+        },
+    };
+}
+function codeExecutionBody(intent) {
+    return {
+        contents: [userTextContent(intent.prompt)],
+        tools: [{ codeExecution: {} }],
+    };
+}
+function groundingBody(intent) {
+    return {
+        contents: [userTextContent(intent.prompt)],
+        tools: [{ googleSearch: {} }],
+    };
+}
+// Shape-identical between streaming and non-streaming variants — only the
+// endpoint differs (handled by buildEndpointURL). The streaming variant
+// deliberately does NOT clamp `thinkingBudget: 0` the way plain-text
+// streaming does: the safety classifier's engagement may depend on
+// whether the model goes through a thinking phase, and the probe's job
+// is to observe natural classifier behavior at default generation
+// settings, not constrained ones.
+function safetyClassificationBody(intent) {
+    return {
+        contents: [userTextContent(intent.prompt)],
+    };
+}
+function structuredOutputBody(intent) {
+    const format = intent.responseFormat;
+    if (format === undefined) {
+        throw new Error("google-genai: structured-output intent has no responseFormat");
+    }
+    const generationConfig = {};
+    switch (format.kind) {
+        case "text":
+            // Free-form text is Gemini's default; emit no responseMimeType.
+            break;
+        case "json":
+            generationConfig.responseMimeType = "application/json";
+            break;
+        case "json-schema":
+            generationConfig.responseMimeType = "application/json";
+            generationConfig.responseSchema = format.schema;
+            break;
+    }
+    const body = {
+        contents: [userTextContent(intent.prompt)],
+    };
+    if (Object.keys(generationConfig).length > 0) {
+        body.generationConfig = generationConfig;
+    }
+    return body;
+}
+export function buildRequestBody(opts) {
+    modelSupportsCapability(opts.model, opts.capability);
+    switch (opts.capability) {
+        case "plain-text":
+            return plainTextBody(opts.intent);
+        case "plain-text-streaming":
+            return plainTextStreamingBody(opts.intent);
+        case "function-calling-multi-turn":
+        case "function-calling-multi-turn-streaming":
+            return functionCallingBody(opts.intent, {
+                budget: 0,
+                includeThoughts: false,
+            });
+        case "function-calling-with-thinking":
+        case "function-calling-with-thinking-streaming":
+            return functionCallingBody(opts.intent, {
+                budget: 1024,
+                includeThoughts: true,
+            });
+        case "vision-input":
+        case "vision-input-streaming":
+        case "audio-input":
+        case "audio-input-streaming":
+        case "video-input":
+        case "video-input-streaming":
+        case "document-input":
+        case "document-input-streaming":
+            return inlineMediaBody(opts.intent);
+        case "image-output":
+        case "image-output-streaming":
+            return imageOutputBody(opts.intent);
+        case "code-execution":
+        case "code-execution-streaming":
+            return codeExecutionBody(opts.intent);
+        case "grounding":
+        case "grounding-streaming":
+            return groundingBody(opts.intent);
+        case "safety-classification":
+        case "safety-classification-streaming":
+            return safetyClassificationBody(opts.intent);
+        case "structured-output":
+        case "structured-output-streaming":
+            return structuredOutputBody(opts.intent);
+        case "files-api-reference":
+        case "files-api-reference-streaming":
+            throw new Error(`google-genai: capability ${opts.capability} is multi-step; use iterateCaptureSteps from the plug-in, not buildRequestBody.`);
+        case "function-calling":
+        case "reasoning-content":
+        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`);
+        default: {
+            const exhaustive = opts.capability;
+            throw new Error(`google-genai: unhandled capability ${String(exhaustive)}`);
+        }
+    }
+}

package/package.json

@@ -1,16 +1,26 @@
 {
   "name": "@intx/inference-discovery-google-genai",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "license": "LGPL-2.1-only",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "intx-src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
   "dependencies": {
-    "@intx/inference-discovery": "0.0.0",
+    "@intx/inference-discovery": "0.2.2",
     "arktype": "^2.1.29"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/auth.ts

@@ -1,8 +0,0 @@
-export const AUTH_HEADER = "x-goog-api-key";
-
-export function buildAuthHeaders(apiKey: string): Record<string, string> {
-  if (apiKey.length === 0) {
-    throw new Error("google-genai: apiKey must be a non-empty string");
-  }
-  return { [AUTH_HEADER]: apiKey };
-}

package/src/endpoint.ts

@@ -1,20 +0,0 @@
-import type { Capability } from "@intx/inference-discovery/catalog";
-
-export const GEMINI_BASE = "https://generativelanguage.googleapis.com/v1beta";
-
-export function isStreamingCapability(capability: Capability): boolean {
-  return capability.endsWith("-streaming");
-}
-
-export function buildEndpointURL(opts: {
-  model: string;
-  capability: Capability;
-}): string {
-  if (opts.model.length === 0) {
-    throw new Error("google-genai: model must be a non-empty string");
-  }
-  if (isStreamingCapability(opts.capability)) {
-    return `${GEMINI_BASE}/models/${opts.model}:streamGenerateContent?alt=sse`;
-  }
-  return `${GEMINI_BASE}/models/${opts.model}:generateContent`;
-}

package/src/index.ts

@@ -1,327 +0,0 @@
-import { readFileSync } from "node:fs";
-import {
-  resolveMediaPath,
-  type Capability,
-  type CapabilityIntent,
-  type MediaRef,
-} from "@intx/inference-discovery/catalog";
-import type {
-  CaptureStep,
-  CapturedResponse,
-  IterateCaptureStepsOpts,
-  ProviderPlugin,
-} from "@intx/inference-discovery";
-import { buildAuthHeaders } from "./auth";
-import { buildEndpointURL } from "./endpoint";
-import { buildRequestBody } from "./request-body";
-
-const PROVIDER_NAME = "google-genai";
-const MODELS = ["gemini-2.5-flash", "gemini-2.5-flash-image"] as const;
-const REDACT_REQUEST_HEADERS = ["x-goog-api-key"] as const;
-const REDACT_RESPONSE_HEADERS: readonly string[] = [];
-
-const FILES_API_UPLOAD_URL =
-  "https://generativelanguage.googleapis.com/upload/v1beta/files";
-
-const MULTI_TURN_CAPABILITIES: ReadonlySet<Capability> = new Set<Capability>([
-  "function-calling-multi-turn",
-  "function-calling-multi-turn-streaming",
-  "function-calling-with-thinking",
-  "function-calling-with-thinking-streaming",
-]);
-
-const FILES_API_CAPABILITIES: ReadonlySet<Capability> = new Set<Capability>([
-  "files-api-reference",
-  "files-api-reference-streaming",
-]);
-
-export interface GoogleGenaiPluginOptions {
-  apiKey: string;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-interface UploadStepDescriptor {
-  url: string;
-  mimeType: string;
-  displayName: string;
-  bytes: Uint8Array;
-}
-
-function buildUploadDescriptor(intent: CapabilityIntent): UploadStepDescriptor {
-  const media = intent.media?.[0];
-  if (media === undefined) {
-    throw new Error(
-      "google-genai files-API: intent.media[0] is required; the catalog's " +
-        "files-api-reference intent must declare the document to upload.",
-    );
-  }
-  const bytes = readFileSync(resolveMediaPath(media));
-  return {
-    url: FILES_API_UPLOAD_URL,
-    mimeType: mimeTypeForMedia(media),
-    displayName: basename(media.path),
-    bytes: new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength),
-  };
-}
-
-function basename(path: string): string {
-  const slash = path.lastIndexOf("/");
-  return slash < 0 ? path : path.slice(slash + 1);
-}
-
-function mimeTypeForMedia(ref: MediaRef): string {
-  if (ref.kind === "document") return "application/pdf";
-  if (ref.kind === "image") return "image/jpeg";
-  if (ref.kind === "audio") return "audio/wav";
-  if (ref.kind === "video") return "video/mp4";
-  throw new Error(`google-genai: unsupported media kind ${String(ref.kind)}`);
-}
-
-function extractFileUri(parsed: unknown): string {
-  if (!isRecord(parsed)) {
-    throw new Error(
-      "google-genai files-API: upload response is not a JSON object",
-    );
-  }
-  const file = parsed.file;
-  if (!isRecord(file)) {
-    throw new Error(
-      "google-genai files-API: upload response missing 'file' object",
-    );
-  }
-  const uri = file.uri;
-  if (typeof uri !== "string" || uri.length === 0) {
-    throw new Error(
-      "google-genai files-API: upload response has no string 'file.uri'",
-    );
-  }
-  return uri;
-}
-
-function extractMimeTypeFromUpload(parsed: unknown): string {
-  if (!isRecord(parsed)) {
-    throw new Error(
-      "google-genai files-API: upload response is not a JSON object",
-    );
-  }
-  const file = parsed.file;
-  if (!isRecord(file)) {
-    throw new Error(
-      "google-genai files-API: upload response missing 'file' object",
-    );
-  }
-  const mime = file.mimeType;
-  if (typeof mime !== "string" || mime.length === 0) {
-    throw new Error(
-      "google-genai files-API: upload response has no string 'file.mimeType'",
-    );
-  }
-  return mime;
-}
-
-function buildFilesApiGenerateBody(opts: {
-  intent: CapabilityIntent;
-  fileUri: string;
-  mimeType: string;
-}): unknown {
-  return {
-    contents: [
-      {
-        role: "user",
-        parts: [
-          { text: opts.intent.prompt },
-          {
-            fileData: {
-              mimeType: opts.mimeType,
-              fileUri: opts.fileUri,
-            },
-          },
-        ],
-      },
-    ],
-  };
-}
-
-function extractAssistantContent(parsed: unknown): unknown {
-  if (!isRecord(parsed)) {
-    throw new Error(
-      "google-genai multi-turn: turn-1 response is not a JSON object",
-    );
-  }
-  const candidates = parsed.candidates;
-  if (!Array.isArray(candidates) || candidates.length === 0) {
-    throw new Error(
-      "google-genai multi-turn: turn-1 response has no candidates array",
-    );
-  }
-  const first = candidates[0];
-  if (!isRecord(first)) {
-    throw new Error(
-      "google-genai multi-turn: turn-1 response candidates[0] is not an object",
-    );
-  }
-  const content = first.content;
-  if (!isRecord(content)) {
-    throw new Error(
-      "google-genai multi-turn: turn-1 response candidates[0].content is not an object",
-    );
-  }
-  return content;
-}
-
-function deriveToolFollowUp(intent: CapabilityIntent): {
-  toolName: string;
-  content: string;
-} {
-  const followUp = intent.followUp;
-  if (followUp !== undefined) {
-    for (const step of followUp) {
-      if (step.role === "tool") {
-        return { toolName: step.toolName, content: step.content };
-      }
-    }
-  }
-  const tools = intent.tools;
-  if (tools === undefined || tools.length === 0) {
-    throw new Error(
-      "google-genai multi-turn: intent has neither followUp nor tools",
-    );
-  }
-  const [tool] = tools;
-  if (tool === undefined) {
-    throw new Error("google-genai multi-turn: intent.tools[0] is undefined");
-  }
-  return { toolName: tool.name, content: "{}" };
-}
-
-function buildMultiTurnTurn2Body(opts: {
-  capability: Capability;
-  intent: CapabilityIntent;
-  turn1Body: unknown;
-  turn1Response: unknown;
-}): unknown {
-  if (!isRecord(opts.turn1Body)) {
-    throw new Error("google-genai multi-turn: turn-1 body is not an object");
-  }
-  const turn1Contents = opts.turn1Body.contents;
-  if (!Array.isArray(turn1Contents)) {
-    throw new Error(
-      "google-genai multi-turn: turn-1 body.contents is not an array",
-    );
-  }
-  const assistantContent = extractAssistantContent(opts.turn1Response);
-  const tool = deriveToolFollowUp(opts.intent);
-  const toolResponseObject: unknown = JSON.parse(tool.content);
-
-  const turn1Tools = opts.turn1Body.tools;
-  const turn1GenerationConfig = opts.turn1Body.generationConfig;
-
-  const body: Record<string, unknown> = {
-    contents: [
-      ...turn1Contents,
-      assistantContent,
-      {
-        role: "user",
-        parts: [
-          {
-            functionResponse: {
-              name: tool.toolName,
-              response: toolResponseObject,
-            },
-          },
-        ],
-      },
-    ],
-  };
-  if (turn1Tools !== undefined) {
-    body.tools = turn1Tools;
-  }
-  if (turn1GenerationConfig !== undefined) {
-    body.generationConfig = turn1GenerationConfig;
-  }
-  return body;
-}
-
-export function* iterateCaptureSteps(
-  opts: IterateCaptureStepsOpts,
-): Generator<CaptureStep, void, CapturedResponse> {
-  const { model, capability, intent } = 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,
-      headers: {
-        "X-Goog-Upload-Protocol": "raw",
-        "X-Goog-Upload-File-Name": upload.displayName,
-      },
-      body: upload.bytes,
-    };
-    const fileUri = extractFileUri(uploadResponse.parsed);
-    const mimeType = extractMimeTypeFromUpload(uploadResponse.parsed);
-    const generateBody = buildFilesApiGenerateBody({
-      intent,
-      fileUri,
-      mimeType,
-    });
-    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 url = buildEndpointURL({ model, capability });
-    const turn1Response = yield {
-      kind: "json",
-      subdir: "turn-1",
-      url,
-      body: turn1Body,
-    };
-    const turn2Body = buildMultiTurnTurn2Body({
-      capability,
-      intent,
-      turn1Body,
-      turn1Response: turn1Response.parsed,
-    });
-    yield {
-      kind: "json",
-      subdir: "turn-2",
-      url,
-      body: turn2Body,
-    };
-    return;
-  }
-
-  yield {
-    kind: "json",
-    subdir: null,
-    url: buildEndpointURL({ model, capability }),
-    body: buildRequestBody({ model, capability, intent }),
-  };
-}
-
-export function createGoogleGenaiPlugin(
-  opts: GoogleGenaiPluginOptions,
-): ProviderPlugin {
-  const apiKey = opts.apiKey;
-  return {
-    name: PROVIDER_NAME,
-    models: MODELS,
-    redactRequestHeaders: REDACT_REQUEST_HEADERS,
-    redactResponseHeaders: REDACT_RESPONSE_HEADERS,
-    buildAuthHeaders: () => buildAuthHeaders(apiKey),
-    iterateCaptureSteps,
-  };
-}