theorum 0.1.3 → 0.1.4

package/esm/src/kernel/engine/runner/tools.js

@@ -1,197 +0,0 @@
-import { publicError } from '../../../guardrails/error.js';
-import { CATALOG } from '../../registry/catalog.js';
-import { executeTool } from '../../registry/tools.js';
-function formatToolFinding(res) {
-    if (res.finding) {
-        return res.finding;
-    }
-    if (res.data) {
-        return JSON.stringify(res.data);
-    }
-    return 'ok';
-}
-function* invokeFromUi(profile, req) {
-    const invoke = req.toolInvoke;
-    if (!invoke) {
-        return;
-    }
-    try {
-        const result = executeTool(profile, invoke.name, invoke.arguments);
-        yield {
-            type: 'tool',
-            tool: { name: invoke.name, arguments: invoke.arguments, result },
-        };
-        if (result.status === 'error') {
-            yield { type: 'error', error: publicError(formatToolFinding(result)) };
-            return;
-        }
-        yield { type: 'done' };
-    }
-    catch (err) {
-        yield { type: 'error', error: publicError(err) };
-        yield { type: 'done' };
-    }
-}
-function executeCustomModelTool(profile, name, args) {
-    try {
-        const result = executeTool(profile, name, args);
-        const events = [
-            {
-                type: 'tool',
-                tool: { name, arguments: args, result },
-            },
-        ];
-        if (result.status === 'error') {
-            events.push({ type: 'error', error: publicError(formatToolFinding(result)) });
-        }
-        return events;
-    }
-    catch (err) {
-        return [{ type: 'error', error: publicError(err) }];
-    }
-}
-function dispatchModelTool(profile, event, gated) {
-    const { tool } = event;
-    if (!tool) {
-        return [];
-    }
-    const name = tool.name;
-    if (CATALOG.tools[name]?.kind === 'builtin') {
-        return [event];
-    }
-    if (!gated.includes(name)) {
-        return [
-            {
-                type: 'error',
-                error: publicError(`Tool '${name}' is not gated on this turn`),
-            },
-        ];
-    }
-    const args = tool.arguments ?? {};
-    return executeCustomModelTool(profile, name, args);
-}
-function findDynamicDeclaration(tools, name) {
-    return tools?.find((t) => t.name === name);
-}
-async function checkDynamicAuthorization(decl, args, profile, sessionPermissions) {
-    if (!decl.canExecute) {
-        return null;
-    }
-    try {
-        const decision = await decl.canExecute({
-            args,
-            profile,
-            sessionPermissions,
-        });
-        if (typeof decision === 'boolean' && !decision) {
-            return {
-                status: 'error',
-                finding: `Tool '${decl.name}' execution not authorized.`,
-            };
-        }
-        if (typeof decision === 'object' && decision !== null) {
-            return decision;
-        }
-        return null;
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-            status: 'error',
-            finding: `Authorization error for '${decl.name}': ${msg}`,
-        };
-    }
-}
-function checkDynamicPermissionTier(decl, args, sessionPermissions) {
-    if (decl.permissionTier === 'session_consent' || decl.permissionTier === 'always_confirm') {
-        const isGranted = sessionPermissions?.includes(decl.name) || sessionPermissions?.includes('*');
-        if (!isGranted) {
-            return {
-                status: 'pause',
-                finding: `Tool '${decl.name}' requires ${decl.permissionTier} authorization.`,
-                data: { tool: decl.name, permissionTier: decl.permissionTier, args },
-            };
-        }
-    }
-    return null;
-}
-async function runDynamicHandler(decl, args) {
-    if (!decl.handler) {
-        return {
-            status: 'ok',
-            finding: `${decl.name} accepted (no handler)`,
-            data: args,
-        };
-    }
-    try {
-        return await decl.handler(args);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return { status: 'error', finding: msg };
-    }
-}
-async function executeDynamicTool(decl, args, profile, sessionPermissions) {
-    const authEnvelope = await checkDynamicAuthorization(decl, args, profile, sessionPermissions);
-    if (authEnvelope) {
-        return authEnvelope;
-    }
-    const permissionEnvelope = checkDynamicPermissionTier(decl, args, sessionPermissions);
-    if (permissionEnvelope) {
-        return permissionEnvelope;
-    }
-    return runDynamicHandler(decl, args);
-}
-function mergeDynamicTools(current, loaded) {
-    const merged = [...(current ?? [])];
-    for (const tool of loaded) {
-        const existing = merged.findIndex((item) => item.name === tool.name);
-        if (existing >= 0) {
-            merged[existing] = tool;
-        }
-        else {
-            merged.push(tool);
-        }
-    }
-    return merged;
-}
-async function executeDynamicToolLoader(args) {
-    const { decl, toolArgs, profile, generation } = args;
-    const loader = generation.dynamicToolLoader;
-    if (!loader) {
-        return {
-            status: 'error',
-            finding: `Tool '${decl.name}' is marked as a loader but no loader is configured.`,
-        };
-    }
-    const loaded = await loader({
-        name: decl.name,
-        args: toolArgs,
-        profile,
-        currentTools: generation.dynamicTools ?? [],
-        sessionPermissions: generation.sessionPermissions,
-    });
-    generation.dynamicTools = mergeDynamicTools(generation.dynamicTools, loaded);
-    return {
-        status: 'ok',
-        finding: `Loaded ${String(loaded.length)} dynamic tool schema(s).`,
-        data: { loadedTools: loaded.map((tool) => tool.name) },
-    };
-}
-function isActionableDynamicDeclaration(decl) {
-    return Boolean(decl?.handler || decl?.canExecute || decl?.permissionTier || decl?.loadsDynamicTools);
-}
-async function executeDynamicDeclaration(args) {
-    const { decl, toolArgs, profile, generation } = args;
-    const res = await executeDynamicTool(decl, toolArgs, profile, generation.sessionPermissions);
-    if (res.status === 'ok' && decl.loadsDynamicTools) {
-        return await executeDynamicToolLoader({
-            decl,
-            toolArgs,
-            profile,
-            generation,
-        });
-    }
-    return res;
-}
-export { dispatchModelTool, executeDynamicDeclaration, findDynamicDeclaration, formatToolFinding, invokeFromUi, isActionableDynamicDeclaration, };

