theorum 0.1.2 → 0.1.3

package/esm/src/kernel/registry/resolve.js

@@ -7,22 +7,17 @@
  * @module
  */
 import { TheorumError } from '../../guardrails/error.js';
-import { resolveGeminiBucket } from '../../guardrails/keys.js';
 import { sanitizeTurnRequest } from '../../guardrails/sanitize.js';
-import { assertImageGrounding, resolveImageFormat, resolveInputParts, } from '../../providers/media.js';
 import { mintCanary } from '../engine/boundary.js';
-import { CATALOG, clampThinkingLevel, modelEntry } from './catalog.js';
+import { CATALOG, clampThinkingLevel, getTool, listBuiltinIds, requireModelSpec, } from './catalog.js';
+import { assertImageGrounding, assertSpeechRole, resolveImageFormat, resolveInputParts, } from './ingress.js';
 import { getProfile } from './profiles.js';
-const BUILTINS = ['googleSearch', 'googleMaps', 'urlContext'];
+import { resolveGeminiBucket } from './vault.js';
 function applyBuiltinMutualExclusions(requested) {
-    const search = requested.includes('googleSearch');
-    const maps = requested.includes('googleMaps');
-    const urlContext = requested.includes('urlContext');
-    // Google Interactions API: google_maps cannot be combined with google_search or url_context
-    if (maps && (search || urlContext)) {
-        return requested.filter((id) => id !== 'googleMaps');
-    }
-    return requested;
+    return requested.filter((id) => {
+        const conflicts = getTool(id)?.conflictsWith ?? [];
+        return !conflicts.some((other) => requested.includes(other));
+    });
 }
 function firstSelectKey(selectMap) {
     const [key] = Object.keys(selectMap);
@@ -60,12 +55,11 @@ function pickModel(profile, select) {
     }
     return only;
 }
