@theoremjs/agents 0.3.0 → 0.3.1

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

@@ -1,38 +1,55 @@
-import { egressChecksProblem } from '../../guardrails/egress.js';
-import { streamPlanOf } from '../../guardrails/egress-stream.js';
+import { TOOL_BOUNDARIES } from '../../guardrails/boundaries.js';
+import { detectProblem } from '../../guardrails/detectors.js';
 import { TheoremError } from '../../guardrails/error.js';
-import { validateLexiconOverrides } from '../../guardrails/lexicon.js';
-import { SENSITIVE_GROUPS } from '../../guardrails/sensitive.js';
+import { labelText, validateLabelOverrides } from '../../guardrails/labels.js';
+import { BLOCKED_REPLY_ON_BLOCK, } from '../../guardrails/types.js';
 import { resolveObservabilityPolicy } from '../../observability/resolve-policy.js';
+import { providerContinuationSchema } from '../checkpoint.js';
 import { assertLiveIngressConfigured } from '../engine/live-ingress.js';
-import { outOfScopeFields } from '../profile-scope.js';
-import { CACHE_MODES, CACHE_TTLS, IMAGE_ATTACHMENT_ACCEPT_MIMES, isKeySlotName, isValidPair, isValidProfileProtocol, PROFILE_FIELDS, PROFILE_TYPES, protocolsForProfileType, THINKING_LEVELS, } from '../schema.js';
+import { itemSchemaAt, schemaReaches } from '../engine/runner/schema-validation.js';
+import { outOfScopeFields, profileKeysOf, profileTypesForField } from '../profile-scope.js';
+import { checkBinding, decisionModelBindingSchema, modelBindingSchema, } from '../protocols/binding.js';
+import { CONTEXT_SENDERS, IMAGE_ATTACHMENT_ACCEPT_MIMES, PROFILE_FIELDS, PROFILE_HANDLE_MAX_CHARS, PROFILE_ID_MAX_CHARS, PROFILE_TYPES, THINKING_LEVELS, } from '../schema.js';
 import { isContinueStopKind } from '../stop.js';
 import { assertSystemPrompt } from '../system-parts.js';
 import { profileToolAllow, profileToolsSpec } from '../tools/resolve.js';
 import { isTurnMediaRef } from './attachments.js';
 import { mediaKindForMime, mimeAllowed, profileInputs } from './catalog.js';
 import { soleModelId } from './sole-model.js';