package/esm/src/kernel/engine/runner.js

@@ -1,6 +0,0 @@
-/**
- * Deterministic turn runner for THEORUM.
- *
- * @module
- */
-export { runTurn } from './runner/mod.js';

package/esm/src/kernel/engine/tree.d.ts

@@ -1,2 +0,0 @@
-declare function mapStrings(value: unknown, map: (text: string) => string): unknown;
-export { mapStrings };

package/esm/src/kernel/engine/tree.js

@@ -1,17 +0,0 @@
-function mapStrings(value, map) {
-    if (typeof value === 'string') {
-        return map(value);
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => mapStrings(item, map));
-    }
-    if (value && typeof value === 'object') {
-        const out = {};
-        for (const [key, nested] of Object.entries(value)) {
-            out[key] = mapStrings(nested, map);
-        }
-        return out;
-    }
-    return value;
-}
-export { mapStrings };

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

@@ -1,18 +0,0 @@
-/**
- * Profile, turn, tool, provider, egress, and event contracts for THEORUM.
- *
- * This entrypoint is type-first. Host applications import from here when they
- * want to declare profiles, tool schemas, provider adapters, turn requests, or
- * trace-safe event handlers without importing provider implementations.
- *
- * @module
- */
-import "../../_dnt.polyfills.js";
-export { runTurn } from './engine/runner.js';
-export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, getTool, listBuiltinIds, modelEntryByApiId, registerTools, requireModelSpec, resetTools, } from './registry/catalog.js';
-export type { ProfileDefinition } from './registry/profiles.js';
-export { clearProfiles, defineProfile, getProfile, hasProfile, listProfiles, registerProfile, registerProfiles, } from './registry/profiles.js';
-export { projectProfile, resolveTurn } from './registry/resolve.js';
-export { getStructured, registerStructured } from './registry/schemas.js';
-export { executeTool } from './registry/tools.js';
-export type * from './types.js';

package/esm/src/kernel/mod.js