-function thinkingFromControl(modelId, thinkingOn) {
-    const catalog = modelEntry(modelId);
+function thinkingFromControl(spec, thinkingOn) {
     if (thinkingOn) {
-        return catalog.thinking.on;
+        return spec.thinking.on;
     }
-    return catalog.thinking.off;
+    return spec.thinking.off;
 }
 function pinnedLevel(pinned, key) {
     if (!key) {
@@ -91,25 +85,20 @@ function thinkingFromPin(profile, select) {
     }
     throw new TheorumError(`Profile ${profile.id} must pin thinking or list it in controls`);
 }
-function resolveThinking(profile, modelId, thinkingOn, select) {
+function resolveThinking(profile, spec, thinkingOn, select) {
     const raw = profile.model.controls?.includes('thinking')
-        ? thinkingFromControl(modelId, thinkingOn)
+        ? thinkingFromControl(spec, thinkingOn)
         : thinkingFromPin(profile, select);
-    return clampThinkingLevel(modelId, raw);
+    return clampThinkingLevel(spec, raw);
 }
-function resolveSummaries(profile, modelId, thinkingOn) {
-    const override = profile.model.override?.[modelId]?.summaries;
-    if (override) {
-        return override;
-    }
-    const entry = modelEntry(modelId);
+function resolveSummaries(profile, spec, thinkingOn) {
     if (profile.model.controls?.includes('thinking')) {
         if (thinkingOn) {
-            return entry.summaries.on;
+            return spec.summaries.on;
         }
-        return entry.summaries.off;
+        return spec.summaries.off;
     }
-    return entry.summaries.on;
+    return spec.summaries.on;
 }
 function isGatedOn(requested, id) {
     if (!requested) {
@@ -119,7 +108,7 @@ function isGatedOn(requested, id) {
 }
 function resolveBuiltins(profile, requested) {
     const allowed = profile.tools.allow.filter((id) => CATALOG.tools[id]?.kind === 'builtin');
-    const picked = BUILTINS.filter((id) => allowed.includes(id) && isGatedOn(requested, id));
+    const picked = listBuiltinIds().filter((id) => allowed.includes(id) && isGatedOn(requested, id));
     return applyBuiltinMutualExclusions(picked);
 }
 function resolveCustom(profile, requested) {
@@ -147,34 +136,32 @@ function resolveStructured(profile, slots) {
     }
     return structured.fallback;
 }
-function generationLimits(profile, model) {
-    const catalog = modelEntry(model);
-    const ov = profile.model.override?.[model];
-    return {
-        maxOutputTokens: ov?.maxOutputTokens ?? catalog.maxOutputTokens,
-        temperature: ov?.temperature ?? catalog.temperature,
-    };
-}
 /** Resolve a host `TurnRequest` into provider-ready generation state. */
 function resolveTurn(req) {
     const safe = sanitizeTurnRequest(req);
     const input = safe.input ?? {};
     const profile = getProfile(safe.profile);
     const model = pickModel(profile, safe.select);
+    const spec = requireModelSpec(profile, model);
     const thinkingOn = safe.thinking === true;
-    const limits = generationLimits(profile, model);
     const builtins = resolveBuiltins(profile, safe.tools);
-    assertImageGrounding(model, builtins);
+    assertImageGrounding(profile, model, builtins);
+    assertSpeechRole(profile);
+    const geminiBucket = profile.model.provider === 'google'
+        ? resolveGeminiBucket(profile.model.key ?? 'freeA', spec, builtins)
+        : undefined;
     return {
         profile,
         generation: {
             model,
+            apiId: spec.apiId,
+            openRouterId: spec.openRouterId,
             previousInteractionId: safe.previousInteractionId,
             store: safe.store,
-            thinking: resolveThinking(profile, model, thinkingOn, safe.select),
-            summaries: resolveSummaries(profile, model, thinkingOn),
-            maxOutputTokens: limits.maxOutputTokens,
-            temperature: limits.temperature,
+            thinking: resolveThinking(profile, spec, thinkingOn, safe.select),
+            summaries: resolveSummaries(profile, spec, thinkingOn),
+            maxOutputTokens: spec.maxOutputTokens,
+            temperature: spec.temperature,
             builtins,
             custom: resolveCustom(profile, safe.tools),
             dynamicTools: safe.dynamicTools,
@@ -184,21 +171,16 @@ function resolveTurn(req) {
             maxSteps: profile.model.maxSteps ?? 1,
             structured: resolveStructured(profile, input.slots),
             image: resolveImageFormat(profile, model, input.slots),
-            voice: profile.outputs.voice,
+            speech: profile.outputs.speech,
             input: resolveInputParts(profile, model, safe),
-            geminiBucket: resolveGeminiBucket(profile.model.key ?? 'freeA', model, builtins),
+            geminiBucket,
             canary: profile.guardrails.canary !== false ? mintCanary() : '',
         },
     };
 }
-function primaryImageSpec(allow) {
-    const [primary] = allow;
-    if (!primary) {
-        return undefined;
-    }
-    return modelEntry(primary).image;
+function primaryImageSpec(profile) {
+    return profile.outputs.image;
 }
-/** UI projection: catalog ∩ profile. Swatches are not included. */
 /** Project a registered profile into a safe host/UI inspection object. */
 function projectProfile(id) {
     const profile = getProfile(id);
@@ -221,7 +203,7 @@ function projectProfile(id) {
         inputs,
         slots: slots ?? {},
         outputs,
-        image: primaryImageSpec(allow),
+        image: primaryImageSpec(profile),
     };
 }
 function pickSystemRole(profile, requested) {

package/esm/src/kernel/registry/tools.js

@@ -6,7 +6,7 @@
  *
  * @module
  */
-import { CATALOG } from './catalog.js';
+import { getTool } from './catalog.js';
 import { assertToolAllowed } from './resolve.js';
 function executeAskUser(args) {
     const { kind, prompt } = args;
@@ -19,7 +19,7 @@ function executeAskUser(args) {
     return {
         status: 'pause',
         finding: prompt,
-        data: { ...args, schema: CATALOG.tools.askUser.schema },
+        data: { ...args, schema: getTool('askUser')?.schema },
     };
 }
 /** Execute a static tool after enforcing the profile allowlist. */

package/esm/src/kernel/registry/vault.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gemini vault slot selection for Google Interactions transport.
+ *
+ * Host-owned policy over `ModelSpec.key` / `keyBuiltins`. Pure; no network.
+ *
+ * @module
+ */
+import type { BuiltinToolId, GeminiBucket, GeminiFreeBucket, ModelSpec } from '../types.js';
+/** Pick the vault slot for a turn from profile key, model pin, and builtins. */
+declare function resolveGeminiBucket(profileKey: GeminiFreeBucket, spec: ModelSpec, builtins: BuiltinToolId[]): GeminiBucket;
+export { resolveGeminiBucket };

package/esm/src/kernel/registry/vault.js

@@ -0,0 +1,18 @@
+/**
+ * Gemini vault slot selection for Google Interactions transport.
+ *
+ * Host-owned policy over `ModelSpec.key` / `keyBuiltins`. Pure; no network.
+ *
+ * @module
+ */
+/** Pick the vault slot for a turn from profile key, model pin, and builtins. */
+function resolveGeminiBucket(profileKey, spec, builtins) {
+    if (spec.key) {
+        return spec.key;
+    }
+    if (builtins.some((id) => !spec.keyBuiltins.includes(id))) {
+        return 'paid';
+    }
+    return profileKey;
+}
+export { resolveGeminiBucket };

package/esm/src/kernel/types.d.ts

@@ -8,17 +8,15 @@
  * @module
  */
 /** Model reasoning effort level normalized across provider adapters. */
-export type ThinkingLevel = 'minimal' | 'low' | 'medium' | 'high';
-/** Built-in model aliases included in THEORUM's generic model catalog. */
-export type StandardModelId = 'gemini31FlashLite' | 'gemini31ProPreview' | 'gemini35FlashLite' | 'gemini31FlashLiteImage' | 'gemini31FlashTts' | 'sonar';
-/** Any model id a host profile may allow, including app-provided custom ids. */
-export type ModelId = StandardModelId | (string & {});
-/** Provider-native tools THEORUM can project into supported provider payloads. */
-export type BuiltinToolId = 'googleSearch' | 'googleMaps' | 'urlContext';
-/** Minimal built-in custom tool available to host apps for user interaction pauses. */
-export type StandardCustomToolId = 'askUser';
-/** Host-owned custom tool id. */
-export type CustomToolId = StandardCustomToolId | (string & {});
+export type ThinkingLevel = 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+/** Any host-declared model id. */
+export type ModelId = string;
+/** Provider-projected builtin tool id (registered by presets/adapters). */
+export type BuiltinToolId = string;
+/** Harness custom tool that ships with THEORUM. */
+export type HarnessToolId = 'askUser';
+/** Host-owned or harness custom tool id. */
+export type CustomToolId = HarnessToolId | (string & {});
 /** Any tool id accepted by profile allowlists and per-turn gates. */
 export type ToolId = BuiltinToolId | CustomToolId;
 /** Id of a host-registered structured output schema. */
@@ -35,10 +33,23 @@ export type GeminiFreeBucket = Exclude<GeminiBucket, 'paid'>;
 export type ChatRole = 'system' | 'user' | 'assistant';
 /** Profile-level control a caller may toggle at turn time. */
 export type ControlId = 'thinking';
-/** Native image size supported by the generic image response spec. */
-export type ImageSize = '1K';
-/** Native image aspect ratio accepted by image-capable model specs. */
-export type ImageAspectRatio = '1:1' | '3:2' | '2:3' | '3:4' | '4:3' | '4:5' | '5:4' | '9:16' | '16:9' | '21:9';
+/**
+ * Image-role output pins owned by the host profile.
+ * The image model itself lives in `model.allow` / `model.config`.
+ * Aspect/size/mime values are host strings (presets/apps own the vocabularies).
+ */
+export interface ProfileImageSpec {
+    /** Default aspect ratio when the turn does not set `slots.aspectRatio`. */
+    aspectRatio?: string;
+    /** Default size / resolution when the turn does not set `slots.size`. */
+    size?: string;
+    /** Output MIME for generated images. */
+    mimeType?: string;
+    /** When false, grounding builtins are rejected on this profile. */
+    allowsGrounding?: boolean;
+    /** Cap on reference images in one turn. */
+    maxInputImages?: number;
+}
 /** Public event types emitted by `runTurn` and provider adapters. */
 export type TurnEventType = 'thought' | 'text' | 'tool' | 'structured' | 'media' | 'grounding' | 'evidence' | 'tokens' | 'done' | 'error';
 /** Provider thinking levels used when a boolean thinking control is on or off. */
@@ -51,44 +62,48 @@ export interface SummaryMap {
     on: 'auto' | 'none';
     off: 'auto' | 'none';
 }
-/** Native image generation on Interactions (`response_format.type = image`). */
-export interface ImageModelSpec {
-    maxInputImages: number;
-    inputMimes: string[];
-    sizes: ImageSize[];
-    aspectRatios: ImageAspectRatio[];
-    outputMime: string;
-    allowsGrounding: boolean;
-}
-/** Static metadata THEORUM needs to safely call a model id. */
-export interface ModelCatalogEntry {
+/** Host-declared metadata THEORUM needs to call a model safely. */
+export interface ModelSpec {
     apiId: string;
     /** Provider-native id for OpenRouter-compatible gateways. Defaults to `google/${apiId}`. */
     openRouterId?: string;
     thinking: ThinkingMap;
-    /** Levels this model accepts on Interactions. Illegal values → 400. */
+    /** Levels this model accepts. Illegal values are clamped via `thinkingLevels`. */
     thinkingLevels: ThinkingLevel[];
     summaries: SummaryMap;
     maxOutputTokens: number;
     temperature: number;
-    /** Builtins that may run on the profile's free key. Anything else is paid. */
-    freeBuiltins: BuiltinToolId[];
-    image?: ImageModelSpec;
-}
-/** Static metadata for built-in and generic custom tools. */
+    /**
+     * Builtins that may use `profile.model.key`.
+     * Any other enabled builtin selects the overflow vault slot (`paid`).
+     * Host-owned policy — THEORUM does not infer tool pricing.
+     */
+    keyBuiltins: BuiltinToolId[];
+    /**
+     * Optional vault slot for this model. When set, overrides `profile.model.key`
+     * (and builtin routing). Host-owned — e.g. pin image models to `paid`.
+     */
+    key?: GeminiBucket;
+}
+/** Static metadata for harness, preset, and host-registered tools. */
 export interface ToolCatalogEntry {
     kind: 'builtin' | 'custom';
     ui: boolean;
     schema?: Record<string, unknown>;
+    /** Interactions API `tools[].type` when this builtin is projected. */
+    interactionsType?: string;
+    /** OpenRouter plugin id enabled when this builtin is on. */
+    openRouterPlugin?: string;
+    /** Drop this builtin when any listed sibling builtin is also requested. */
+    conflictsWith?: ToolId[];
 }
 /** Host-registered structured output schema and enforcement mode. */
 export interface StructuredSpec {
     enforced: 'responseFormat' | 'prompt';
     jsonSchema?: Record<string, unknown>;
 }
-/** In-memory model and tool catalog shape. */
+/** In-memory tool catalog shape. */
 export interface Catalog {
-    models: Record<ModelId, ModelCatalogEntry>;
     tools: Record<ToolId, ToolCatalogEntry>;
 }
 /** Per-turn file, byte, and MIME-specific input limits. */
@@ -114,16 +129,6 @@ export interface StructuredBySlot {
     map: Record<string, string>;
     fallback: string;
 }
-/** Legacy-compatible model selection block used by profile builders. */
-export interface ProfileModels {
-    allow: ModelId[];
-    select?: Record<string, ModelId>;
-    /** Pinned level when `thinking` is not in `controls`. */
-    thinking?: ThinkingLevel | Record<string, ThinkingLevel>;
-    override?: Partial<Record<ModelId, Partial<Pick<ModelCatalogEntry, 'maxOutputTokens' | 'temperature'> & {
-        summaries?: 'auto' | 'none';
-    }>>>;
-}
 /** Result returned by a profile output validator. */
 export interface ValidationResult {
     isValid: boolean;
@@ -140,14 +145,26 @@ export interface ProfileValidationSpec {
     maxRetries?: number;
     repairGuidance?: string;
 }
-/** Audio container emitted by the OpenRouter TTS adapter. */
-export type OpenRouterAudioFormat = 'pcm' | 'mp3';
-/** Voice name passed through to OpenRouter-compatible TTS models. */
-export type OpenRouterTtsVoice = 'Zephyr' | 'Puck' | 'Charon' | 'Kore' | 'Fenrir' | 'Leda' | 'Orus' | 'Aoede' | 'Callirrhoe' | 'Autonoe' | 'Enceladus' | 'Iapetus' | 'Umbriel' | 'Algieba' | 'Despina' | 'Erinome' | 'Algenib' | 'Rasalgethi' | 'Laomedeia' | 'Achernar' | 'Alnilam' | 'Schedar' | 'Gacrux' | 'Pulcherrima' | 'Achird' | 'Zubenelgenubi' | 'Vindemiatrix' | 'Sadachbia' | 'Sadaltager' | 'Sulafat' | (string & {});
-/** Voice output configuration owned by the host profile. */
-export interface ProfileVoiceSpec {
-    voice?: OpenRouterTtsVoice;
-    responseFormat?: OpenRouterAudioFormat;
+/**
+ * Audio container for speech generation output.
+ * - `openAi` speech (`/audio/speech`): sent as wire `response_format`.
+ * - `geminiInteractions`: only `pcm` (or omit). Google returns PCM; THEORUM emits WAV.
+ *   `mp3` is rejected at resolve.
+ */
+export type SpeechAudioFormat = 'pcm' | 'mp3';
+/**
+ * Speech-role output pins owned by the host profile.
+ * The speech model itself lives in `model.allow` / `model.config`.
+ * Namespaced under `outputs.speech` so `voice` here is the TTS voice id,
+ * not ingress audio (`inputs.voice`).
+ */
+export interface ProfileSpeechSpec {
+    voice?: string;
+    /**
+     * Output container. `pcm` (default) → WAV media on both transports.
+     * `mp3` requires `protocol: 'openAi'` speech; rejected on Interactions.
+     */
+    format?: SpeechAudioFormat;
 }
 /** Stream delivery controls enforced by the kernel. */
 export interface ProfileStreamingSpec {
@@ -194,17 +211,15 @@ export interface ProfileGuardrailsSpec {
 export interface ProfileModelSpec {
     protocol: 'geminiInteractions' | 'openAi';
     provider: 'google' | 'openrouter';
+    /** Ids this profile may select. Each id must exist in `config`. */
     allow: ModelId[];
+    /** Host-owned wire config keyed by the same ids used in `allow` / `select`. */
+    config: Record<ModelId, ModelSpec>;
     select?: Record<string, ModelId>;
     thinking?: ThinkingLevel | Record<string, ThinkingLevel>;
     controls?: ControlId[];
     maxSteps?: number;
     key?: GeminiFreeBucket;
-    override?: Record<string, {
-        maxOutputTokens?: number;
-        temperature?: number;
-        summaries?: 'auto' | 'none';
-    }>;
 }
 /** Text, attachment, voice, slot, and size rules for a profile. */
 export interface ProfileInputsSpec {
@@ -221,11 +236,13 @@ export interface ProfileInputsSpec {
     limitsByMime?: Record<string, number>;
     slots?: Record<string, string[]>;
 }
-/** Output schema, media, voice, validation, and stream rules for a profile. */
+/** Output schema, image, speech, validation, and stream rules for a profile. */
 export interface ProfileOutputsSpec {
     structured?: StructuredSchemaId | StructuredBySlot | null;
-    media?: boolean;
-    voice?: ProfileVoiceSpec;
+    /** Pins for an image-role profile. Model id is on `model`. */
+    image?: ProfileImageSpec;
+    /** Pins for a speech-role profile (`voice` / `format`). Model id is on `model`. */
+    speech?: ProfileSpeechSpec;
     validation?: ProfileValidationSpec;
     streaming?: ProfileStreamingSpec;
 }
@@ -263,8 +280,9 @@ export type InteractionPart = InteractionTextPart | InteractionMediaPart;
 export interface ImageResponseFormat {
     type: 'image';
     mimeType: string;
-    aspectRatio: ImageAspectRatio;
-    imageSize: ImageSize;
+    aspectRatio: string;
+    /** Authoring / kernel name; adapters map to provider wire keys (e.g. Google `imageSize`). */
+    size: string;
 }
 /** Base64-encoded blob supplied by a host turn request. */
 export interface TurnBlob {
@@ -386,11 +404,14 @@ export interface ProjectedProfile {
     inputs: Profile['inputs'];
     slots: Record<string, string[]>;
     outputs: Profile['outputs'];
-    image?: ImageModelSpec | null;
+    image?: ProfileImageSpec | null;
 }
-/** Fully-resolved provider request state created from a `TurnRequest`. */
-export interface ResolvedGeneration {
+/** Provider selection and generation knobs shared before and after resolution. */
+export interface ProviderGenerationConfig {
     model: ModelId;
+    /** Provider-native model id taken from the profile model spec. */
+    apiId: string;
+    openRouterId?: string;
     previousInteractionId?: string;
     store?: boolean;
     thinking: ThinkingLevel;
@@ -398,6 +419,9 @@ export interface ResolvedGeneration {
     maxOutputTokens: number;
     temperature: number;
     builtins: BuiltinToolId[];
+}
+/** Fully-resolved provider request state created from a `TurnRequest`. */
+export interface ResolvedGeneration extends ProviderGenerationConfig {
     custom: CustomToolId[];
     dynamicTools?: DynamicToolDeclaration[];
     dynamicToolLoader?: DynamicToolLoader;
@@ -406,9 +430,13 @@ export interface ResolvedGeneration {
     maxSteps: number;
     structured: StructuredSchemaId | null;
     image: ImageResponseFormat | null;
-    voice?: ProfileVoiceSpec;
+    speech?: ProfileSpeechSpec;
     input: InteractionPart[];
-    geminiBucket: GeminiBucket;
+    /**
+     * Gemini vault slot for Google Interactions transport only.
+     * Omitted for non-Google providers; never sent on the wire.
+     */
+    geminiBucket?: GeminiBucket;
     canary: string;
 }
 /** Tool execution status returned to the model and stream. */
@@ -470,15 +498,7 @@ export interface TurnEvent {
     error?: string;
 }
 /** Provider-neutral request object sent from the kernel to a model adapter. */
-export interface ProviderCompleteRequest {
-    model: ModelId;
-    previousInteractionId?: string;
-    store?: boolean;
-    thinking: ThinkingLevel;
-    summaries: 'auto' | 'none';
-    maxOutputTokens: number;
-    temperature: number;
-    builtins: BuiltinToolId[];
+export interface ProviderCompleteRequest extends ProviderGenerationConfig {
     system: string;
     input: InteractionPart[];
     history?: TurnHistoryMessage[];
@@ -486,8 +506,12 @@ export interface ProviderCompleteRequest {
     dynamicToolLoader?: DynamicToolLoader;
     structured: StructuredSchemaId | null;
     image: ImageResponseFormat | null;
-    voice?: ProfileVoiceSpec;
-    geminiBucket: GeminiBucket;
+    speech?: ProfileSpeechSpec;
+    /**
+     * Gemini vault slot for Google Interactions transport only.
+     * Required when completing via Google Interactions.
+     */
+    geminiBucket?: GeminiBucket;
     /** Scrubbed SSE / HTTP rows for traces. */
     tapGemini?: (row: Record<string, unknown>) => void;
 }

package/esm/src/observability/trace-attach.js

@@ -1,24 +1,7 @@
-import { modelEntry } from '../kernel/registry/catalog.js';
+import { providerCompleteRequest } from '../kernel/registry/provider-request.js';
 import { tapeGemini } from '../providers/gemini-tape.js';
 import { toInteractionsBody } from '../providers/interactions.js';
 import { httpStatus } from './trace-usage.js';
-function completeRequest(generation, system) {
-    return {
-        model: generation.model,
-        previousInteractionId: generation.previousInteractionId,
-        store: generation.store,
-        thinking: generation.thinking,
-        summaries: generation.summaries,
-        maxOutputTokens: generation.maxOutputTokens,
-        temperature: generation.temperature,
-        builtins: generation.builtins,
-        system,
-        input: generation.input,
-        structured: generation.structured,
-        image: generation.image,
-        geminiBucket: generation.geminiBucket,
-    };
-}
 function attachResolved(record, args) {
     const { safe, model, bucket, generation } = args;
     if (safe.projectId) {
@@ -37,7 +20,10 @@ function attachResolved(record, args) {
         record.metadata = safe.metadata;
     }
     if (model) {
-        record.model = { id: model, apiId: modelEntry(model).apiId };
+        record.model = {
+            id: model,
+            apiId: generation?.apiId ?? model,
+        };
     }
     if (bucket) {
         record.bucket = bucket;
@@ -61,7 +47,7 @@ async function attachTape(record, args) {
         record.gemini = await tapeGemini(gemini, canary ?? '');
     }
     if (generation && system !== undefined) {
-        record.wire = await tapeGemini(toInteractionsBody(completeRequest(generation, system)), canary ?? '');
+        record.wire = await tapeGemini(toInteractionsBody(providerCompleteRequest(generation, system)), canary ?? '');
     }
 }
 function attachUsage(record, gemini, done) {

package/esm/src/presets/google.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Google / Gemini convenience preset.
+ *
+ * Kernel stays open (`string` pins). This pack owns Google vocabularies as
+ * real unions so host profiles stay typed when they opt into the preset.
+ *
+ * Call `registerGooglePreset()` at host startup for tools; use the exported
+ * types/constants when authoring image/speech-adjacent profile fields.
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import type { ProfileImageSpec, ProfileSpeechSpec, ToolCatalogEntry } from '../kernel/types.js';
+/** Google Interactions / Gemini grounding builtins. */
+declare const GOOGLE_BUILTIN_TOOLS: Record<string, ToolCatalogEntry>;
+/** Common Gemini image input MIME allowlist. */
+declare const GOOGLE_IMAGE_INPUT_MIMES: readonly ["image/png", "image/jpeg", "image/webp", "image/heic", "image/heif"];
+/** Common voice/audio input MIME allowlist for Gemini multimodal. */
+declare const GOOGLE_VOICE_INPUT_MIMES: readonly ["audio/webm", "audio/wav", "audio/mpeg", "audio/mp4"];
+/** Common Gemini TTS voice names for `outputs.speech.voice`. */
+declare const GOOGLE_SPEECH_VOICES: readonly ["Zephyr", "Puck", "Charon", "Kore", "Fenrir", "Leda", "Orus", "Aoede", "Callirrhoe", "Autonoe", "Enceladus", "Iapetus", "Umbriel", "Algieba", "Despina", "Erinome", "Algenib", "Rasalgethi", "Laomedeia", "Achernar", "Alnilam", "Schedar", "Gacrux", "Pulcherrima", "Achird", "Zubenelgenubi", "Vindemiatrix", "Sadachbia", "Sadaltager", "Sulafat"];
+type GoogleSpeechVoice = (typeof GOOGLE_SPEECH_VOICES)[number];
+/**
+ * `outputs.speech` pins narrowed to Google TTS vocabulary.
+ * Assignable to kernel `ProfileSpeechSpec`.
+ */
+type GoogleSpeechPins = Omit<ProfileSpeechSpec, 'voice'> & {
+    voice?: GoogleSpeechVoice;
+};
+/** Aspect ratios commonly accepted by Gemini image models. */
+declare const GOOGLE_IMAGE_ASPECT_RATIOS: readonly ["1:1", "3:2", "2:3", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
+/** Image sizes commonly accepted by Gemini Flash Lite image. */
+declare const GOOGLE_IMAGE_SIZES: readonly ["1K"];
+type GoogleImageInputMime = (typeof GOOGLE_IMAGE_INPUT_MIMES)[number];
+type GoogleVoiceInputMime = (typeof GOOGLE_VOICE_INPUT_MIMES)[number];
+type GoogleImageAspectRatio = (typeof GOOGLE_IMAGE_ASPECT_RATIOS)[number];
+type GoogleImageSize = (typeof GOOGLE_IMAGE_SIZES)[number];
+/**
+ * `outputs.image` pins narrowed to Google image vocabulary.
+ * Assignable to kernel `ProfileImageSpec`.
+ */
+type GoogleImagePins = Omit<ProfileImageSpec, 'aspectRatio' | 'size' | 'mimeType'> & {
+    aspectRatio?: GoogleImageAspectRatio;
+    size?: GoogleImageSize;
+    mimeType?: GoogleImageInputMime | 'image/jpeg';
+};
+/** Register Google provider builtins into the process-local tool catalog. */
+declare function registerGooglePreset(): void;
+export type { GoogleImageAspectRatio, GoogleImageInputMime, GoogleImagePins, GoogleImageSize, GoogleSpeechPins, GoogleSpeechVoice, GoogleVoiceInputMime, };
+export { GOOGLE_BUILTIN_TOOLS, GOOGLE_IMAGE_ASPECT_RATIOS, GOOGLE_IMAGE_INPUT_MIMES, GOOGLE_IMAGE_SIZES, GOOGLE_SPEECH_VOICES, GOOGLE_VOICE_INPUT_MIMES, registerGooglePreset, };