-function assertModelRoute(profileId, modelId, binding, type) {
-    if (type === 'decision' && !binding.apiId.trim()) {
-        throw new TheoremError('config', `Profile ${profileId} model '${modelId}' must set apiId`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
-    if (type === 'decision' && !isValidProfileProtocol(type, binding.protocol)) {
-        throw new TheoremError('config', 
-        // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-        `Profile ${profileId} model '${modelId}': type 'decision' cannot use protocol '${binding.protocol}'. Supported: decision`);
-    }
-    if (!isValidPair(binding.protocol, binding.provider)) {
-        throw new TheoremError('config', 
-        // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-        `Profile ${profileId} model '${modelId}': protocol '${binding.protocol}' is not valid for provider '${binding.provider}'`);
-    }
+function assertModelRoute(_profileId, _modelId, binding, _type) {
+    if (!binding.provider?.trim() || !binding.apiId?.trim())
+        throw new TheoremError('config', labelText('provider.binding_identity'));
+}
+function defineEmbeddingProfile(input) {
+    assertModelsNonEmpty(input.id, input.models);
+    assertObservability(input.id, input.observability);
+    assertMediaLimits(input.id, input.inputs);
+    for (const [modelId, binding] of Object.entries(input.models))
+        assertModelBinding(input.id, modelId, binding);
+    return {
+        type: 'embedding',
+        id: input.id,
+        identity: { handle: input.identity.handle },
+        models: input.models,
+        defaultModel: resolveDefaultModel(input.id, input),
+        allowModelSelect: input.allowModelSelect,
+        inputs: input.inputs,
+        guardrails: input.guardrails,
+        observability: input.observability,
+        labels: input.labels,
+    };
+}
+function assertBindingData(profileId, modelId, binding, schema) {
+    const parsed = schema.safeParse(binding);
+    if (!parsed.success)
+        throw new TheoremError('config', `Profile ${profileId} model '${modelId}': ${parsed.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; ')}`);
 }
 function validateDecisionBinding(profileId, modelId, binding) {
+    assertBindingData(profileId, modelId, binding, decisionModelBindingSchema);
     assertModelRoute(profileId, modelId, binding, 'decision');
     if ('retry' in binding) {
         throw new TheoremError('config', 
-        // lexicon-exempt: developer contract / internal diagnostic
+        // labels-exempt: developer contract / internal diagnostic
         `Profile ${profileId} model '${modelId}': decision retry configuration is unsupported; POSTs are never retried`);
     }
     if (binding.timeoutMs !== undefined &&
@@ -49,53 +66,49 @@ function validateDecisionModel(input) {
 }
 function validateDecisionConfig(input) {
     if (input.inputs.state !== 'json') {
-        throw new TheoremError('config', `Profile ${input.id}: decision inputs.state must be 'json'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `Profile ${input.id}: decision inputs.state must be 'json'`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     const cap = input.inputs.maxStateBytes;
     if (cap !== undefined && !(Number.isInteger(cap) && cap > 0)) {
         throw new TheoremError('config', `Profile ${input.id}: decision inputs.maxStateBytes must be a positive integer`);
     }
     if (!input.decision.contract.trim()) {
-        throw new TheoremError('config', `Profile ${input.id}: decision.contract must be non-empty`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `Profile ${input.id}: decision.contract must be non-empty`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
 function defineDecisionProfile(input) {
     validateDecisionModel(input);
     validateDecisionConfig(input);
-    assertSlotName(input.id, 'key', input.key);
-    for (const [modelId, binding] of Object.entries(input.models)) {
-        assertSlotName(input.id, `models.${modelId}.key`, binding.key);
-        if (!binding.key && !input.key) {
-            throw new TheoremError('config', `Profile ${input.id} model '${modelId}': a decision model needs models.*.key or the profile key`);
-        }
-    }
     assertObservability(input.id, input.observability);
     return { ...input, identity: { handle: input.identity.handle } };
 }
+/** `tools.parallel` carried over only when the definition sets it. */
+function optionalParallel(parallel) {
+    return parallel === undefined ? {} : { parallel };
+}
 function defineHostProfile(input) {
     assertHostTools(input.id, input.tools);
     assertObservability(input.id, input.observability);
     return {
         type: 'host',
         id: input.id,
-        tools: { allow: input.tools.allow },
+        tools: { allow: input.tools.allow, ...optionalParallel(input.tools.parallel) },
         guardrails: input.guardrails,
         observability: input.observability,
-        lexicon: input.lexicon,
+        labels: input.labels,
     };
 }
 function assertHostTools(profileId, tools) {
     if (!Array.isArray(tools.allow)) {
-        throw new TheoremError('config', `Profile ${profileId}: type 'host' must set tools.allow`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `Profile ${profileId}: type 'host' must set tools.allow`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
 function assertModelsNonEmpty(profileId, models) {
     if (Object.keys(models).length === 0) {
-        throw new TheoremError('config', `Profile ${profileId} must declare at least one model`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `Profile ${profileId} must declare at least one model`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
 function resolveDefaultModel(profileId, input) {
-    const ids = Object.keys(input.models);
     const inferred = input.defaultModel ?? soleModelId(input.models);
     if (!inferred) {
         throw new TheoremError('config', `Profile ${profileId} must set defaultModel when more than one model is declared`);
@@ -103,51 +116,12 @@ function resolveDefaultModel(profileId, input) {
     if (!input.models[inferred]) {
         throw new TheoremError('config', `Profile ${profileId} defaultModel '${inferred}' is not declared`);
     }
-    if (input.allowModelSelect && ids.length < 2) {
-        throw new TheoremError('config', `Profile ${profileId} allowModelSelect requires at least two models`);
-    }
     return inferred;
 }
 function assertModelBinding(profileId, modelId, binding) {
-    assertModelRoute(profileId, modelId, binding);
     assertModelEfforts(profileId, modelId, binding);
-    if (binding.cache) {
-        assertCacheSpec(profileId, modelId, binding, binding.cache);
-    }
-    assertInteractionsPersistence(profileId, modelId, binding);
-    assertLocalServer(profileId, modelId, binding);
-}
-function assertSlotName(profileId, path, slot) {
-    if (slot !== undefined && !isKeySlotName(slot)) {
-        throw new TheoremError('config', `Profile ${profileId}: ${path} '${slot}' is not a key slot name; use letters, digits, '-' and '_', up to 32 characters`);
-    }
-}
-/** A model's key and fallback, each its own or the profile's. A fallback is never implied. */
-function assertKeySlot(profileId, modelId, binding, profile) {
-    assertSlotName(profileId, `models.${modelId}.key`, binding.key);
-    assertSlotName(profileId, `models.${modelId}.fallbackKey`, binding.fallbackKey);
-    const key = binding.key ?? profile.key;
-    const fallback = binding.fallbackKey ?? profile.fallbackKey;
-    if (binding.provider !== 'local' && !key) {
-        throw new TheoremError('config', `Profile ${profileId} model '${modelId}': a ${binding.provider} model needs models.*.key or the profile key`);
-    }
-    if (fallback === undefined)
-        return;
-    if (fallback === key) {
-        throw new TheoremError('config', `Profile ${profileId} model '${modelId}': fallbackKey '${fallback}' is the same slot as its key`);
-    }
-}
-function assertLocalServer(profileId, modelId, binding) {
-    if (binding.server === undefined) {
-        return;
-    }
-    const tag = `Profile ${profileId} model '${modelId}'`;
-    if (binding.provider !== 'local') {
-        throw new TheoremError('config', `${tag}: server is only valid when provider is 'local'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
-    if (typeof binding.server !== 'string' || binding.server.trim() === '') {
-        throw new TheoremError('config', `${tag}: server must be a non-empty string`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
+    assertBindingData(profileId, modelId, binding, modelBindingSchema);
+    assertModelEfforts(profileId, modelId, binding);
 }
 function assertModelEfforts(profileId, modelId, binding) {
     const efforts = binding.efforts;
@@ -174,22 +148,15 @@ function assertModelEfforts(profileId, modelId, binding) {
         throw new TheoremError('config', `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 TheoremError('config', `Profile ${profile.id} model '${modelId}': type '${profile.type}' cannot use protocol '${binding.protocol}'. Supported: ${valid}`);
-        }
-    }
-}
 function profileModelFields(input) {
     return {
+        providerContinuation: input.providerContinuation
+            ? providerContinuationSchema.parse(input.providerContinuation)
+            : {},
         models: input.models,
         defaultModel: resolveDefaultModel(input.id, input),
         allowModelSelect: input.allowModelSelect,
         maxSteps: input.maxSteps,
-        key: input.key,
-        fallbackKey: input.fallbackKey,
     };
 }
 function assertContinueKindList(profileId, path, kinds) {
@@ -197,7 +164,7 @@ function assertContinueKindList(profileId, path, kinds) {
         return;
     for (const kind of kinds) {
         if (!isContinueStopKind(kind)) {
-            throw new TheoremError('config', `Profile ${profileId}: turnBehaviour.resumption.${path} may only include ContinueStopKind ` + // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            throw new TheoremError('config', `Profile ${profileId}: turnBehaviour.resumption.${path} may only include ContinueStopKind ` + // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
                 `(length | stream_incomplete | provider_error); got '${kind}'`);
         }
     }
@@ -227,20 +194,33 @@ const REQUIRED_PATHS = Object.entries(PROFILE_FIELDS)
     .filter(([, meta]) => meta.required === true)
     .map(([path, meta]) => [path, meta.profileTypes])
     .sort(([a], [b]) => a.split('.').length - b.split('.').length);
-/** A definition may come over the network (a playground draft), so its shape is checked before anything reads it. */
+/** A definition may come over the network (a studio draft), so its shape is checked before anything reads it. */
 function assertProfileShape(input) {
     if (!isRecord(input)) {
-        throw new TheoremError('config', 'Profile definition must be an object'); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', 'Profile definition must be an object'); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     const id = typeof input.id === 'string' && input.id.trim() ? input.id : undefined;
     if (!id) {
-        throw new TheoremError('config', 'Profile definition must set id'); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', 'Profile definition must set id'); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     const type = PROFILE_TYPES.find((known) => known === input.type);
     if (!type) {
         throw new TheoremError('config', `Profile ${id}: type must be one of ${PROFILE_TYPES.join(', ')}`);
     }
 }
+/** A profile's id and its handle each fit their limit. */
+function assertNameLengths(input) {
+    const handle = input.identity?.handle;
+    const names = [
+        ['id', input.id, PROFILE_ID_MAX_CHARS],
+        ['identity.handle', typeof handle === 'string' ? handle : '', PROFILE_HANDLE_MAX_CHARS],
+    ];
+    for (const [path, name, max] of names) {
+        if (Array.from(name).length <= max)
+            continue;
+        throw new TheoremError('config', `Profile ${input.id.slice(0, PROFILE_ID_MAX_CHARS)}: ${path} must be at most ${max} characters`);
+    }
+}
 /** A field under an optional parent the definition leaves out is not required. */
 function assertRequiredFields(input) {
     const { id, type } = input;
@@ -248,7 +228,7 @@ function assertRequiredFields(input) {
     for (const [path, profileTypes] of REQUIRED_PATHS) {
         if (profileTypes && !profileTypes.includes(type))
             continue;
-        const keys = path.split('.');
+        const keys = profileKeysOf(path);
         const parents = valuesAt(root, keys.slice(0, -1));
         const last = keys[keys.length - 1];
         const missing = parents.some((parent) => {
@@ -258,10 +238,20 @@ function assertRequiredFields(input) {
             return value === undefined || value === null || value === '';
         });
         if (missing) {
-            throw new TheoremError('config', `Profile ${id}: type '${type}' must set ${path}`);
+            throw new TheoremError('config', `Profile ${id}: type '${type}' must set ${keys.join('.')}`);
         }
     }
 }
+/** `inputs` is optional on a live profile only, where it holds slots and context and nothing else. */
+function assertInputsSet(input) {
+    const { id, type } = input;
+    if (type === 'live' || !profileTypesForField('inputs').includes(type))
+        return;
+    const inputs = input.inputs;
+    if (inputs === undefined || inputs === null) {
+        throw new TheoremError('config', `Profile ${id}: type '${type}' must set inputs`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+}
 /** Covers untyped hosts that the definition types can't stop. */
 function assertFieldScope(input) {
     const [field] = outOfScopeFields(input);
@@ -275,50 +265,57 @@ function assertTurnBehaviour(profileId, input) {
     const tb = input.turnBehaviour;
     assertResumption(profileId, tb?.resumption);
 }
-/**
- * The canary lives in the system prompt, and speech has none: Gemini TTS rejects developer
- * instructions and OpenAI-compatible `/audio/speech` has no field for one.
- */
-function speechGuardrails(input) {
-    return { ...input.guardrails, canary: false };
+function assertValidation(profileId, validation) {
+    const fail = (message) => new TheoremError('config', `Profile ${profileId}: ${message}`);
+    const retries = validation?.maxRetries;
+    if (retries !== undefined && (!Number.isInteger(retries) || retries < 0)) {
+        throw fail('outputs.validation.maxRetries must be a non-negative integer'); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
 }
-function assertEgress(profileId, guardrails) {
-    const egress = guardrails?.egress;
+function assertGuardrails(profileId, guardrails) {
     const fail = (message) => new TheoremError('config', `Profile ${profileId}: ${message}`);
-    if (egress && (egress.enforce === undefined) === (egress.checks === undefined)) {
+    // why: A key this does not read would be a check the builder believes is on.
+    const unknown = Object.keys(guardrails ?? {}).find((key) => !GUARDRAIL_KEYS.includes(key));
+    if (unknown !== undefined) {
+        throw fail(`guardrails.${unknown} is not a setting; it takes ${GUARDRAIL_KEYS.join(', ')}`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    assertBlockedReply(guardrails?.blockedReply, fail);
+}
+const GUARDRAIL_KEYS = [
+    'quota',
+    'detect',
+    'blockedReply',
+    'network',
+    'taint',
+];
+const BLOCKED_REPLY_KEYS = ['onBlock', 'maxRetries'];
+function assertBlockedReply(blockedReply, fail) {
+    if (blockedReply === undefined)
+        return;
+    const unknown = Object.keys(blockedReply).find((key) => !BLOCKED_REPLY_KEYS.includes(key));
+    if (unknown !== undefined) {
         throw fail(
-        // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-        'guardrails.egress takes enforce (your own check) or checks (the bundled ones), one of the two');
+        // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        `guardrails.blockedReply.${unknown} is not a setting; it takes onBlock and maxRetries`);
     }
-    if (egress?.enforce !== undefined && typeof egress.enforce !== 'function') {
-        throw fail('guardrails.egress.enforce must be a function'); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    }
-    const problem = egress?.checks === undefined
-        ? undefined
-        : egressChecksProblem('guardrails.egress.checks', egress.checks);
-    if (problem !== undefined)
-        throw fail(problem);
-    for (const key of ['maxRetries', 'holdback']) {
-        const value = egress?.[key];
-        if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
-            throw new TheoremError('config', `Profile ${profileId}: guardrails.egress.${key} must be a non-negative integer`);
-        }
+    const { onBlock, maxRetries } = blockedReply;
+    if (onBlock !== undefined && !BLOCKED_REPLY_ON_BLOCK.includes(onBlock)) {
+        throw fail(
+        // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        `guardrails.blockedReply.onBlock must be one of ${BLOCKED_REPLY_ON_BLOCK.join(', ')}`);
     }
-    if (egress?.holdback !== undefined &&
-        (egress.enforce === undefined || streamPlanOf(egress.enforce))) {
-        throw new TheoremError('config', `Profile ${profileId}: guardrails.egress.holdback applies only to a host egress.enforce; the bundled policy holds exactly what could still become a match`);
+    if (maxRetries !== undefined && (!Number.isInteger(maxRetries) || maxRetries < 0)) {
+        throw fail('guardrails.blockedReply.maxRetries must be a non-negative integer'); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
-/** A misspelt group would leave the group it meant on, silently. */
-function assertRedactSensitive(profileId, guardrails) {
-    const selection = guardrails?.redactSensitive;
-    if (selection === undefined || typeof selection === 'boolean')
-        return;
-    const groups = new Set(SENSITIVE_GROUPS);
-    const bad = Object.entries(selection).find(([group, on]) => !groups.has(group) || typeof on !== 'boolean');
-    if (bad !== undefined) {
-        throw new TheoremError('config', `Profile ${profileId}: guardrails.redactSensitive.${bad[0]} is not a group (${SENSITIVE_GROUPS.join(', ')}) set to a boolean`);
-    }
+/** A host profile runs no model turn, so the tool boundaries are the only ones it has. */
+function assertDetect(input) {
+    const spec = input.guardrails?.detect;
+    const problem = input.type === 'host'
+        ? detectProblem('guardrails.detect', spec, TOOL_BOUNDARIES)
+        : detectProblem('guardrails.detect', spec);
+    if (problem !== undefined)
+        throw new TheoremError('config', `Profile ${input.id}: ${problem}`);
 }
 function assertObservability(profileId, spec) {
     try {
@@ -339,7 +336,10 @@ function assertObservability(profileId, spec) {
     }
 }
 function assertIdentitySystem(input) {
-    if (input.type === 'host' || input.type === 'decision' || input.type === 'speech')
+    if (input.type === 'host' ||
+        input.type === 'decision' ||
+        input.type === 'speech' ||
+        input.type === 'embedding')
         return;
     const { system, systemByRole } = input.identity;
     if (system !== undefined)
@@ -348,29 +348,37 @@ function assertIdentitySystem(input) {
         assertSystemPrompt(prompt, `Profile ${input.id} identity.systemByRole.${role}`);
     }
 }
+/** Validate any definition and return the profile. */
 function defineProfile(input) {
     assertProfileShape(input);
+    for (const field of ['key', 'fallbackKey', 'protocol', 'provider'])
+        if (field in input)
+            throw new TheoremError('config', labelText('provider.profile_configuration', { profile: input.id, field }));
     assertFieldScope(input);
+    assertInputsSet(input);
     assertRequiredFields(input);
-    if (input.lexicon)
-        validateLexiconOverrides(input.lexicon, `Profile ${input.id}`);
+    assertNameLengths(input);
+    if (input.labels)
+        validateLabelOverrides(input.labels, `Profile ${input.id}`);
     assertIdentitySystem(input);
-    assertRedactSensitive(input.id, input.guardrails);
+    assertDetect(input);
     if (input.type === 'host') {
         return defineHostProfile(input);
     }
     if (input.type === 'decision') {
         return defineDecisionProfile(input);
     }
+    if (input.type === 'embedding') {
+        return defineEmbeddingProfile(input);
+    }
     assertModelsNonEmpty(input.id, input.models);
     assertTurnBehaviour(input.id, input);
-    assertEgress(input.id, input.guardrails);
+    assertGuardrails(input.id, input.guardrails);
+    if (input.type === 'text')
+        assertValidation(input.id, input.outputs?.validation);
     assertObservability(input.id, input.observability);
-    assertSlotName(input.id, 'key', input.key);
-    assertSlotName(input.id, 'fallbackKey', input.fallbackKey);
     for (const [modelId, binding] of Object.entries(input.models)) {
         assertModelBinding(input.id, modelId, binding);
-        assertKeySlot(input.id, modelId, binding, input);
     }
     const identity = input.type === 'speech'
         ? { handle: input.identity.handle }
@@ -381,7 +389,7 @@ function defineProfile(input) {
         };
     const guardrails = input.guardrails;
     const observability = input.observability;
-    const lexicon = input.lexicon;
+    const labels = input.labels;
     const modelFields = profileModelFields(input);
     let profile;
     switch (input.type) {
@@ -397,7 +405,7 @@ function defineProfile(input) {
                 turnBehaviour: input.turnBehaviour,
                 guardrails,
                 observability,
-                lexicon,
+                labels,
             };
             break;
         case 'image':
@@ -413,7 +421,7 @@ function defineProfile(input) {
                 turnBehaviour: input.turnBehaviour,
                 guardrails,
                 observability,
-                lexicon,
+                labels,
             };
             assertImageAccept(profile.id, profile.inputs.attachments?.accept);
             assertImagePinValues(profile.id, profile.image);
@@ -427,9 +435,9 @@ function defineProfile(input) {
                 speech: input.speech,
                 outputs: input.outputs,
                 turnBehaviour: input.turnBehaviour,
-                guardrails: speechGuardrails(input),
+                guardrails,
                 observability,
-                lexicon,
+                labels,
             };
             break;
         case 'live': {
@@ -439,25 +447,43 @@ function defineProfile(input) {
                 identity,
                 ...modelFields,
                 live: input.live,
-                tools: { allow: input.tools.allow },
+                inputs: input.inputs,
+                tools: { allow: input.tools.allow, ...optionalParallel(input.tools.parallel) },
                 turnBehaviour: input.turnBehaviour,
                 guardrails,
                 observability,
-                lexicon,
+                labels,
             };
             assertLiveIngressConfigured(profile);
             assertLiveCompression(profile.id, profile.live.contextCompression);
+            assertLiveOpening(profile);
             break;
         }
         default: {
             const _exhaustive = input;
-            throw new TheoremError('config', `Unknown profile type '${String(_exhaustive)}'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            throw new TheoremError('config', `Unknown profile type '${String(_exhaustive)}'`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
     }
     assertStructuredSlot(profile);
-    assertTypeProtocols(profile);
+    assertMaxSteps(profile);
+    assertAnswerStep(profile);
     return profile;
 }
+/** Only a positive whole number is a cap; left out, the turn gets `DEFAULT_MAX_STEPS`. */
+function assertMaxSteps(profile) {
+    const { maxSteps } = profile;
+    if (maxSteps === undefined || (Number.isInteger(maxSteps) && maxSteps > 0))
+        return;
+    throw new TheoremError('config', `Profile ${profile.id}: maxSteps must be a whole number of 1 or more; leave it out for the default of 20`);
+}
+/** The answering step takes no tools, so with one step the profile's tools could never run. */
+function assertAnswerStep(profile) {
+    if (profile.type !== 'text' || profile.turnBehaviour?.atStepLimit !== 'answer')
+        return;
+    if (profile.maxSteps !== 1)
+        return;
+    throw new TheoremError('config', `Profile ${profile.id}: turnBehaviour.atStepLimit 'answer' with maxSteps 1 leaves no step that can call a tool`);
+}
 /** A turn can pass no value outside the slot's choices, so any other mapped key is dead. */
 function assertStructuredSlot(profile) {
     if (profile.type === 'live')
@@ -475,28 +501,28 @@ function assertStructuredSlot(profile) {
     }
 }
 const IMAGE_PIN_RULES = {
-    n: { ok: (v) => Number.isInteger(v) && v >= 1, rule: 'a whole number of 1 or more' }, // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    seed: { ok: Number.isInteger, rule: 'a whole number' }, // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    n: { ok: (v) => Number.isInteger(v) && v >= 1, rule: 'a whole number of 1 or more' }, // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    seed: { ok: Number.isInteger, rule: 'a whole number' }, // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     outputCompression: {
         ok: (v) => Number.isInteger(v) && v >= 0 && v <= 100,
-        rule: 'a whole number from 0 to 100', // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        rule: 'a whole number from 0 to 100', // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     },
 };
 function assertImagePinValues(profileId, image) {
     for (const [name, { ok, rule }] of Object.entries(IMAGE_PIN_RULES)) {
         const value = image[name];
         if (value !== undefined && !ok(value)) {
-            throw new TheoremError('config', `Profile ${profileId}: image.${name} must be ${rule}`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            throw new TheoremError('config', `Profile ${profileId}: image.${name} must be ${rule}`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
     }
     image.references?.forEach((reference, index) => {
         const where = `Profile ${profileId}: image.references[${index}]`;
         if (mediaKindForMime(reference.mimeType) !== 'image') {
-            throw new TheoremError('config', `${where} must be an image, not '${reference.mimeType}'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            throw new TheoremError('config', `${where} must be an image, not '${reference.mimeType}'`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
         const source = isTurnMediaRef(reference) ? reference.uri : reference.data;
         if (!source) {
-            throw new TheoremError('config', `${where} needs its bytes or its uri`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+            throw new TheoremError('config', `${where} needs its bytes or its uri`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         }
     });
 }
@@ -505,35 +531,55 @@ function assertImageAccept(profileId, accept) {
     if (!outside?.length)
         return;
     throw new TheoremError('config', 
-    // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
-    `Profile ${profileId}: an image profile's attachments take images, video and PDF only, ` +
+    // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    `Profile ${profileId}: an image profile's attachments take images, video, and PDF only, ` +
         `not ${outside.join(', ')}`);
 }
+/** A greeting is a prompt, and a resume prompt needs the handles that make a resume. */
+function assertLiveOpening(profile) {
+    const { greeting, resumed, sessionResumption } = profile.live;
+    const tag = `Profile ${profile.id} live`; // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    if (greeting !== undefined && (typeof greeting !== 'string' || !greeting.trim())) {
+        throw new TheoremError('config', `${tag}.greeting must be a prompt; leave it out to wait`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (!resumed)
+        return;
+    if (typeof resumed.prompt !== 'string' || !resumed.prompt.trim()) {
+        throw new TheoremError('config', `${tag}.resumed.prompt must be a prompt`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    const { afterMs } = resumed;
+    if (afterMs !== undefined && !(Number.isFinite(afterMs) && afterMs >= 0)) {
+        throw new TheoremError('config', `${tag}.resumed.afterMs must be 0 or more milliseconds`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    }
+    if (!sessionResumption) {
+        throw new TheoremError('config', `${tag}.resumed needs live.sessionResumption: without it no call resumes`);
+    }
+}
 function assertLiveCompression(profileId, spec) {
     if (!spec)
         return;
-    const tag = `Profile ${profileId} live.contextCompression`; // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    const tag = `Profile ${profileId} live.contextCompression`; // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     const trigger = spec.triggerTokens;
     const target = spec.slidingWindow.targetTokens;
     assertWholeTokens(`${tag}.triggerTokens`, trigger);
     assertWholeTokens(`${tag}.slidingWindow.targetTokens`, target);
     if (trigger !== undefined && target !== undefined && target >= trigger) {
         throw new TheoremError('config', 
-        // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
         `${tag}: slidingWindow.targetTokens must be below triggerTokens`);
     }
 }
 function assertWholeTokens(tag, value) {
     if (value === undefined || (Number.isInteger(value) && value > 0))
         return;
-    throw new TheoremError('config', `${tag} must be a whole number above 0`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    throw new TheoremError('config', `${tag} must be a whole number above 0`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
 }
 function assertCompactionSpec(registered, owner, modelId, spec) {
-    const tag = `Profile ${owner.id} model ${modelId} compaction`; // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+    const tag = `Profile ${owner.id} model ${modelId} compaction`; // labels-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 TheoremError('config', `${tag}: meter must be 'history' or 'input'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `${tag}: meter must be 'history' or 'input'`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (spec.profile === undefined) {
         if (owner.type !== 'text' || owner.inputs.text === false) {
@@ -549,55 +595,23 @@ function assertCompactionSpec(registered, owner, modelId, spec) {
         throw new TheoremError('config', `${tag}: compaction profile '${spec.profile}' must be a text profile that takes text`);
     }
 }
-function assertCacheSpec(profileId, modelId, binding, spec) {
-    const tag = `Profile ${profileId} model '${modelId}'`;
-    if (binding.provider !== 'openrouter') {
-        throw new TheoremError('config', `${tag}: cache is only valid when protocol is 'openAi' and provider is 'openrouter'`);
-    }
-    if (!CACHE_MODES.includes(spec.mode)) {
-        throw new TheoremError('config', `${tag}: cache.mode must be one of ${CACHE_MODES.join(' | ')}`);
-    }
-    if (spec.ttl != null && !CACHE_TTLS.includes(spec.ttl)) {
-        throw new TheoremError('config', `${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.protocol === 'geminiInteractions') {
-        if (binding.persistViaInteractionId === undefined) {
-            throw new TheoremError('config', `Profile ${profileId} model '${modelId}': persistViaInteractionId is required on a 'geminiInteractions' binding — true chains on Google's stored interaction, false sends the host's history plus this turn's steps every call`);
-        }
-        if (binding.persistViaInteractionId && binding.store === false) {
-            throw new TheoremError('config', `Profile ${profileId} model '${modelId}': persistViaInteractionId: true needs store left on — Google chains only from a stored interaction`);
-        }
-        return;
-    }
-    if (binding.store === undefined && binding.persistViaInteractionId === undefined) {
-        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 TheoremError('config', `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 TheoremError('config', `${tag}: maxTokens must be > 0`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `${tag}: maxTokens must be > 0`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (spec.compactAt <= 0 || spec.compactAt >= 1) {
-        throw new TheoremError('config', `${tag}: compactAt must be in (0, 1)`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `${tag}: compactAt must be in (0, 1)`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
 function assertCompactionRetain(tag, spec) {
     if (spec.previousExchanges < 0) {
-        throw new TheoremError('config', `${tag}: previousExchanges must be >= 0`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `${tag}: previousExchanges must be >= 0`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     if (spec.previousExchanges < 1 && spec.previousExchanges >= spec.compactAt) {
         throw new TheoremError('config', `${tag}: previousExchanges as fraction (${spec.previousExchanges}) must be < compactAt (${spec.compactAt})`);
     }
     if (spec.previousExchanges > 1 && !Number.isInteger(spec.previousExchanges)) {
-        throw new TheoremError('config', `${tag}: previousExchanges >= 1 must be an integer`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('config', `${tag}: previousExchanges >= 1 must be an integer`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
 }
 function assertCustomToolsOnly(tools, profile) {
@@ -605,7 +619,7 @@ function assertCustomToolsOnly(tools, profile) {
         const tool = tools.get(id);
         if (tool?.type === 'builtin') {
             throw new TheoremError('config', 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 — type 'host' never runs a model` // labels-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`);
         }
     }
@@ -638,35 +652,96 @@ function assertModelBuiltInTools(tools, profile) {
         }
     }
 }
-function assertMediaLimits(profile) {
-    const inputs = profileInputs(profile);
+/** The schema ids `outputs.structured` can pick, by slot and fallback. */
+function structuredIds(profile) {
+    const structured = profile.type === 'text' ? profile.outputs?.structured : undefined;
+    if (!structured)
+        return [];
+    if (typeof structured === 'string')
+        return [structured];
+    return [...new Set([...Object.values(structured.map), structured.fallback])];
+}
+/**
+ * Every schema `outputs.structured` names is registered, and every
+ * `outputs.validation.fields` path reaches a property of one of them.
+ */
+function assertStructuredSchemas(schemas, profile) {
+    const specs = structuredIds(profile).map((id) => {
+        const spec = schemas.find(id);
+        if (!spec) {
+            throw new TheoremError('config', `Profile ${profile.id}: outputs.structured names '${id}', which is not a registered schema; register it before the profile`);
+        }
+        return spec;
+    });
+    const validation = profile.type === 'text' ? profile.outputs?.validation : undefined;
+    const fields = Object.keys(validation?.fields ?? {});
+    const lists = Object.keys(validation?.items ?? {});
+    if (!fields.length && !lists.length)
+        return;
+    if (!specs.length) {
+        throw new TheoremError('config', `Profile ${profile.id}: outputs.validation checks a structured reply, so it needs outputs.structured`);
+    }
+    const notLists = lists.filter((path) => !specs.some((spec) => itemSchemaAt(spec.jsonSchema, path)));
+    if (notLists.length) {
+        throw new TheoremError('config', `Profile ${profile.id}: outputs.validation.items has ${notLists.join(', ')}, which no structured schema reaches as a list with an items schema`);
+    }
+    const unreached = fields.filter((path) => !specs.some((spec) => schemaReaches(spec.jsonSchema, path)));
+    if (unreached.length) {
+        throw new TheoremError('config', `Profile ${profile.id}: outputs.validation.fields has ${unreached.join(', ')}, which no structured schema reaches through object properties`);
+    }
+}
+function assertContextSpec(profile) {
+    const context = profileInputs(profile)?.context;
+    if (!context) {
+        return;
+    }
+    const senders = CONTEXT_SENDERS;
+    if (context.from.length === 0 || context.from.some((sender) => !senders.includes(sender))) {
+        throw new TheoremError('config', `Profile ${profile.id}: inputs.context.from must list ${CONTEXT_SENDERS.join(' or ')}`);
+    }
+    if (!(Number.isInteger(context.maxChars) && context.maxChars > 0)) {
+        throw new TheoremError('config', `Profile ${profile.id}: inputs.context.maxChars must be a positive integer`);
+    }
+}
+function assertMediaLimits(profileId, inputs) {
     if (!inputs) {
         return;
     }
     const { attachments, voice, maxFiles, maxBytes, maxTurnBytes, limitsByMime } = inputs;
     const limits = { maxFiles, maxBytes, maxTurnBytes };
     if ((attachments || voice) && Object.values(limits).some((value) => value === undefined)) {
-        throw new TheoremError('config', `Profile ${profile.id} must set maxFiles, maxBytes, and maxTurnBytes`);
+        throw new TheoremError('config', `Profile ${profileId} must set maxFiles, maxBytes, and maxTurnBytes`);
     }
     for (const [mime, value] of Object.entries(limitsByMime ?? {})) {
         limits[`limitsByMime['${mime}']`] = value;
     }
     for (const [name, value] of Object.entries(limits)) {
         if (value !== undefined && !(Number.isInteger(value) && value > 0)) {
-            throw new TheoremError('config', `Profile ${profile.id}: inputs.${name} must be a positive integer`);
+            throw new TheoremError('config', `Profile ${profileId}: inputs.${name} must be a positive integer`);
         }
     }
 }
-/** Profiles are checked against `tools`, so register a scope's tools before its profiles. */
-function createProfileRegistry(tools) {
+/** Profiles are checked against `tools` and `schemas`, so register a scope's tools and schemas before its profiles. */
+function createProfileRegistry(tools, schemas, providers) {
     const profiles = new Map();
     const register = (profileInput) => {
-        const profile = defineProfile(profileInput);
+        const defined = defineProfile(profileInput);
+        const profile = providers && defined.type !== 'host'
+            ? {
+                ...defined,
+                models: Object.fromEntries(Object.entries(defined.models).map(([modelId, binding]) => [
+                    modelId,
+                    checkBinding(providers.require(binding.provider, binding.apiId), binding, defined.type),
+                ])),
+            }
+            : defined;
         assertCustomToolsOnly(tools, profile);
         assertProfileToolLoader(tools, profile);
-        if (profile.type !== 'host' && profile.type !== 'decision') {
+        if (profile.type !== 'host' && profile.type !== 'decision' && profile.type !== 'embedding') {
             assertModelBuiltInTools(tools, profile);
-            assertMediaLimits(profile);
+            assertMediaLimits(profile.id, profileInputs(profile));
+            assertContextSpec(profile);
+            assertStructuredSchemas(schemas, profile);
             for (const [modelId, binding] of Object.entries(profile.models)) {
                 if (binding.compaction) {
                     assertCompactionSpec(profiles, profile, modelId, binding.compaction);