@@ -1,16 +0,0 @@
-/**
- * Profile, turn, tool, provider, egress, and event contracts for THEORUM.
- *
- * This entrypoint is type-first. Host applications import from here when they
- * want to declare profiles, tool schemas, provider adapters, turn requests, or
- * trace-safe event handlers without importing provider implementations.
- *
- * @module
- */
-import "../../_dnt.polyfills.js";
-export { runTurn } from './engine/runner.js';
-export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, getTool, listBuiltinIds, modelEntryByApiId, registerTools, requireModelSpec, resetTools, } from './registry/catalog.js';
-export { clearProfiles, defineProfile, getProfile, hasProfile, listProfiles, registerProfile, registerProfiles, } from './registry/profiles.js';
-export { projectProfile, resolveTurn } from './registry/resolve.js';
-export { getStructured, registerStructured } from './registry/schemas.js';
-export { executeTool } from './registry/tools.js';

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

@@ -1,16 +0,0 @@
-import type { MediaLimits, Profile, TurnBlob } from '../types.js';
-declare function tooManyFilesMessage(maxFiles: number): string;
-declare function fileTooLargeMessage(maxBytes: number): string;
-declare function turnTooLargeMessage(maxTurnBytes: number): string;
-declare function requireMediaLimits(profile: Profile): MediaLimits;
-declare function sanitizeCsvText(text: string): string;
-declare function assertAttachmentLimits(blobs: TurnBlob[], limits: MediaLimits): void;
-declare function sanitizeTurnBlobs(attachments: TurnBlob[] | undefined, voice: TurnBlob[] | undefined, limits: MediaLimits | undefined): {
-    attachments?: TurnBlob[];
-    voice?: TurnBlob[];
-};
-declare function sanitizeTurnBlobsForProfile(profileId: string, attachments: TurnBlob[] | undefined, voice: TurnBlob[] | undefined): {
-    attachments?: TurnBlob[];
-    voice?: TurnBlob[];
-};
-export { assertAttachmentLimits, fileTooLargeMessage, requireMediaLimits, sanitizeCsvText, sanitizeTurnBlobs, sanitizeTurnBlobsForProfile, tooManyFilesMessage, turnTooLargeMessage, };

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

