@theoremjs/agents 0.3.0 → 0.3.1

package/esm/src/kernel/profile-presence.d.ts

@@ -1,9 +1,18 @@
-/** lexicon-exempt-file: authoring field-meta presence notes — not runtime user or model copy (P2) */
+/** labels-exempt-file: authoring field-meta presence notes — not runtime user or model copy (P2) */
 export interface ProfileFieldPresence {
     /** The profile must set the field: always (`true`), or only in the case named. */
     required?: true | string;
     /** What leaving the field out does, as a short phrase a blank control can show. */
     unset?: string;
+    /**
+     * The value leaving the field out stands for, where one value says it: a profile that writes
+     * this value and one that leaves the field out are the same profile.
+     */
+    value?: unknown;
 }
+/** The most model calls a turn makes when its profile sets no `maxSteps`. */
+export declare const DEFAULT_MAX_STEPS = 20;
 /** Presence for profile paths, keyed like `PROFILE_FIELDS` (`models.*` matches every binding). */
 export declare const PROFILE_FIELD_PRESENCE: Readonly<Record<string, ProfileFieldPresence>>;
+/** The value leaving the field at `path` out stands for, or nothing when no one value says it. */
+export declare function unsetValue(path: readonly string[]): unknown;

package/esm/src/kernel/profile-presence.js

