theorum 1.0.0 → 1.1.3

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

@@ -2,50 +2,225 @@
  * Runtime profile registry for host-owned THEORUM profiles.
  *
  * THEORUM ships profile types — not application profiles and not invented defaults.
- * Hosts must pass required fields explicitly (`type`, `model.protocol`, `model.provider`, …).
+ * Hosts must pass required fields explicitly (`type`, `models`, …).
  *
  * @module
  */
 import { TheorumError } from '../../guardrails/error.js';
-import { isValidPair, isValidProfileProtocol, protocolsForProfileType } from '../schema.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 assertProtocolProvider(profileId, model) {
-    if (!model.protocol) {
-        throw new TheorumError(`Profile ${profileId} must set model.protocol`);
+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)
+        }
     }
-    if (!model.provider) {
-        throw new TheorumError(`Profile ${profileId} must set model.provider`);
+    assertHostGuardrails(input.id, input.guardrails);
+    assertHostTools(input.id, input.tools);
+    assertObservability(input.id, input.observability);
+    return {
+        type: 'host',
+        id: input.id,
+        tools: { allow: input.tools.allow },
+        guardrails: input.guardrails,
+        observability: input.observability,
+    };
+}
+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)
     }
-    if (!isValidPair(model.protocol, model.provider)) {
-        throw new TheorumError(`Profile ${profileId}: protocol '${model.protocol}' is not valid for provider '${model.provider}'`);
+    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 assertTypeProtocol(profile) {
-    const protocol = profile.model.protocol;
-    if (isValidProfileProtocol(profile.type, protocol))
+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 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 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 valid = protocolsForProfileType(profile.type).join(', ');
-    throw new TheorumError(`Profile ${profile.id}: type '${profile.type}' cannot use protocol '${protocol}'. Supported: ${valid}`);
+    }
+    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 {
+        models: input.models,
+        defaultModel: input.defaultModel ?? soleModelId(input.models),
+        allowModelSelect: input.allowModelSelect,
+        maxSteps: input.maxSteps,
+        key: input.key,
+    };
+}
+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}`);
+    }
 }
-/** Define a typed profile. Required fields must be set explicitly; optional fields stay optional. */
 function defineProfile(input) {
-    assertProtocolProvider(input.id, input.model);
-    assertModelSpecs(input.id, input.model.allow, input.model.config);
+    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 outputs = input.outputs;
     const guardrails = input.guardrails;
+    const observability = input.observability;
+    const modelFields = profileModelFields(input);
     let profile;
     switch (input.type) {
         case 'text':
@@ -53,12 +228,13 @@ function defineProfile(input) {
                 type: 'text',
                 id: input.id,
                 identity,
-                model: input.model,
+                ...modelFields,
                 tools: input.tools,
                 inputs: input.inputs,
-                outputs,
-                turnResumption: input.turnResumption,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
                 guardrails,
+                observability,
             };
             break;
         case 'image':
@@ -66,13 +242,14 @@ function defineProfile(input) {
                 type: 'image',
                 id: input.id,
                 identity,
-                model: input.model,
+                ...modelFields,
                 image: input.image,
                 tools: input.tools,
                 inputs: input.inputs,
-                outputs,
-                turnResumption: input.turnResumption,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
                 guardrails,
+                observability,
             };
             break;
         case 'speech':
@@ -80,56 +257,96 @@ function defineProfile(input) {
                 type: 'speech',
                 id: input.id,
                 identity,
-                model: input.model,
+                ...modelFields,
                 speech: input.speech,
-                outputs,
-                turnResumption: input.turnResumption,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
                 guardrails,
+                observability,
             };
             break;
-        case 'live':
+        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,
-                model: input.model,
+                ...modelFields,
                 live: input.live,
-                tools: input.tools,
-                inputs: input.inputs,
-                outputs,
+                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)}'`);
+            throw new TheorumError(`Unknown profile type '${String(_exhaustive)}'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
     }
-    assertTypeProtocol(profile);
+    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) {
@@ -137,7 +354,7 @@ 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)
     }
 }
 function profileToolsAllow(profile) {
@@ -150,14 +367,34 @@ function assertCustomToolsOnly(profile) {
     for (const id of profileToolsAllow(profile)) {
         const tool = getTool(id);
         if (tool?.type === 'builtin') {
-            throw new TheorumError(`Profile ${profile.id} lists builtin '${id}' in tools.allow — declare it on model.config.*.builtInTools instead`);
+            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;
@@ -170,13 +407,19 @@ function assertProfileToolLoader(profile) {
         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, spec] of Object.entries(profile.model.config)) {
-        for (const id of spec.builtInTools ?? []) {
-            const tool = getTool(id);
-            if (tool?.type !== 'builtin') {
-                throw new TheorumError(`Profile ${profile.id} model '${modelId}' lists '${id}' in builtInTools — not a registered builtin`);
-            }
+    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`);
         }
     }
 }
@@ -184,14 +427,14 @@ function assertCompactionOnlyOnText(profile) {
     if (profile.type === 'text') {
         return;
     }
-    for (const [modelId, spec] of Object.entries(profile.model.config)) {
-        if (spec.compaction) {
+    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') {
+    if (profile.type === 'speech' || profile.type === 'live') {
         return;
     }
     const inputs = profile.inputs;
@@ -201,22 +444,26 @@ function assertMediaLimits(profile) {
     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)
         }
     }
 }
 /** 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);
     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, spec] of Object.entries(profile.model.config)) {
-        if (spec.compaction) {
-            assertCompactionSpec(profile.id, modelId, spec.compaction);
+    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

@@ -13,6 +13,8 @@ function providerCompleteRequest(generation, system) {
         temperature: generation.temperature,
         builtins: generation.builtins,
         googleMapsLocation: isInteractions ? generation.googleMapsLocation : undefined,
+        cache: generation.cache,
+        sessionId: generation.sessionId,
         system,
         input: generation.input,
         history: generation.history,

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

@@ -3,16 +3,17 @@
  *
  * @module
  */
-import type { ModelId, Profile, ProjectedProfile, ResolvedGeneration, TurnRequest } from '../types.js';
-declare function pickModel(profile: Profile, select?: string): ModelId;
+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(profile: Profile): ProjectedProfile;
+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 { pickModel, pickSystemRole, projectProfile, projectProfileObject, resolveTurn };
+export { pickModel, projectProfile, projectProfileObject, requireModelProfile, resolveTurn };