@@ -1,156 +0,0 @@
-import { TheorumError } from '../../guardrails/error.js';
-import { injectionSpans } from '../../guardrails/injection.js';
-import { sensitiveSpans } from '../../guardrails/sensitive.js';
-import { applySpans } from '../../observability/spans.js';
-import { getProfile } from './profiles.js';
-const B64_PAD = 2;
-const B64_WORD = 4;
-const B64_TRIPLET = 3;
-const CSV_FORMULA = /(^|,)(\s*)("?)(?:([=@])|([+-])(?![0-9."]))/gm;
-const B64_BODY = /^[A-Za-z0-9+/]*={0,2}$/;
-const TEXT_MIMES = new Set(['text/csv', 'text/plain', 'text/markdown']);
-const BYTES_PER_KIB = 1024;
-function formatMb(bytes) {
-    const mb = bytes / (BYTES_PER_KIB * BYTES_PER_KIB);
-    return Number.isInteger(mb) ? `${String(mb)} MB` : `${mb.toFixed(1)} MB`;
-}
-function tooManyFilesMessage(maxFiles) {
-    return maxFiles === 1
-        ? 'Only 1 file per message.'
-        : `Only ${String(maxFiles)} files per message.`;
-}
-function fileTooLargeMessage(maxBytes) {
-    return `Each file must be ${formatMb(maxBytes)} or smaller.`;
-}
-function turnTooLargeMessage(maxTurnBytes) {
-    return `Those files together are too large for one message (${formatMb(maxTurnBytes)} max).`;
-}
-function mediaLimits(inputs) {
-    const { maxFiles, maxBytes, maxTurnBytes, limitsByMime } = inputs;
-    if (maxFiles && maxBytes && maxTurnBytes) {
-        return { maxFiles, maxBytes, maxTurnBytes, limitsByMime };
-    }
-    return undefined;
-}
-function maxBytesForMime(mimeType, limits) {
-    if (limits.limitsByMime) {
-        const cleanMime = mimeType.split(';')[0]?.trim().toLowerCase() ?? '';
-        if (limits.limitsByMime[cleanMime]) {
-            return limits.limitsByMime[cleanMime];
-        }
-        const [category] = cleanMime.split('/');
-        const wildCard = `${category}/*`;
-        if (limits.limitsByMime[wildCard]) {
-            return limits.limitsByMime[wildCard];
-        }
-    }
-    return limits.maxBytes;
-}
-function requireMediaLimits(profile) {
-    const limits = mediaLimits(profile.inputs);
-    if (!limits) {
-        throw new TheorumError(`Profile ${profile.id} must set maxFiles, maxBytes, and maxTurnBytes`);
-    }
-    return limits;
-}
-function b64DecodedLen(data) {
-    let pad = 0;
-    if (data.endsWith('==')) {
-        pad = B64_PAD;
-    }
-    else if (data.endsWith('=')) {
-        pad = 1;
-    }
-    return Math.floor((data.length * B64_TRIPLET) / B64_WORD) - pad;
-}
-function decodeB64(data) {
-    const binary = atob(data);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i += 1) {
-        bytes[i] = binary.charCodeAt(i);
-    }
-    return bytes;
-}
-function encodeB64(bytes) {
-    let binary = '';
-    for (const byte of bytes) {
-        binary += String.fromCharCode(byte);
-    }
-    return btoa(binary);
-}
-function decodeText(bytes) {
-    try {
-        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
-    }
-    catch {
-        return new TextDecoder('latin1').decode(bytes);
-    }
-}
-function sanitizeCsvText(text) {
-    return text.replace(CSV_FORMULA, (_full, ...groups) => {
-        const [a, b, c, d, e] = groups;
-        return `${a}${b}${c}'${d ?? ''}${e ?? ''}`;
-    });
-}
-function sanitizeTextBytes(mime, bytes) {
-    let text = decodeText(bytes);
-    if (mime === 'text/csv') {
-        text = sanitizeCsvText(text);
-    }
-    return new TextEncoder().encode(applySpans(text, [...injectionSpans(text), ...sensitiveSpans(text)]));
-}
-function assertAttachmentLimits(blobs, limits) {
-    if (blobs.length > limits.maxFiles) {
-        throw new TheorumError(tooManyFilesMessage(limits.maxFiles));
-    }
-    let total = 0;
-    for (const blob of blobs) {
-        const { data, mimeType } = blob;
-        if (!B64_BODY.test(data)) {
-            throw new TheorumError('attachment data must be base64');
-        }
-        const size = b64DecodedLen(data);
-        const maxAllowed = maxBytesForMime(mimeType, limits);
-        if (size > maxAllowed) {
-            throw new TheorumError(fileTooLargeMessage(maxAllowed));
-        }
-        total += size;
-    }
-    if (total > limits.maxTurnBytes) {
-        throw new TheorumError(turnTooLargeMessage(limits.maxTurnBytes));
-    }
-}
-function sanitizeAttachment(blob) {
-    const { mimeType, data } = blob;
-    if (!TEXT_MIMES.has(mimeType.split(';')[0]?.trim().toLowerCase() ?? '')) {
-        return blob;
-    }
-    const bytes = sanitizeTextBytes(mimeType, decodeB64(data));
-    return { mimeType, data: encodeB64(bytes) };
-}
-function hasTurnBlobs(attachments, voice) {
-    return (attachments?.length ?? 0) > 0 || (voice?.length ?? 0) > 0;
-}
-function sanitizeTurnBlobs(attachments, voice, limits) {
-    if (!hasTurnBlobs(attachments, voice)) {
-        return { attachments, voice };
-    }
-    const files = attachments ?? [];
-    const clips = voice ?? [];
-    if (!limits) {
-        throw new TheorumError('This profile does not accept files.');
-    }
-    assertAttachmentLimits([...files, ...clips], limits);
-    return {
-        attachments: files.length > 0 ? files.map(sanitizeAttachment) : attachments,
-        voice: clips.length > 0 ? clips.map(sanitizeAttachment) : voice,
-    };
-}
-function sanitizeTurnBlobsForProfile(profileId, attachments, voice) {
-    if (!hasTurnBlobs(attachments, voice)) {
-        return { attachments, voice };
-    }
-    const limits = requireMediaLimits(getProfile(profileId));
-    return sanitizeTurnBlobs(attachments, voice, limits);
-}
-export { assertAttachmentLimits, fileTooLargeMessage, requireMediaLimits, sanitizeCsvText, sanitizeTurnBlobs, sanitizeTurnBlobsForProfile, tooManyFilesMessage, turnTooLargeMessage, };

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