@@ -1,12 +1,12 @@
-// Leaf module: `schema.ts` reads it at load time. `defineProfile` enforces the requirements;
-// this records them for display.
+/** The most model calls a turn makes when its profile sets no `maxSteps`. */
+export const DEFAULT_MAX_STEPS = 20;
 /** Presence for profile paths, keyed like `PROFILE_FIELDS` (`models.*` matches every binding). */
 export const PROFILE_FIELD_PRESENCE = {
-    id: { required: true },
-    type: { required: true },
+    'profile.id': { required: true },
+    'profile.type': { required: true },
     identity: { required: true },
     'identity.handle': { required: true },
-    'identity.system': { unset: 'No system instruction' },
+    'identity.system': { unset: "Only the kernel's notes" },
     tools: { required: true },
     'tools.allow': { required: true },
     image: { required: true },
@@ -15,15 +15,21 @@ export const PROFILE_FIELD_PRESENCE = {
     decision: { required: true },
     'decision.contract': { required: true },
     models: { required: true },
-    defaultModel: { required: 'when more than one model is declared', unset: 'The only model' },
-    allowModelSelect: { unset: 'Off' },
-    maxSteps: { unset: 'Unbounded' },
-    key: { required: 'when a Google model has no key of its own', unset: 'No key slot' },
-    fallbackKey: { unset: 'No fallback' },
+    'profile.defaultModel': {
+        required: 'when more than one model is declared',
+        unset: 'The only model',
+    },
+    'profile.allowModelSelect': { unset: 'Off', value: false },
+    'profile.maxSteps': { unset: `${DEFAULT_MAX_STEPS} model calls`, value: DEFAULT_MAX_STEPS },
     'models.*.protocol': { required: true },
     'models.*.provider': { required: true },
+    'models.*.options': { unset: "The protocol's defaults" },
+    'models.*.keySlot': { unset: 'Provider primary slot' },
+    'models.*.fallbackKeySlot': { unset: 'Provider fallback slot, when configured' },
+    providerContinuation: { unset: 'The host keeps the history' },
+    'providerContinuation.history': { unset: 'host', value: 'host' },
     'models.*.apiId': { required: true },
-    'models.*.builtInTools': { unset: 'None' },
+    'models.*.builtInTools': { unset: 'None', value: [] },
     'models.*.maxOutputTokens': { unset: 'Provider default' },
     'models.*.temperature': { unset: 'Provider default' },
     'models.*.summaries': { unset: 'Provider default' },
@@ -32,24 +38,18 @@ export const PROFILE_FIELD_PRESENCE = {
         required: 'when more than one effort is declared',
         unset: 'The only effort',
     },
-    'models.*.allowEffortSelect': { unset: 'Off' },
-    'models.*.key': { unset: "The profile's key" },
-    'models.*.fallbackKey': { unset: "The profile's fallback key" },
+    'models.*.allowEffortSelect': { unset: 'Off', value: false },
     'models.*.timeoutMs': { unset: 'No timeout' },
     'models.*.compaction': { unset: 'Off' },
     'models.*.compaction.maxTokens': { required: true },
     'models.*.compaction.compactAt': { required: true },
     'models.*.compaction.previousExchanges': { required: true },
-    'models.*.compaction.profile': { unset: 'The agent itself' },
+    'models.*.compaction.profile': { unset: 'The agent itself, on a text profile' },
+    'models.*.compaction.trigger': { unset: 'compactAt of maxTokens' },
     'models.*.compaction.timing': { required: true },
-    'models.*.compaction.meter': { unset: 'history' },
-    'models.*.cache': { unset: 'Off' },
-    'models.*.cache.mode': { required: true },
-    'models.*.cache.ttl': { unset: 'Provider default' },
-    'models.*.store': { unset: 'Provider default' },
-    'models.*.persistViaInteractionId': { required: 'when the protocol is geminiInteractions' },
-    inputs: { required: true },
-    'inputs.text': { unset: 'Accepted' },
+    'models.*.compaction.meter': { unset: 'history', value: 'history' },
+    inputs: { required: 'on every type that takes it but live', unset: 'No slots or context' },
+    'inputs.text': { unset: 'Accepted', value: true },
     'inputs.attachments.accept': { unset: 'No attachments' },
     'inputs.voice.accept': { unset: 'No voice' },
     'inputs.maxFiles': { required: 'when attachments or voice is set' },
@@ -59,58 +59,57 @@ export const PROFILE_FIELD_PRESENCE = {
     'inputs.maxStateBytes': { unset: 'No cap' },
     'inputs.limitsByMime': { unset: 'maxBytes for every type' },
     'inputs.slots': { unset: 'No slots' },
-    'outputs.structured': { unset: 'Free text' },
-    'outputs.validation.maxRetries': { unset: '0' },
-    'outputs.streaming.mode': { unset: 'sse' },
-    'outputs.streaming.streamThoughts': { unset: 'On' },
-    'turnBehaviour.resumption.allowContinue': { unset: 'All three' },
-    'turnBehaviour.resumption.autoContinue': { unset: 'length and stream_incomplete' },
+    'inputs.context': { unset: 'No context' },
+    'inputs.context.from': { required: true },
+    'inputs.context.maxChars': { required: true },
+    'outputs.structured': { unset: 'Free text', value: null },
+    'outputs.validation.maxRetries': { unset: '0', value: 0 },
+    'outputs.streaming.mode': { unset: 'sse', value: 'sse' },
+    'outputs.streaming.streamThoughts': { unset: 'On', value: true },
+    'turnBehaviour.resumption.allowContinue': {
+        unset: 'All three',
+        value: ['length', 'stream_incomplete', 'provider_error'],
+    },
+    'turnBehaviour.resumption.autoContinue': {
+        unset: 'length and stream_incomplete',
+        value: ['length', 'stream_incomplete'],
+    },
     'turnBehaviour.resumption.maxContinues': { unset: 'No cap' },
-    'turnBehaviour.allowSteering': { unset: 'On' },
+    'turnBehaviour.allowSteering': { unset: 'On', value: true },
+    'turnBehaviour.atStepLimit': { unset: 'stop', value: 'stop' },
     'guardrails.quota': { unset: 'No limit' },
-    'guardrails.canary': { unset: 'On' },
-    'guardrails.sanitizeInput': { unset: 'On' },
-    'guardrails.redactSensitive': { unset: 'On' },
-    'guardrails.egress': { unset: 'No check' },
-    'guardrails.egress.enforce': { required: 'when checks is not set' },
-    'guardrails.egress.checks': { required: 'when enforce is not set' },
-    'guardrails.egress.checks.sensitive': { unset: 'Every group but network' },
-    'guardrails.egress.checks.sensitive.ids': { unset: 'On' },
-    'guardrails.egress.checks.sensitive.financial': { unset: 'On' },
-    'guardrails.egress.checks.sensitive.network': { unset: 'Off' },
-    'guardrails.egress.checks.sensitive.credentials': { unset: 'On' },
-    'guardrails.egress.checks.boundary': { unset: 'On' },
-    'guardrails.egress.checks.injection': { unset: 'On' },
-    'guardrails.egress.checks.images': { unset: 'On' },
-    'guardrails.egress.checks.images.hosts': { unset: 'None' },
-    'guardrails.egress.checks.images.fromTools': { unset: 'On' },
-    'guardrails.egress.checks.links': { unset: 'Off' },
-    'guardrails.egress.checks.links.hosts': { unset: 'The images hosts' },
-    'guardrails.egress.checks.links.fromTools': { unset: 'On' },
-    'guardrails.egress.onBlock': { unset: 'reject_to_agent' },
-    'guardrails.egress.maxRetries': { unset: '0' },
-    'guardrails.egress.holdback': { unset: '256' },
-    'guardrails.network.allowPrivateNetworks': { unset: 'Off' },
-    'guardrails.network.allowedHosts': { unset: 'None' },
+    'guardrails.detect': { unset: 'Redacts what goes to the model' },
+    'guardrails.detect.ungiven_images.allow.fromTools': { unset: 'On', value: true },
+    'guardrails.detect.ungiven_links.allow.fromTools': { unset: 'On', value: true },
+    'guardrails.blockedReply': { unset: 'One rewrite' },
+    'guardrails.blockedReply.onBlock': { unset: 'retry', value: 'retry' },
+    'guardrails.blockedReply.maxRetries': { unset: '1', value: 1 },
+    'guardrails.network.allowPrivateNetworks': { unset: 'Off', value: false },
+    'guardrails.network.allowedHosts': { unset: 'None', value: [] },
     'guardrails.network.allowedSchemes': {
         unset: 'https, plus http when allowPrivateNetworks is on',
     },
-    'guardrails.taint.afterRemoteRead': { unset: 'off' },
+    'guardrails.taint.afterRemoteRead': { unset: 'off', value: 'off' },
+    'guardrails.taint.remoteDestination': { unset: 'off', value: 'off' },
     'guardrails.disclosure': { unset: 'No check' },
-    'observability.writeTo': { unset: 'No traces' },
-    'observability.sampleRate': { unset: '1' },
-    'observability.include.upstreamLog': { unset: 'On' },
-    'observability.include.outboundWire': { unset: 'Off' },
-    'observability.include.evidenceRaw': { unset: 'Off' },
-    'observability.include.usage': { unset: 'On' },
-    'observability.include.guardrailDecisions': { unset: 'On' },
-    'observability.include.guardrailMatchPreview': { unset: 'Off' },
+    'observability.writeTo': { unset: 'No traces, unless runTurn is given a sink' },
+    'observability.sampleRate': { unset: '1', value: 1 },
+    'observability.include.upstreamLog': { unset: 'On', value: true },
+    'observability.include.outboundWire': {
+        unset: 'Off; on when the profile has no observability block',
+    },
+    'observability.include.evidenceRaw': {
+        unset: 'Off; on when the profile has no observability block',
+    },
+    'observability.include.usage': { unset: 'On', value: true },
+    'observability.include.guardrailDecisions': { unset: 'On', value: true },
+    'observability.include.guardrailMatchPreview': { unset: 'Off', value: false },
     'observability.resource': { unset: 'None' },
-    'observability.scrub.sensitive': { unset: 'On' },
-    'observability.scrub.injection': { unset: 'On' },
-    'observability.scrub.canary': { unset: 'On' },
-    'observability.retainForDays': { unset: '14' },
-    'observability.rotateAfterMiB': { unset: '32' },
+    'observability.scrub.sensitive': { unset: 'On', value: true },
+    'observability.scrub.injection': { unset: 'On', value: true },
+    'observability.scrub.canary': { unset: 'On', value: true },
+    'observability.retainForDays': { unset: '14', value: 14 },
+    'observability.rotateAfterMiB': { unset: '32', value: 32 },
     'observability.onWriteError': { unset: 'Errors are dropped' },
     'image.aspectRatio': { unset: 'Provider default' },
     'image.resolution': { unset: 'Provider default' },
@@ -121,23 +120,39 @@ export const PROFILE_FIELD_PRESENCE = {
     'image.seed': { unset: 'Provider default' },
     'image.outputCompression': { unset: 'Provider default' },
     'image.references': { unset: 'None' },
-    'image.includeText': { unset: 'Off' },
-    'speech.voice': { unset: 'Provider default' },
+    'image.includeText': { unset: 'Off', value: false },
+    'speech.voice': { unset: "The turn's speech.voice; Gemini refuses speech without one" },
+    'speech.style': { unset: "The turn's speech.style, else no direction" },
+    'speech.speed': { unset: "The turn's speech.speed, else the voice's own pace" },
     'speech.format': { unset: 'Provider default' },
-    'live.ingress.audio': { unset: 'On' },
-    'live.ingress.video': { unset: 'On' },
-    'live.ingress.text': { unset: 'Off' },
+    'live.ingress.audio': { unset: 'On', value: true },
+    'live.ingress.video': { unset: 'On', value: true },
+    'live.ingress.text': { unset: 'Off', value: false },
     'live.voice': { unset: 'Provider default' },
     'live.vad.activityHandling': { unset: 'Provider default' },
     'live.vad.startSensitivity': { unset: 'Provider default' },
     'live.vad.endSensitivity': { unset: 'Provider default' },
     'live.vad.prefixPaddingMs': { unset: 'Provider default' },
     'live.vad.silenceDurationMs': { unset: 'Provider default' },
-    'live.sessionResumption': { unset: 'Off' },
+    'live.sessionResumption': { unset: 'Off', value: false },
+    'live.greeting': { unset: 'The agent waits for the visitor' },
+    'live.resumed': { unset: 'A resumed call is silent' },
+    'live.resumed.prompt': { required: true },
+    'live.resumed.afterMs': { unset: '3000' },
     'live.contextCompression': { unset: 'Off' },
     'live.contextCompression.triggerTokens': { unset: 'Provider default' },
     'live.contextCompression.slidingWindow': { required: true },
     'live.contextCompression.slidingWindow.targetTokens': { unset: 'Provider default' },
     'live.transcription.input': { unset: 'Off' },
-    'live.transcription.output': { unset: 'Off' },
+    'live.transcription.output': {
+        unset: 'Off; on with a detector at live_reply',
+    },
 };
+/** The value leaving the field at `path` out stands for, or nothing when no one value says it. */
+export function unsetValue(path) {
+    const held = Object.entries(PROFILE_FIELD_PRESENCE).find(([known]) => {
+        const keys = known.replace(/^profile\./, '').split('.');
+        return keys.length === path.length && keys.every((key, at) => key === '*' || key === path[at]);
+    });
+    return held?.[1].value;
+}

package/esm/src/kernel/profile-scope.d.ts

@@ -9,11 +9,15 @@ export interface ProfileFieldScope {
     /** Why other types can't take it — shown in `defineProfile` errors and authoring UIs. */
     reason: string;
     /**
-     * The one value other types may still carry: the field's "off" value (speech stores
-     * `guardrails.canary: false`; `outputs.structured: null` asks for no schema).
+     * The one value other types may still carry: the field's "off" value
+     * (`outputs.structured: null` asks for no schema).
      */
-    offValue?: false | null;
+    offValue?: null;
 }
+/** Whether a top-level profile key is one of the profile's own settings. */
+export declare function isProfileRootField(key: string): boolean;
+/** The keys of the profile object that a catalog path names: `profile.maxSteps` is `maxSteps`. */
+export declare function profileKeysOf(catalogPath: string): string[];
 /** Keyed like `PROFILE_FIELDS`; `models.*` matches every model binding. */
 export declare const PROFILE_FIELD_SCOPE: Readonly<Record<string, ProfileFieldScope>>;
 /**

package/esm/src/kernel/profile-scope.js

@@ -1,5 +1,5 @@
-// Leaf module: `schema.ts` and `profile-graph.ts` read it at load time.
-/** lexicon-exempt-file: authoring field-meta scope reasons — not runtime user or model copy (P2) */
+// invariant: Leaf module: `schema.ts` and `profile-graph.ts` read it at load time.
+/** labels-exempt-file: authoring field-meta scope reasons — not runtime user or model copy (P2) */
 import { HOST_GUARDRAIL_FIELDS } from '../guardrails/types.js';
 /**
  * Mirrors `PROFILE_TYPES` — a value import would cycle through `schema.ts`.
@@ -11,21 +11,49 @@ export const ALL_PROFILE_TYPES = [
     'speech',
     'live',
     'decision',
+    'embedding',
     'host',
 ];
-const MODEL_PROFILE_TYPES = ['text', 'image', 'speech', 'live', 'decision'];
+const MODEL_PROFILE_TYPES = [
+    'text',
+    'image',
+    'speech',
+    'live',
+    'decision',
+    'embedding',
+];
 const TURN_TYPES = ['text', 'image', 'speech', 'live'];
 /** Types whose `inputs` are turn inputs (text, files, slots) rather than decision state. */
 const TURN_INPUT_TYPES = ['text', 'image'];
-const TURN_INPUT_REASON = 'a decision takes JSON state, not turn text, files or slots';
+const TURN_INPUT_REASON = 'a decision takes JSON state, not turn text, files, or slots';
+/** Types that take slots and context: the turn types, and a call. */
+const SLOT_TYPES = ['text', 'image', 'live'];
+const SLOT_REASON = 'a decision takes JSON state, and speech reads its transcript only';
 /** Guardrails a host profile may set keep `host`; the rest guard a model turn. */
 function turnGuardrailTypes(key) {
     return HOST_GUARDRAIL_FIELDS.includes(key)
         ? [...TURN_TYPES, 'host']
         : TURN_TYPES;
 }
+/**
+ * The profile's own settings, which no section holds. The catalog names each `profile.<key>`, as
+ * a section's fields carry their section's name.
+ */
+const PROFILE_ROOT_FIELDS = ['id', 'type', 'defaultModel', 'allowModelSelect', 'maxSteps'];
+/** Whether a top-level profile key is one of the profile's own settings. */
+export function isProfileRootField(key) {
+    return PROFILE_ROOT_FIELDS.includes(key);
+}
+/** The keys of the profile object that a catalog path names: `profile.maxSteps` is `maxSteps`. */
+export function profileKeysOf(catalogPath) {
+    return catalogPath.replace(/^profile\./, '').split('.');
+}
 /** Keyed like `PROFILE_FIELDS`; `models.*` matches every model binding. */
 export const PROFILE_FIELD_SCOPE = {
+    providerContinuation: {
+        profileTypes: TURN_TYPES,
+        reason: 'only model turns and live sessions use provider continuation',
+    },
     ...Object.fromEntries([
         'efforts',
         'defaultEffort',
@@ -34,11 +62,6 @@ export const PROFILE_FIELD_SCOPE = {
         'maxOutputTokens',
         'temperature',
         'builtInTools',
-        'cache',
-        'store',
-        'persistViaInteractionId',
-        'server',
-        'fallbackKey',
     ].map((field) => [
         `models.*.${field}`,
         {
@@ -75,20 +98,15 @@ export const PROFILE_FIELD_SCOPE = {
         profileTypes: ['text', 'image', 'speech'],
         reason: 'live compacts with live.contextCompression',
     },
-    key: { profileTypes: MODEL_PROFILE_TYPES, reason: 'a host profile runs no model' },
-    fallbackKey: {
-        profileTypes: TURN_TYPES,
-        reason: 'a host profile runs no model and a decision makes one call on its key',
-    },
-    defaultModel: {
-        profileTypes: TURN_TYPES,
+    'profile.defaultModel': {
+        profileTypes: [...TURN_TYPES, 'embedding'],
         reason: 'a host profile runs no model and a decision declares exactly one',
     },
-    allowModelSelect: {
-        profileTypes: TURN_TYPES,
+    'profile.allowModelSelect': {
+        profileTypes: [...TURN_TYPES, 'embedding'],
         reason: 'a host profile runs no model and a decision declares exactly one',
     },
-    maxSteps: {
+    'profile.maxSteps': {
         profileTypes: TURN_TYPES,
         reason: 'only model turns take tool-loop steps',
     },
@@ -109,48 +127,52 @@ export const PROFILE_FIELD_SCOPE = {
         reason: 'live function declarations are fixed at session setup, and a host profile can execute every allowed tool',
     },
     inputs: {
-        profileTypes: ['text', 'image', 'decision'],
-        reason: 'speech input is the transcript, live ingress is live.ingress, and a host profile takes no turns',
+        profileTypes: ['text', 'image', 'live', 'decision', 'embedding'],
+        reason: 'speech input is the transcript, and a host profile takes no turns',
     },
     'inputs.voice': {
         profileTypes: ['text'],
         reason: 'no image model reads audio, and a decision takes JSON state',
     },
     'inputs.text': {
-        profileTypes: TURN_INPUT_TYPES,
+        profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
         reason: TURN_INPUT_REASON,
     },
     'inputs.attachments': {
-        profileTypes: TURN_INPUT_TYPES,
+        profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
         reason: TURN_INPUT_REASON,
     },
     'inputs.maxFiles': {
-        profileTypes: TURN_INPUT_TYPES,
+        profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
         reason: TURN_INPUT_REASON,
     },
     'inputs.maxBytes': {
-        profileTypes: TURN_INPUT_TYPES,
+        profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
         reason: TURN_INPUT_REASON,
     },
     'inputs.maxTurnBytes': {
-        profileTypes: TURN_INPUT_TYPES,
+        profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
         reason: TURN_INPUT_REASON,
     },
     'inputs.limitsByMime': {
-        profileTypes: TURN_INPUT_TYPES,
+        profileTypes: [...TURN_INPUT_TYPES, 'embedding'],
         reason: TURN_INPUT_REASON,
     },
     'inputs.slots': {
-        profileTypes: TURN_INPUT_TYPES,
-        reason: TURN_INPUT_REASON,
+        profileTypes: SLOT_TYPES,
+        reason: SLOT_REASON,
+    },
+    'inputs.context': {
+        profileTypes: SLOT_TYPES,
+        reason: SLOT_REASON,
     },
     'inputs.state': {
         profileTypes: ['decision'],
-        reason: 'only a decision reads JSON state; a turn takes text, files and slots',
+        reason: 'only a decision reads JSON state; a turn takes text, files, and slots',
     },
     'inputs.maxStateBytes': {
         profileTypes: ['decision'],
-        reason: 'only a decision reads JSON state; a turn takes text, files and slots',
+        reason: 'only a decision reads JSON state; a turn takes text, files, and slots',
     },
     outputs: {
         profileTypes: ['text', 'image', 'speech'],
@@ -177,39 +199,29 @@ export const PROFILE_FIELD_SCOPE = {
         profileTypes: ['text', 'live'],
         reason: 'image and speech turns take no mid-turn input',
     },
+    'turnBehaviour.atStepLimit': {
+        profileTypes: ['text'],
+        reason: 'only a text turn writes an answer after its tools',
+    },
     'guardrails.quota': {
         profileTypes: turnGuardrailTypes('quota'),
         reason: 'quota counts model turns',
     },
-    'guardrails.canary': {
-        profileTypes: ['text', 'image', 'live'],
-        reason: 'the canary is minted into a system prompt, which speech, decision and host profiles lack',
-        offValue: false,
-    },
-    'guardrails.promptEcho': {
-        profileTypes: ['text', 'image', 'live'],
-        reason: 'the echo is of a system prompt, which speech, decision and host profiles lack',
-        offValue: false,
-    },
-    'guardrails.sanitizeInput': {
-        profileTypes: turnGuardrailTypes('sanitizeInput'),
-        reason: 'the decision path runs none of the turn guardrails',
-    },
-    'guardrails.redactSensitive': {
-        profileTypes: turnGuardrailTypes('redactSensitive'),
+    'guardrails.detect': {
+        profileTypes: turnGuardrailTypes('detect'),
         reason: 'the decision path runs none of the turn guardrails',
     },
-    'guardrails.egress': {
-        profileTypes: turnGuardrailTypes('egress'),
-        reason: 'egress gates user-visible model text in the turn runner',
+    'guardrails.blockedReply': {
+        profileTypes: ['text', 'image', 'live'],
+        reason: 'only a reply can be blocked, and speech, decision, and host profiles write none',
     },
     'guardrails.network': {
-        profileTypes: turnGuardrailTypes('network'),
-        reason: 'the decision path calls no tools',
+        profileTypes: ['text', 'image', 'live', 'host'],
+        reason: 'speech and decision profiles call no tools',
     },
     'guardrails.taint': {
-        profileTypes: turnGuardrailTypes('taint'),
-        reason: 'the decision path calls no tools',
+        profileTypes: ['text', 'image', 'live'],
+        reason: 'speech and decision profiles call no tools, and a host profile runs no turn to taint',
     },
     'guardrails.disclosure': {
         profileTypes: ['decision'],
@@ -252,7 +264,7 @@ export function outOfScopeFields(profile) {
     for (const [path, scope] of Object.entries(PROFILE_FIELD_SCOPE)) {
         if (scope.profileTypes.includes(profile.type))
             continue;
-        for (const [at, value] of valuesAt(profile, path.split('.'))) {
+        for (const [at, value] of valuesAt(profile, profileKeysOf(path))) {
             if (scope.offValue !== undefined && value === scope.offValue)
                 continue;
             out.push({ path: at, scope });

package/esm/src/kernel/protocols/binding.d.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { type JsonObject } from '../json.js';
+import { type KeySlot } from '../schema.js';
+import { type ModelProfileType, type Protocol } from './protocol.js';
+import type { RegisteredProvider } from './provider.js';
+/** A vault slot name. */
+export declare const keySlotSchema: z.ZodString;
+export declare const commonModelSettingsSchema: z.ZodObject<{
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    efforts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        none: 'none';
+        minimal: 'minimal';
+        low: 'low';
+        medium: 'medium';
+        high: 'high';
+        xhigh: 'xhigh';
+        max: 'max';
+    }>>>;
+    defaultEffort: z.ZodOptional<z.ZodString>;
+    allowEffortSelect: z.ZodOptional<z.ZodBoolean>;
+    summaries: z.ZodOptional<z.ZodBoolean>;
+    builtInTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    compaction: z.ZodOptional<z.ZodCustom<import('../types.js').CompactionSpec>>;
+}>;
+/** One entry under a profile's `models`: which protocol, which provider, which model, and its settings. */
+export interface ModelBinding extends z.infer<typeof commonModelSettingsSchema> {
+    protocol: string;
+    provider: string;
+    apiId: string;
+    keySlot?: string;
+    fallbackKeySlot?: string;
+    options?: JsonObject;
+}
+/** A decision profile's model: no generation settings, and a time limit. */
+export interface DecisionModelBinding extends Pick<ModelBinding, 'protocol' | 'provider' | 'apiId' | 'keySlot' | 'fallbackKeySlot' | 'options'> {
+    timeoutMs?: number;
+}
+export declare const modelBindingSchema: z.ZodType<ModelBinding>;
+export declare const decisionModelBindingSchema: z.ZodType<DecisionModelBinding>;
+/** What a runtime can do that a sign-in may need. */
+export interface RuntimeAbilities {
+    /** Whether a WebSocket can be opened with headers (not in a browser). */
+    webSocketHeaders: boolean;
+}
+/** The slots a model reads its key from: the ones it names, else its provider's. */
+export declare function keySlotsOf(provider: {
+    keySlot?: KeySlot;
+    fallbackKeySlot?: KeySlot;
+}, binding: {
+    keySlot?: KeySlot;
+    fallbackKeySlot?: KeySlot;
+}): {
+    keySlot?: KeySlot;
+    fallbackKeySlot?: KeySlot;
+};
+/** The provider's serve of the protocol a binding speaks. */
+export declare function bindingServe(provider: RegisteredProvider, binding: ModelBinding | DecisionModelBinding): RegisteredProvider['serves'][number];
+/** The protocol a binding speaks on its provider. */
+export declare function protocolOf(provider: RegisteredProvider, binding: ModelBinding | DecisionModelBinding): Protocol;
+/**
+ * The one place a binding meets its provider, once, at registration, for fit only. Returns the
+ * binding with its options parsed; changes nothing in place.
+ */
+export declare function checkBinding<B extends ModelBinding | DecisionModelBinding>(provider: RegisteredProvider, binding: B, profileType: ModelProfileType, runtime?: RuntimeAbilities): B;