theorum 0.1.15 → 1.1.3

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

@@ -1,106 +1,352 @@
 /**
  * Runtime profile registry for host-owned THEORUM profiles.
  *
- * THEORUM ships profile types and defaults, not application profiles. Host apps
- * register their profiles at process startup or test setup.
+ * THEORUM ships profile types — not application profiles and not invented defaults.
+ * Hosts must pass required fields explicitly (`type`, `models`, …).
  *
  * @module
  */
 import { TheorumError } from '../../guardrails/error.js';
+import { HOST_GUARDRAIL_FIELDS, } from '../../guardrails/types.js';
+import { resolveObservabilityPolicy } from '../../observability/resolve-policy.js';
+import { assertLiveIngressConfigured } from '../engine/live-ingress.js';
+import { CACHE_MODES, CACHE_TTLS, isValidPair, isValidProfileProtocol, protocolsForProfileType, } from '../schema.js';
+import { isContinueStopKind } from '../stop.js';
+import { getTool } from '../tools/registry.js';
+import { soleModelId } from './sole-model.js';
 const profiles = new Map();
-function assertModelSpecs(profileId, allow, config) {
-    for (const id of allow) {
-        if (!config[id]) {
-            throw new TheorumError(`Profile ${profileId} allowlists '${id}' without a model spec`);
+/** Fields a `host` profile must not carry — rejected when supplied. */
+const HOST_ABSENT_FIELDS = [
+    'models',
+    'defaultModel',
+    'allowModelSelect',
+    'identity',
+    'inputs',
+    'outputs',
+    'turnBehaviour',
+    'key',
+    'maxSteps',
+];
+/**
+ * Guardrails that only a model turn can run, so a host profile must not declare
+ * them: `egress` gates user-visible model text in the turn runner, `canary` is
+ * minted into a system prompt, and `quota` counts turns. None is reachable from
+ * `invokeTool`, so accepting them would register config that guards nothing.
+ */
+const HOST_ABSENT_GUARDRAILS = ['quota', 'canary', 'egress'];
+const HOST_GUARDRAIL_REASON = {
+    quota: 'quota counts model turns', // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    canary: 'canary is minted into a system prompt', // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    egress: 'egress gates user-visible model text in the turn runner', // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+};
+function assertHostGuardrails(profileId, guardrails) {
+    if (!guardrails)
+        return;
+    const extra = guardrails;
+    for (const key of HOST_ABSENT_GUARDRAILS) {
+        if (extra[key] !== undefined) {
+            throw new TheorumError(`Profile ${profileId}: type 'host' must not set guardrails.${key} — a host profile runs no model and ${HOST_GUARDRAIL_REASON[key]}. Host profiles accept ${HOST_GUARDRAIL_FIELDS.join(', ')}.`);
         }
     }
 }
-function buildDefaultIdentity(id, identity) {
+function defineHostProfile(input) {
+    const extra = input;
+    for (const key of HOST_ABSENT_FIELDS) {
+        if (extra[key] !== undefined) {
+            throw new TheorumError(`Profile ${input.id}: type 'host' must not set ${key}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        }
+    }
+    assertHostGuardrails(input.id, input.guardrails);
+    assertHostTools(input.id, input.tools);
+    assertObservability(input.id, input.observability);
     return {
-        handle: identity?.handle ?? id,
-        chat: identity?.chat,
-        system: identity?.system,
-        systemByRole: identity?.systemByRole,
+        type: 'host',
+        id: input.id,
+        tools: { allow: input.tools.allow },
+        guardrails: input.guardrails,
+        observability: input.observability,
     };
 }
-function buildDefaultModel(profileId, model) {
-    assertModelSpecs(profileId, model.allow, model.config);
-    return {
-        protocol: model.protocol ?? 'geminiInteractions',
-        provider: model.provider ?? 'google',
-        allow: model.allow,
-        config: model.config,
-        thinking: model.thinking ?? 'minimal',
-        controls: model.controls ?? [],
-        maxSteps: model.maxSteps ?? 1,
-        key: model.key ?? 'freeA',
-        select: model.select,
-    };
+function assertHostTools(profileId, tools) {
+    if (!Array.isArray(tools?.allow)) {
+        throw new TheorumError(`Profile ${profileId}: type 'host' must set tools.allow`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    const extra = tools;
+    if (extra.t1Policy !== undefined || extra.t2Loader !== undefined) {
+        throw new TheorumError(`Profile ${profileId}: tools.t1Policy / tools.t2Loader are not supported on type 'host' — every allowed tool is executable`);
+    }
 }
-function buildDefaultInputs(inputs) {
-    return {
-        text: inputs?.text ?? true,
-        attachments: inputs?.attachments,
-        voice: inputs?.voice,
-        maxFiles: inputs?.maxFiles,
-        maxBytes: inputs?.maxBytes,
-        maxTurnBytes: inputs?.maxTurnBytes,
-        limitsByMime: inputs?.limitsByMime,
-        slots: inputs?.slots,
-    };
+function assertModelsNonEmpty(profileId, models) {
+    if (Object.keys(models).length === 0) {
+        throw new TheorumError(`Profile ${profileId} must declare at least one model`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
 }
-function buildDefaultOutputs(outputs) {
-    return {
-        structured: outputs?.structured ?? null,
-        image: outputs?.image,
-        speech: outputs?.speech,
-        validation: outputs?.validation,
-        streaming: outputs?.streaming,
-    };
+function assertDefaultModel(profileId, input) {
+    const ids = Object.keys(input.models);
+    const inferred = input.defaultModel ?? soleModelId(input.models);
+    if (!inferred) {
+        throw new TheorumError(`Profile ${profileId} must set defaultModel when more than one model is declared`);
+    }
+    if (!input.models[inferred]) {
+        throw new TheorumError(`Profile ${profileId} defaultModel '${inferred}' is not declared`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (input.allowModelSelect && ids.length < 2) {
+        throw new TheorumError(`Profile ${profileId} allowModelSelect requires at least two models`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+}
+function assertModelBinding(profileId, modelId, binding) {
+    if (!binding.protocol) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}' must set protocol`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (!binding.provider) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}' must set provider`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (!binding.apiId) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}' must set apiId`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (!isValidPair(binding.protocol, binding.provider)) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}': protocol '${binding.protocol}' is not valid for provider '${binding.provider}'`);
+    }
+    assertModelEfforts(profileId, modelId, binding);
+    if (binding.cache) {
+        assertCacheSpec(profileId, modelId, binding);
+    }
+    assertInteractionsPersistence(profileId, modelId, binding);
 }
-function buildDefaultGuardrails(guardrails) {
+function assertModelEfforts(profileId, modelId, binding) {
+    const efforts = binding.efforts;
+    if (!efforts || Object.keys(efforts).length === 0) {
+        if (binding.defaultEffort || binding.allowEffortSelect) {
+            throw new TheorumError(`Profile ${profileId} model '${modelId}': defaultEffort and allowEffortSelect require efforts`);
+        }
+        return;
+    }
+    const keys = Object.keys(efforts);
+    const defaultAlias = binding.defaultEffort ?? (keys.length === 1 ? keys[0] : undefined);
+    if (!defaultAlias) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}' must set defaultEffort when more than one effort is declared`);
+    }
+    if (!efforts[defaultAlias]) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}' defaultEffort '${defaultAlias}' is not declared`);
+    }
+    if (binding.allowEffortSelect && keys.length < 2) {
+        throw new TheorumError(`Profile ${profileId} model '${modelId}' allowEffortSelect requires at least two efforts`);
+    }
+}
+function assertTypeProtocols(profile) {
+    for (const [modelId, binding] of Object.entries(profile.models)) {
+        if (!isValidProfileProtocol(profile.type, binding.protocol)) {
+            const valid = protocolsForProfileType(profile.type).join(', ');
+            throw new TheorumError(`Profile ${profile.id} model '${modelId}': type '${profile.type}' cannot use protocol '${binding.protocol}'. Supported: ${valid}`);
+        }
+    }
+}
+function profileModelFields(input) {
     return {
-        quota: guardrails?.quota,
-        canary: guardrails?.canary ?? true,
-        sanitizeInput: guardrails?.sanitizeInput ?? true,
-        redactSensitive: guardrails?.redactSensitive ?? true,
-        egress: guardrails?.egress,
+        models: input.models,
+        defaultModel: input.defaultModel ?? soleModelId(input.models),
+        allowModelSelect: input.allowModelSelect,
+        maxSteps: input.maxSteps,
+        key: input.key,
     };
 }
-/** Define a typed profile with stable defaults for optional properties. */
+function assertContinueKindList(profileId, path, kinds) {
+    if (!kinds?.length)
+        return;
+    for (const kind of kinds) {
+        if (!isContinueStopKind(kind)) {
+            throw new TheorumError(`Profile ${profileId}: turnBehaviour.resumption.${path} may only include ContinueStopKind ` + // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+                `(length | stream_incomplete | provider_error); got '${kind}'`);
+        }
+    }
+}
+function assertResumption(profileId, resumption) {
+    if (!resumption)
+        return;
+    assertContinueKindList(profileId, 'allowContinue', resumption.allowContinue);
+    assertContinueKindList(profileId, 'autoContinue', resumption.autoContinue);
+}
+function assertTurnBehaviour(profileId, input) {
+    if (input.type === 'host')
+        return;
+    if (input.type === 'live') {
+        const tb = input.turnBehaviour;
+        if (tb?.resumption !== undefined) {
+            throw new TheorumError(`Profile ${profileId}: type 'live' uses live.sessionResumption, not turnBehaviour.resumption`);
+        }
+        return;
+    }
+    if (input.type !== 'text' && input.turnBehaviour?.allowSteering !== undefined) {
+        throw new TheorumError(`Profile ${profileId}: turnBehaviour.allowSteering is only valid on type 'text' or 'live'`);
+    }
+    assertResumption(profileId, input.turnBehaviour?.resumption);
+}
+function assertObservability(profileId, spec) {
+    if (!spec) {
+        return;
+    }
+    try {
+        const policy = resolveObservabilityPolicy(spec);
+        if (policy.retainForDays <= 0 || !Number.isFinite(policy.retainForDays)) {
+            throw new TheorumError(`Profile ${profileId}: observability.retainForDays must be a positive number`);
+        }
+        if (policy.rotateAfterMiB <= 0 || !Number.isFinite(policy.rotateAfterMiB)) {
+            throw new TheorumError(`Profile ${profileId}: observability.rotateAfterMiB must be a positive number`);
+        }
+    }
+    catch (err) {
+        if (err instanceof TheorumError && err.message.startsWith('Profile ')) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new TheorumError(`Profile ${profileId}: ${message}`);
+    }
+}
 function defineProfile(input) {
-    return {
-        id: input.id,
-        identity: buildDefaultIdentity(input.id, input.identity),
-        model: buildDefaultModel(input.id, input.model),
-        tools: { allow: input.tools?.allow ?? [] },
-        inputs: buildDefaultInputs(input.inputs),
-        outputs: buildDefaultOutputs(input.outputs),
-        guardrails: buildDefaultGuardrails(input.guardrails),
+    if (input.type === 'host') {
+        return defineHostProfile(input);
+    }
+    assertModelsNonEmpty(input.id, input.models);
+    assertDefaultModel(input.id, input);
+    assertTurnBehaviour(input.id, input);
+    assertObservability(input.id, input.observability);
+    for (const [modelId, binding] of Object.entries(input.models)) {
+        assertModelBinding(input.id, modelId, binding);
+    }
+    const identity = {
+        handle: input.identity.handle,
+        system: input.identity.system,
+        systemByRole: input.identity.systemByRole,
     };
+    const guardrails = input.guardrails;
+    const observability = input.observability;
+    const modelFields = profileModelFields(input);
+    let profile;
+    switch (input.type) {
+        case 'text':
+            profile = {
+                type: 'text',
+                id: input.id,
+                identity,
+                ...modelFields,
+                tools: input.tools,
+                inputs: input.inputs,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
+                guardrails,
+                observability,
+            };
+            break;
+        case 'image':
+            profile = {
+                type: 'image',
+                id: input.id,
+                identity,
+                ...modelFields,
+                image: input.image,
+                tools: input.tools,
+                inputs: input.inputs,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
+                guardrails,
+                observability,
+            };
+            break;
+        case 'speech':
+            profile = {
+                type: 'speech',
+                id: input.id,
+                identity,
+                ...modelFields,
+                speech: input.speech,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
+                guardrails,
+                observability,
+            };
+            break;
+        case 'live': {
+            const liveInput = input;
+            if (liveInput.inputs !== undefined) {
+                throw new TheorumError(`Profile ${input.id}: type 'live' must not set inputs`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            }
+            if (liveInput.outputs !== undefined) {
+                throw new TheorumError(`Profile ${input.id}: type 'live' must not set outputs`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            }
+            profile = {
+                type: 'live',
+                id: input.id,
+                identity,
+                ...modelFields,
+                live: input.live,
+                tools: assertLiveTools(input.id, input.tools),
+                turnBehaviour: liveInput.turnBehaviour,
+                guardrails,
+                observability,
+            };
+            assertLiveIngressConfigured(profile);
+            break;
+        }
+        default: {
+            const _exhaustive = input;
+            throw new TheorumError(`Unknown profile type '${String(_exhaustive)}'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        }
+    }
+    assertTypeProtocols(profile);
+    return profile;
 }
 function assertCompactionSpec(profileId, modelId, spec) {
-    const tag = `Profile ${profileId} model ${modelId} compaction`;
+    const tag = `Profile ${profileId} model ${modelId} compaction`; // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     assertCompactionBudget(tag, spec);
     assertCompactionRetain(tag, spec);
     if (spec.meter != null && spec.meter !== 'history' && spec.meter !== 'input') {
-        throw new TheorumError(`${tag}: meter must be 'history' or 'input'`);
+        throw new TheorumError(`${tag}: meter must be 'history' or 'input'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (!profiles.has(spec.profile)) {
         throw new TheorumError(`${tag}: compaction profile '${spec.profile}' must be registered before '${profileId}'`);
     }
 }
+function assertCacheSpec(profileId, modelId, binding) {
+    const spec = binding.cache;
+    if (!spec) {
+        return;
+    }
+    const tag = `Profile ${profileId} model '${modelId}'`;
+    if (binding.provider !== 'openrouter' || binding.protocol !== 'openAi') {
+        throw new TheorumError(`${tag}: cache is only valid when protocol is 'openAi' and provider is 'openrouter'`);
+    }
+    if (!CACHE_MODES.includes(spec.mode)) {
+        throw new TheorumError(`${tag}: cache.mode must be one of ${CACHE_MODES.join(' | ')}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (spec.ttl != null && !CACHE_TTLS.includes(spec.ttl)) {
+        throw new TheorumError(`${tag}: cache.ttl must be one of ${CACHE_TTLS.join(' | ')}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+}
+function assertInteractionsPersistence(profileId, modelId, binding) {
+    if (binding.store === undefined && binding.persistViaInteractionId === undefined) {
+        return;
+    }
+    if (binding.protocol === 'geminiInteractions' && binding.provider === 'google') {
+        return;
+    }
+    const which = binding.store !== undefined && binding.persistViaInteractionId !== undefined
+        ? 'store and persistViaInteractionId' // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        : binding.store !== undefined
+            ? 'store'
+            : 'persistViaInteractionId';
+    throw new TheorumError(`Profile ${profileId} model '${modelId}': ${which} is only valid when protocol is 'geminiInteractions' and provider is 'google'`);
+}
 function assertCompactionBudget(tag, spec) {
     if (spec.maxTokens <= 0) {
-        throw new TheorumError(`${tag}: maxTokens must be > 0`);
+        throw new TheorumError(`${tag}: maxTokens must be > 0`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (spec.compactAt <= 0 || spec.compactAt >= 1) {
-        throw new TheorumError(`${tag}: compactAt must be in (0, 1)`);
+        throw new TheorumError(`${tag}: compactAt must be in (0, 1)`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
 function assertCompactionRetain(tag, spec) {
     if (spec.previousExchanges < 0) {
-        throw new TheorumError(`${tag}: previousExchanges must be >= 0`);
+        throw new TheorumError(`${tag}: previousExchanges must be >= 0`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (spec.previousExchanges > 0 && spec.previousExchanges < 1) {
         if (spec.previousExchanges >= spec.compactAt) {
@@ -108,22 +354,116 @@ function assertCompactionRetain(tag, spec) {
         }
     }
     if (spec.previousExchanges >= 1 && !Number.isInteger(spec.previousExchanges)) {
-        throw new TheorumError(`${tag}: previousExchanges >= 1 must be an integer`);
+        throw new TheorumError(`${tag}: previousExchanges >= 1 must be an integer`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
-/** Register one host-owned profile in the process-local registry. */
-function registerProfile(profileInput) {
-    const profile = defineProfile(profileInput);
-    assertModelSpecs(profile.id, profile.model.allow, profile.model.config);
-    const { attachments, voice, maxFiles, maxBytes, maxTurnBytes } = profile.inputs;
+function profileToolsAllow(profile) {
+    if (profile.type === 'speech') {
+        return [];
+    }
+    return profile.tools.allow;
+}
+function assertCustomToolsOnly(profile) {
+    for (const id of profileToolsAllow(profile)) {
+        const tool = getTool(id);
+        if (tool?.type === 'builtin') {
+            throw new TheorumError(profile.type === 'host'
+                ? `Profile ${profile.id} lists builtin '${id}' in tools.allow — type 'host' never runs a model` // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+                : `Profile ${profile.id} lists builtin '${id}' in tools.allow — declare it on models.*.builtInTools instead`);
+        }
+    }
+}
+function assertLiveTools(profileId, tools) {
+    const extra = tools;
+    if (extra.t1Policy !== undefined) {
+        throw new TheorumError(`Profile ${profileId}: tools.t1Policy is not supported on type 'live' — wire T0 tools in tools.allow for session setup`);
+    }
+    if (extra.t2Loader !== undefined) {
+        throw new TheorumError(`Profile ${profileId}: tools.t2Loader is not supported on type 'live' — Gemini Live function declarations are fixed at session setup`);
+    }
+    return { allow: tools.allow };
+}
+function assertProfileToolLoader(profile) {
+    if (profile.type === 'speech') {
+        return;
+    }
+    if (profile.type === 'live') {
+        assertLiveTools(profile.id, profile.tools);
+        return;
+    }
+    if (profile.type === 'host') {
+        assertHostTools(profile.id, profile.tools);
+        return;
+    }
+    const loaderId = profile.tools.t2Loader;
+    if (!loaderId) {
+        return;
+    }
+    if (!profile.tools.allow.includes(loaderId)) {
+        throw new TheorumError(`Profile ${profile.id} tools.t2Loader '${loaderId}' must also be listed in tools.allow`);
+    }
+    const tool = getTool(loaderId);
+    if (tool?.type !== 'function') {
+        throw new TheorumError(`Profile ${profile.id} tools.t2Loader '${loaderId}' must be a registered type: 'function' tool`);
+    }
+}
+/** Every builtin id declared across a profile's model bindings. */
+function* modelBuiltinIds(profile) {
+    for (const [modelId, binding] of Object.entries(profile.models)) {
+        for (const id of binding.builtInTools ?? []) {
+            yield { modelId, id };
+        }
+    }
+}
+function assertModelBuiltInTools(profile) {
+    for (const { modelId, id } of modelBuiltinIds(profile)) {
+        const tool = getTool(id);
+        if (tool?.type !== 'builtin') {
+            throw new TheorumError(`Profile ${profile.id} model '${modelId}' lists '${id}' in builtInTools — not a registered builtin`);
+        }
+    }
+}
+function assertCompactionOnlyOnText(profile) {
+    if (profile.type === 'text') {
+        return;
+    }
+    for (const [modelId, binding] of Object.entries(profile.models)) {
+        if (binding.compaction) {
+            throw new TheorumError(`Profile ${profile.id} model '${modelId}': compaction is only valid on type 'text'`);
+        }
+    }
+}
+function assertMediaLimits(profile) {
+    if (profile.type === 'speech' || profile.type === 'live') {
+        return;
+    }
+    const inputs = profile.inputs;
+    if (!inputs) {
+        return;
+    }
+    const { attachments, voice, maxFiles, maxBytes, maxTurnBytes } = inputs;
     if (attachments || voice) {
         if (!(maxFiles && maxBytes && maxTurnBytes)) {
-            throw new TheorumError(`Profile ${profile.id} must set maxFiles, maxBytes, and maxTurnBytes`);
+            throw new TheorumError(`Profile ${profile.id} must set maxFiles, maxBytes, and maxTurnBytes`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
     }
-    for (const [modelId, spec] of Object.entries(profile.model.config)) {
-        if (spec.compaction) {
-            assertCompactionSpec(profile.id, modelId, spec.compaction);
+}
+/** Register one host-owned profile in the process-local registry. */
+function registerProfile(profileInput) {
+    const profile = defineProfile(profileInput);
+    assertCustomToolsOnly(profile);
+    assertProfileToolLoader(profile);
+    if (profile.type === 'host') {
+        // No models, ingress, media limits, or compaction to validate — the tool ceiling is the whole contract.
+        profiles.set(profile.id, profile);
+        return;
+    }
+    assertModelBuiltInTools(profile);
+    assertCompactionOnlyOnText(profile);
+    assertMediaLimits(profile);
+    for (const [modelId, binding] of Object.entries(profile.models)) {
+        if (binding.compaction) {
+            assertCompactionSpec(profile.id, modelId, binding.compaction);
         }
     }
     profiles.set(profile.id, profile);

package/esm/src/kernel/registry/provider-request.js

@@ -1,25 +1,31 @@
 /** Build the provider request projection shared by execution and tracing. */
 function providerCompleteRequest(generation, system) {
+    const isInteractions = generation.transport === 'interactions';
     return {
         model: generation.model,
         apiId: generation.apiId,
-        openRouterId: generation.openRouterId,
-        previousInteractionId: generation.previousInteractionId,
-        store: generation.store,
+        previousInteractionId: isInteractions ? generation.previousInteractionId : undefined,
+        store: isInteractions ? generation.store : undefined,
+        stream: isInteractions ? generation.stream : undefined,
         thinking: generation.thinking,
-        summaries: generation.summaries,
+        summaries: isInteractions ? generation.summaries : undefined,
         maxOutputTokens: generation.maxOutputTokens,
         temperature: generation.temperature,
         builtins: generation.builtins,
+        googleMapsLocation: isInteractions ? generation.googleMapsLocation : undefined,
+        cache: generation.cache,
+        sessionId: generation.sessionId,
         system,
         input: generation.input,
         history: generation.history,
-        dynamicTools: generation.dynamicTools,
-        dynamicToolLoader: generation.dynamicToolLoader,
+        interactionOnlyInput: isInteractions ? generation.interactionOnlyInput : undefined,
+        wireTools: generation.tools.wire,
         structured: generation.structured,
         image: generation.image,
         speech: generation.speech,
-        geminiBucket: generation.geminiBucket,
+        live: generation.live,
+        sessionResumptionHandle: generation.sessionResumptionHandle,
+        keySlot: generation.keySlot,
     };
 }
 export { providerCompleteRequest };

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

@@ -1,19 +1,19 @@
 /**
  * Profile resolution for THEORUM turns.
  *
- * This module validates caller overrides, selects models and tools, normalizes
- * input parts, and produces the provider request state consumed by `runTurn`.
- *
  * @module
  */
-import type { Profile, ProjectedProfile, ResolvedGeneration, ToolId, TurnRequest } from '../types.js';
-declare function assertToolAllowed(profile: Profile, name: ToolId): void;
+import type { ModelId, ModelProfile, Profile, ProjectedProfile, ResolvedGeneration, TurnRequest } from '../types.js';
+/** Narrow to a model-binding profile; `host` never runs a model. */
+declare function requireModelProfile(profile: Profile, door: string): ModelProfile;
+declare function pickModel(profile: ModelProfile, requested?: string): ModelId;
 /** Resolve a host `TurnRequest` into provider-ready generation state. */
 declare function resolveTurn(req: TurnRequest): {
-    profile: Profile;
+    profile: ModelProfile;
     generation: ResolvedGeneration;
 };
+/** Project a profile object into a safe host/UI inspection object. */
+declare function projectProfileObject(input: Profile): ProjectedProfile;
 /** Project a registered profile into a safe host/UI inspection object. */
 declare function projectProfile(id: Profile['id']): ProjectedProfile;
-declare function pickSystemRole(profile: Profile, requested?: string): string;
-export { assertToolAllowed, pickSystemRole, projectProfile, resolveTurn };
+export { pickModel, projectProfile, projectProfileObject, requireModelProfile, resolveTurn };