@@ -1,31 +0,0 @@
-/**
- * Tool catalog and MIME helpers.
- *
- * Model wire metadata is host-owned on `profile.model.config`. This module only
- * keeps builtin/custom tool descriptors and shared MIME utilities.
- *
- * @module
- */
-import type { BuiltinToolId, Catalog, GeminiInputKind, ModelId, ModelSpec, Profile, ThinkingLevel, ToolCatalogEntry, ToolId } from '../types.js';
-/** Live tool catalog. Starts with harness tools; presets/hosts register more. */
-declare const CATALOG: Catalog;
-/** Register or replace tool descriptors (idempotent per id). */
-declare function registerTools(entries: Record<string, ToolCatalogEntry>): void;
-/** Look up one registered tool descriptor. */
-declare function getTool(id: ToolId): ToolCatalogEntry | undefined;
-/** Ids of all registered provider builtins. */
-declare function listBuiltinIds(): BuiltinToolId[];
-/** Restore harness-only tools (tests / host reloads). */
-declare function resetTools(): void;
-declare function mimeEssence(mime: string): string;
-declare function mimeAllowed(accept: string[], mime: string): boolean;
-declare function geminiKindForMime(mime: string): GeminiInputKind | undefined;
-/** Require a host-declared model spec for an allowed profile model id. */
-declare function requireModelSpec(profile: Profile, modelId: ModelId): ModelSpec;
-/** Clamp a requested thinking level to what the model spec accepts. */
-declare function clampThinkingLevel(spec: ModelSpec, level: ThinkingLevel): ThinkingLevel;
-/** Look up a model spec by provider-native API id within a host specs map. */
-declare function modelEntryByApiId(specs: Record<string, ModelSpec>, apiId: string): ModelSpec | undefined;
-/** Clamp thinking level using a provider-native API id within a host specs map. */
-declare function clampThinkingLevelForApiId(specs: Record<string, ModelSpec>, apiId: string, level: ThinkingLevel): ThinkingLevel;
-export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, geminiKindForMime, getTool, listBuiltinIds, mimeAllowed, mimeEssence, modelEntryByApiId, registerTools, requireModelSpec, resetTools, };

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

