theorum 0.1.14 → 1.0.0

package/esm/src/observability/trace-attach.d.ts

@@ -1,16 +1,18 @@
-import type { ResolvedGeneration, TurnRequest } from '../kernel/types.js';
+import type { Protocol } from '../kernel/schema.js';
+import type { ResolvedGeneration, TurnEvent, TurnRequest } from '../kernel/types.js';
 import type { TraceRecord } from './trace-record.js';
 declare function attachResolved(record: TraceRecord, args: {
     safe: TurnRequest;
     model?: string;
-    bucket?: string;
+    keySlot?: string;
     generation?: ResolvedGeneration;
 }): void;
 declare function attachTape(record: TraceRecord, args: {
-    gemini?: unknown;
+    upstream?: unknown;
     canary?: string;
     system?: string;
     generation?: ResolvedGeneration;
+    protocol?: Protocol;
 }): Promise<void>;
-declare function attachUsage(record: TraceRecord, gemini: unknown, done: Record<string, unknown> | undefined): void;
+declare function attachUsage(record: TraceRecord, upstream: unknown, done: Record<string, unknown> | undefined, events?: TurnEvent[]): void;
 export { attachResolved, attachTape, attachUsage };

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

@@ -1,9 +1,8 @@
 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';
+import { tapeUpstream } from '../providers/shared/upstream-tape.js';
+import { httpStatus, openAiFinishReason, tokensFromEvents } from './trace-usage.js';
 function attachResolved(record, args) {
-    const { safe, model, bucket, generation } = args;
+    const { safe, model, keySlot, generation } = args;
     if (safe.projectId) {
         record.projectId = safe.projectId;
     }
@@ -13,9 +12,6 @@ function attachResolved(record, args) {
     if (safe.thinking !== undefined) {
         record.thinking = safe.thinking;
     }
-    if (safe.tools) {
-        record.tools = safe.tools;
-    }
     if (safe.metadata) {
         record.metadata = safe.metadata;
     }
@@ -25,43 +21,61 @@ function attachResolved(record, args) {
             apiId: generation?.apiId ?? model,
         };
     }
-    if (bucket) {
-        record.bucket = bucket;
+    if (keySlot) {
+        record.keySlot = keySlot;
     }
     if (generation) {
-        record.generation = {
+        const traceGeneration = {
             thinking: generation.thinking,
             summaries: generation.summaries,
             temperature: generation.temperature,
             maxOutputTokens: generation.maxOutputTokens,
             builtins: generation.builtins,
-            custom: generation.custom,
+            visibleTools: generation.tools.visible,
             structured: generation.structured,
             image: generation.image,
         };
+        record.generation = traceGeneration;
     }
 }
 async function attachTape(record, args) {
-    const { gemini, canary, system, generation } = args;
-    if (gemini !== undefined) {
-        record.gemini = await tapeGemini(gemini, canary ?? '');
+    const { upstream, canary, system, generation, protocol } = args;
+    if (upstream !== undefined) {
+        record.upstreamLog = await tapeUpstream(upstream, canary ?? '');
     }
-    if (generation && system !== undefined) {
-        record.wire = await tapeGemini(toInteractionsBody(providerCompleteRequest(generation, system)), canary ?? '');
+    if (generation && system !== undefined && protocol === 'geminiInteractions') {
+        const { toInteractionsBody } = await import('../providers/google/interactions/framing.js');
+        record.wire = await tapeUpstream(toInteractionsBody(providerCompleteRequest(generation, system)), canary ?? '');
     }
 }
-function attachUsage(record, gemini, done) {
+function attachUsageTokens(record, done, events) {
     if (done?.usage !== undefined) {
         record.usage = done.usage;
+        return;
     }
-    const upStatus = httpStatus(gemini);
-    if (upStatus !== undefined || done) {
-        record.upstream = {
-            status: upStatus,
-            id: done?.id,
-            finish: done?.status,
-            serviceTier: done?.service_tier ?? done?.serviceTier,
-        };
+    if (!events) {
+        return;
+    }
+    const tokens = tokensFromEvents(events);
+    if (tokens) {
+        record.usage = tokens;
     }
 }
+function attachUpstreamSummary(record, upstream, done) {
+    const upStatus = httpStatus(upstream);
+    const finishReason = openAiFinishReason(upstream);
+    if (upStatus === undefined && !done && finishReason === undefined) {
+        return;
+    }
+    record.upstream = {
+        status: upStatus,
+        id: done?.id,
+        finish: done?.status ?? finishReason,
+        serviceTier: done?.service_tier ?? done?.serviceTier,
+    };
+}
+function attachUsage(record, upstream, done, events) {
+    attachUsageTokens(record, done, events);
+    attachUpstreamSummary(record, upstream, done);
+}
 export { attachResolved, attachTape, attachUsage };

package/esm/src/observability/trace-record.d.ts

@@ -6,6 +6,7 @@
  *
  * @module
  */
+import type { Protocol } from '../kernel/schema.js';
 import type { ResolvedGeneration, TurnEvent, TurnRequest } from '../kernel/types.js';
 /** Hash-only image reference stored in trace records. */
 export interface TraceImage {
@@ -47,20 +48,19 @@ interface TraceRecord {
     projectId?: string;
     select?: string;
     thinking?: boolean;
-    tools?: TurnRequest['tools'];
     metadata?: Record<string, unknown>;
     model?: {
         id: string;
         apiId: string;
     };
-    bucket?: string;
+    keySlot?: string;
     generation?: {
         thinking: string;
-        summaries: string;
-        temperature: number;
-        maxOutputTokens: number;
+        summaries?: string;
+        temperature?: number;
+        maxOutputTokens?: number;
         builtins: string[];
-        custom: string[];
+        visibleTools: string[];
         structured: string | null;
         image: unknown;
     };
@@ -75,7 +75,8 @@ interface TraceRecord {
     };
     wire?: unknown;
     events: TraceEvent[];
-    gemini?: unknown;
+    /** Raw upstream tap rows (HTTP, SSE, provider events). */
+    upstreamLog?: unknown;
     usage?: unknown;
     upstream?: {
         status?: unknown;
@@ -102,12 +103,13 @@ declare function buildRecord(args: {
     events: TurnEvent[];
     started: number;
     model?: string;
-    bucket?: string;
+    keySlot?: string;
     thrown?: unknown;
-    gemini?: unknown;
+    upstreamLog?: unknown;
     canary?: string;
     system?: string;
     generation?: ResolvedGeneration;
+    protocol?: Protocol;
     sanitizedReq?: TurnRequest;
 }): Promise<TraceRecord>;
 export type { TraceRecord };

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

@@ -6,12 +6,12 @@
  *
  * @module
  */
+import { OMIT_CANARY } from '../guardrails/canary.js';
 import { isAbortError, publicError } from '../guardrails/error.js';
-import { redactSensitiveOnly, sanitizeText, sanitizeTurnRequest } from '../guardrails/sanitize.js';
-import { OMIT_CANARY } from '../kernel/engine/boundary.js';
+import { redactSensitiveOnly, sanitizeText, sanitizeTurnRequestForTrace, } from '../guardrails/sanitize.js';
 import { sha256 } from '../kernel/engine/hash.js';
 import { attachResolved, attachTape, attachUsage } from './trace-attach.js';
-import { completedInteraction } from './trace-usage.js';
+import { completedInteraction, stopKindFromEvents } from './trace-usage.js';
 const TRACE_VERSION = 2;
 const TITLE_MAX = 80;
 function hashBlobs(blobs) {
@@ -38,13 +38,22 @@ async function snapshotEvent(event) {
         row.structured = event.structured;
     }
     if (event.tool) {
-        const { name, arguments: args, result } = event.tool;
+        const { name, arguments: args, output, phase, failure } = event.tool;
         row.tool = { name, arguments: args };
-        if (result) {
+        if (output !== undefined && phase === 'complete') {
+            const data = typeof output === 'object' && output !== null
+                ? output
+                : { value: output };
             row.tool.result = {
-                status: result.status,
-                ...(result.finding ? { finding: result.finding } : {}),
-                ...(result.data ? { data: result.data } : {}),
+                status: 'ok',
+                ...(typeof data.finding === 'string' ? { finding: data.finding } : {}),
+                data,
+            };
+        }
+        else if (phase === 'error' && failure) {
+            row.tool.result = {
+                status: 'error',
+                finding: failure.message,
             };
         }
     }
@@ -63,12 +72,7 @@ async function snapshotEvent(event) {
     return row;
 }
 function requestForTrace(req) {
-    try {
-        return sanitizeTurnRequest(req);
-    }
-    catch {
-        return { profile: req.profile, input: {} };
-    }
+    return sanitizeTurnRequestForTrace(req);
 }
 function internalError(err) {
     if (typeof err === 'string') {
@@ -102,22 +106,28 @@ function attachFailure(record, thrown, lastErr, canary) {
     }
 }
 async function buildRecord(args) {
-    const { req, events, started, model, bucket, thrown, gemini, canary, system, generation } = args;
-    const safe = args.sanitizedReq ?? requestForTrace(req);
+    const { req, events, started, model, keySlot, thrown, upstreamLog, canary, system, generation } = args;
+    const protocol = args.protocol;
+    const traced = args.sanitizedReq ? { request: args.sanitizedReq } : requestForTrace(req);
+    const safe = traced.request;
     const input = safe.input ?? {};
     const snapped = await Promise.all(events.map((event) => snapshotEvent(event)));
     const lastErr = [...snapped].reverse().find((row) => row.type === 'error');
-    const done = completedInteraction(gemini);
-    const status = done?.status;
     const aborted = isAbortError(thrown);
-    const ok = !(thrown || lastErr) && status !== 'cancelled' && !aborted;
+    const stopKind = stopKindFromEvents(events);
+    const done = completedInteraction(upstreamLog);
+    const interactionStatus = done?.status;
+    const cancelled = aborted ||
+        stopKind === 'cancelled' ||
+        (protocol === 'geminiInteractions' && interactionStatus === 'cancelled');
+    const ok = !(thrown || lastErr) && !cancelled;
     const record = {
         v: TRACE_VERSION,
         id: crypto.randomUUID(),
         ts: started,
         ms: Date.now() - started,
         streamed: true,
-        cancelled: status === 'cancelled' || aborted,
+        cancelled,
         previousInteractionId: safe.previousInteractionId ?? null,
         store: safe.store ?? null,
         profile: safe.profile,
@@ -135,10 +145,13 @@ async function buildRecord(args) {
     if (title) {
         record.title = title;
     }
-    await attachTape(record, { gemini, canary, system, generation });
-    attachUsage(record, gemini, done);
-    attachResolved(record, { safe, model, bucket, generation });
+    await attachTape(record, { upstream: upstreamLog, canary, system, generation, protocol });
+    attachUsage(record, upstreamLog, done, events);
+    attachResolved(record, { safe, model, keySlot, generation });
     attachFailure(record, thrown, lastErr, canary);
+    if (traced.sanitizeError && !record.errorInternal) {
+        record.errorInternal = sanitizeText(`request sanitize for trace failed: ${traced.sanitizeError}`);
+    }
     return record;
 }
 export { buildRecord };

package/esm/src/observability/trace-usage.d.ts

@@ -1,3 +1,10 @@
-declare function completedInteraction(gemini: unknown): Record<string, unknown> | undefined;
-declare function httpStatus(gemini: unknown): unknown;
-export { completedInteraction, httpStatus };
+import type { TurnEvent, TurnTokens } from '../kernel/types.js';
+declare function completedInteraction(upstream: unknown): Record<string, unknown> | undefined;
+/** Extract the terminal stop kind from the TurnEvent stream (protocol-agnostic). */
+declare function stopKindFromEvents(events: TurnEvent[]): string | undefined;
+/** Extract the last tokens snapshot from the TurnEvent stream. */
+declare function tokensFromEvents(events: TurnEvent[]): TurnTokens | undefined;
+/** Extract finish_reason from OpenAI-compat upstream tap rows. */
+declare function openAiFinishReason(upstream: unknown): string | undefined;
+declare function httpStatus(upstream: unknown): unknown;
+export { completedInteraction, httpStatus, openAiFinishReason, stopKindFromEvents, tokensFromEvents, };

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

@@ -2,31 +2,84 @@ import { asRecord } from '../kernel/engine/record.js';
 function eventName(row) {
     return String(row.event_type ?? row.eventType ?? '');
 }
-function completedInteraction(gemini) {
-    if (!Array.isArray(gemini)) {
-        return undefined;
+function upstreamRows(upstream) {
+    if (!Array.isArray(upstream)) {
+        return [];
     }
-    for (let i = gemini.length - 1; i >= 0; i -= 1) {
-        const row = asRecord(gemini[i]);
-        if (row) {
-            const name = eventName(row);
-            if (name === 'interaction.completed' || name === 'interaction.complete') {
-                return asRecord(row.interaction) ?? row;
-            }
+    return upstream
+        .map((item) => asRecord(item))
+        .filter((row) => row != null);
+}
+function lastUpstreamRow(upstream, pred) {
+    const rows = upstreamRows(upstream);
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        if (pred(rows[i])) {
+            return rows[i];
+        }
+    }
+    return undefined;
+}
+function firstUpstreamRow(upstream, pred) {
+    for (const row of upstreamRows(upstream)) {
+        if (pred(row)) {
+            return row;
         }
     }
     return undefined;
 }
-function httpStatus(gemini) {
-    if (!Array.isArray(gemini)) {
+function completedInteraction(upstream) {
+    const row = lastUpstreamRow(upstream, (r) => {
+        const name = eventName(r);
+        return name === 'interaction.completed' || name === 'interaction.complete';
+    });
+    return row ? (asRecord(row.interaction) ?? row) : undefined;
+}
+/** Extract the terminal stop kind from the TurnEvent stream (protocol-agnostic). */
+function stopKindFromEvents(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const ev = events[i];
+        if (ev?.type === 'done' && ev.stop) {
+            return ev.stop.kind;
+        }
+    }
+    return undefined;
+}
+/** Extract the last tokens snapshot from the TurnEvent stream. */
+function tokensFromEvents(events) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const ev = events[i];
+        if (ev?.type === 'tokens' && ev.tokens) {
+            return ev.tokens;
+        }
+    }
+    return undefined;
+}
+/** Extract finish_reason from OpenAI-compat upstream tap rows. */
+function openAiFinishReason(upstream) {
+    const row = lastUpstreamRow(upstream, (r) => {
+        const choices = r.choices;
+        if (!Array.isArray(choices)) {
+            return false;
+        }
+        return choices.some((choice) => asRecord(choice)?.finish_reason != null);
+    });
+    if (!row) {
+        return undefined;
+    }
+    const choices = row.choices;
+    if (!Array.isArray(choices)) {
         return undefined;
     }
-    for (const item of gemini) {
-        const row = asRecord(item);
-        if (row && eventName(row) === 'http_response') {
-            return row.status;
+    for (const choice of choices) {
+        const c = asRecord(choice);
+        if (c?.finish_reason != null) {
+            return String(c.finish_reason);
         }
     }
     return undefined;
 }
-export { completedInteraction, httpStatus };
+function httpStatus(upstream) {
+    const row = firstUpstreamRow(upstream, (r) => eventName(r) === 'http_response');
+    return row?.status;
+}
+export { completedInteraction, httpStatus, openAiFinishReason, stopKindFromEvents, tokensFromEvents, };

package/esm/src/observability/trace.d.ts

@@ -2,8 +2,16 @@ import type { TraceRecord } from './trace-record.js';
 /** Minimal async destination for completed turn trace records. */
 interface TraceSink {
     write: (record: TraceRecord) => Promise<void>;
+    /**
+     * Optional host hook when `writeTrace` catches record-build or write failures.
+     * Must not throw; tracing never fails the turn.
+     */
+    onError?: (err: unknown) => void;
 }
-/** Write a trace record without allowing trace failures to fail the turn. */
+/**
+ * Write a trace record without allowing trace failures to fail the turn.
+ * Build/write errors are forwarded to `sink.onError` when provided.
+ */
 declare function writeTrace(sink: TraceSink, record: Promise<TraceRecord>): Promise<void>;
 /** Trace sink that drops records. */
 declare function noopSink(): TraceSink;

package/esm/src/observability/trace.js

@@ -19,13 +19,21 @@ const MIB = KIB * KIB;
 const ROTATE_MIB = 32;
 const ROTATE_BYTES = ROTATE_MIB * MIB;
 const FILE_DAY = /^turns-(\d{4}-\d{2}-\d{2})(?:-\d+)?\.jsonl$/;
-/** Write a trace record without allowing trace failures to fail the turn. */
+/**
+ * Write a trace record without allowing trace failures to fail the turn.
+ * Build/write errors are forwarded to `sink.onError` when provided.
+ */
 async function writeTrace(sink, record) {
     try {
         await sink.write(await record);
     }
-    catch {
-        // Tracing must not fail the turn.
+    catch (err) {
+        try {
+            sink.onError?.(err);
+        }
+        catch {
+            // Host onError must not fail the turn.
+        }
     }
 }
 /** Trace sink that drops records. */

package/esm/src/presets/google/speech-voices.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Google Gemini TTS voice names for `speech.voice`.
+ *
+ * Standalone preset vocabulary — no kernel registry imports so docs UIs can
+ * import this file without pulling provider wiring.
+ *
+ * @module
+ */
+/** Common Gemini TTS voice names. */
+export 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"];
+export type GoogleSpeechVoice = (typeof GOOGLE_SPEECH_VOICES)[number];

package/esm/src/presets/google/speech-voices.js

@@ -0,0 +1,41 @@
+/**
+ * Google Gemini TTS voice names for `speech.voice`.
+ *
+ * Standalone preset vocabulary — no kernel registry imports so docs UIs can
+ * import this file without pulling provider wiring.
+ *
+ * @module
+ */
+/** Common Gemini TTS voice names. */
+export const GOOGLE_SPEECH_VOICES = [
+    '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',
+];

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

@@ -1,50 +1,62 @@
 /**
  * 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>;
+import type { ProfileImageSpec, ProfileLiveSpec, ProfileSpeechSpec } from '../kernel/types.js';
+import { GOOGLE_SPEECH_VOICES, type GoogleSpeechVoice } from './google/speech-voices.js';
 /** 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. */
+type GoogleLivePins = Omit<ProfileLiveSpec, 'voice'> & {
+    voice?: GoogleSpeechVoice;
+};
 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 const GOOGLE_BUILTIN_TOOLS: ({
+    type: "builtin";
+    name: string;
+    description: string;
+    category: string;
+    access: "read-only";
+    paths: string[];
+    loadTier: "T0";
+    permission: "auto";
+    forcePaidKey: boolean;
+    wire: {
+        interactions: string;
+        openRouter: string;
+    };
+} | {
+    type: "builtin";
+    name: string;
+    description: string;
+    category: string;
+    access: "read-only";
+    paths: string[];
+    loadTier: "T0";
+    permission: "auto";
+    wire: {
+        interactions: string;
+        openRouter?: undefined;
+    };
+    forcePaidKey?: undefined;
+})[];
+/** Register Google provider builtins into the process-local tool registry. */
 declare function registerGooglePreset(): void;
-export type { GoogleImageAspectRatio, GoogleImageInputMime, GoogleImagePins, GoogleImageSize, GoogleSpeechPins, GoogleSpeechVoice, GoogleVoiceInputMime, };
+export type { GoogleImageAspectRatio, GoogleImageInputMime, GoogleImagePins, GoogleImageSize, GoogleLivePins, 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, };