@@ -1,135 +0,0 @@
-/**
- * Tool catalog and MIME helpers.
- *
- * Model wire metadata is host-owned on `profile.model.config`. This module only
- * keeps builtin/custom tool descriptors and shared MIME utilities.
- *
- * @module
- */
-import { TheorumError } from '../../guardrails/error.js';
-const ASK_USER_SCHEMA = {
-    type: 'object',
-    properties: {
-        kind: { type: 'string', enum: ['confirm', 'choice', 'text'] },
-        prompt: { type: 'string' },
-        options: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['kind', 'prompt'],
-};
-/** Harness tools that always ship with THEORUM. */
-const HARNESS_TOOLS = {
-    askUser: { kind: 'custom', ui: true, schema: ASK_USER_SCHEMA },
-};
-/** Live tool catalog. Starts with harness tools; presets/hosts register more. */
-const CATALOG = {
-    tools: { ...HARNESS_TOOLS },
-};
-/** Register or replace tool descriptors (idempotent per id). */
-function registerTools(entries) {
-    Object.assign(CATALOG.tools, entries);
-}
-/** Look up one registered tool descriptor. */
-function getTool(id) {
-    return CATALOG.tools[id];
-}
-/** Ids of all registered provider builtins. */
-function listBuiltinIds() {
-    return Object.entries(CATALOG.tools)
-        .filter(([, entry]) => entry.kind === 'builtin')
-        .map(([id]) => id);
-}
-/** Restore harness-only tools (tests / host reloads). */
-function resetTools() {
-    for (const id of Object.keys(CATALOG.tools)) {
-        delete CATALOG.tools[id];
-    }
-    Object.assign(CATALOG.tools, HARNESS_TOOLS);
-}
-/** Gemini Interactions inline MIME → part type (adapter wire map). */
-const GEMINI_INPUT_KINDS = {
-    'image/png': 'image',
-    'image/jpeg': 'image',
-    'image/jpg': 'image',
-    'image/webp': 'image',
-    'image/heic': 'image',
-    'image/heif': 'image',
-    'audio/wav': 'audio',
-    'audio/x-wav': 'audio',
-    'audio/mpeg': 'audio',
-    'audio/mp3': 'audio',
-    'audio/aiff': 'audio',
-    'audio/aac': 'audio',
-    'audio/ogg': 'audio',
-    'audio/flac': 'audio',
-    'audio/webm': 'audio',
-    'audio/mp4': 'audio',
-    'audio/pcm': 'audio',
-    'video/mp4': 'video',
-    'video/mpeg': 'video',
-    'video/quicktime': 'video',
-    'video/x-msvideo': 'video',
-    'video/x-flv': 'video',
-    'video/mpg': 'video',
-    'video/webm': 'video',
-    'video/wmv': 'video',
-    'video/x-ms-wmv': 'video',
-    'video/3gpp': 'video',
-    'application/pdf': 'document',
-    'text/plain': 'document',
-    'text/csv': 'document',
-    'text/markdown': 'document',
-    'text/html': 'document',
-    'application/json': 'document',
-};
-function mimeEssence(mime) {
-    const [base] = mime.split(';');
-    return (base ?? '').trim().toLowerCase();
-}
-function mimeAllowed(accept, mime) {
-    const actual = mimeEssence(mime);
-    return accept.some((rule) => {
-        const allowed = mimeEssence(rule);
-        if (allowed.endsWith('/*')) {
-            return actual.startsWith(allowed.slice(0, -1));
-        }
-        return allowed === actual;
-    });
-}
-function geminiKindForMime(mime) {
-    return GEMINI_INPUT_KINDS[mimeEssence(mime)];
-}
-/** Require a host-declared model spec for an allowed profile model id. */
-function requireModelSpec(profile, modelId) {
-    const spec = profile.model.config[modelId];
-    if (!spec) {
-        throw new TheorumError(`Profile ${profile.id} has no model spec for '${modelId}'`);
-    }
-    return spec;
-}
-function clampLevels(entry, level) {
-    if (!entry?.thinkingLevels || entry.thinkingLevels.length === 0) {
-        return level;
-    }
-    if (entry.thinkingLevels.includes(level)) {
-        return level;
-    }
-    const fallback = entry.thinking.off;
-    if (entry.thinkingLevels.includes(fallback)) {
-        return fallback;
-    }
-    const first = entry.thinkingLevels[0];
-    return first ?? level;
-}
-/** Clamp a requested thinking level to what the model spec accepts. */
-function clampThinkingLevel(spec, level) {
-    return clampLevels(spec, level);
-}
-/** Look up a model spec by provider-native API id within a host specs map. */
-function modelEntryByApiId(specs, apiId) {
-    return Object.values(specs).find((m) => m.apiId === apiId);
-}
-/** Clamp thinking level using a provider-native API id within a host specs map. */
-function clampThinkingLevelForApiId(specs, apiId, level) {
-    return clampLevels(modelEntryByApiId(specs, apiId), level);
-}
-export { CATALOG, clampThinkingLevel, clampThinkingLevelForApiId, geminiKindForMime, getTool, listBuiltinIds, mimeAllowed, mimeEssence, modelEntryByApiId, registerTools, requireModelSpec, resetTools, };

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

@@ -1,13 +0,0 @@
-/**
- * Kernel ingress: input parts, image pins, and speech-role checks.
- *
- * Owned by the kernel so `resolveTurn` does not import provider adapters.
- *
- * @module
- */
-import type { BuiltinToolId, ImageResponseFormat, InteractionPart, ModelId, Profile, TurnRequest } from '../types.js';
-declare function assertSpeechRole(profile: Profile): void;
-declare function resolveImageFormat(profile: Profile, _model: ModelId, slots?: Record<string, string>): ImageResponseFormat | null;
-declare function resolveInputParts(profile: Profile, model: ModelId, req: TurnRequest): InteractionPart[];
-declare function assertImageGrounding(profile: Profile, model: ModelId, builtins: BuiltinToolId[]): void;
-export { assertImageGrounding, assertSpeechRole, resolveImageFormat, resolveInputParts };