@theoremjs/agents 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,698 @@
+import { egressChecksProblem } from '../../guardrails/egress.js';
+import { streamPlanOf } from '../../guardrails/egress-stream.js';
+import { TheoremError } from '../../guardrails/error.js';
+import { validateLexiconOverrides } from '../../guardrails/lexicon.js';
+import { SENSITIVE_GROUPS } from '../../guardrails/sensitive.js';
+import { resolveObservabilityPolicy } from '../../observability/resolve-policy.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 { 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 validateDecisionBinding(profileId, modelId, binding) {
+    assertModelRoute(profileId, modelId, binding, 'decision');
+    if ('retry' in binding) {
+        throw new TheoremError('config', 
+        // lexicon-exempt: developer contract / internal diagnostic
+        `Profile ${profileId} model '${modelId}': decision retry configuration is unsupported; POSTs are never retried`);
+    }
+    if (binding.timeoutMs !== undefined &&
+        (!Number.isFinite(binding.timeoutMs) || binding.timeoutMs <= 0)) {
+        throw new TheoremError('config', `Profile ${profileId} model '${modelId}' timeoutMs must be > 0`);
+    }
+}
+function validateDecisionModel(input) {
+    const modelId = input.models ? soleModelId(input.models) : undefined;
+    if (!modelId) {
+        throw new TheoremError('config', `Profile ${input.id}: type 'decision' must declare exactly one model`);
+    }
+    validateDecisionBinding(input.id, modelId, input.models[modelId]);
+}
+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)
+    }
+    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)
+    }
+}
+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 } };
+}
+function defineHostProfile(input) {
+    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,
+        lexicon: input.lexicon,
+    };
+}
+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)
+    }
+}
+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)
+    }
+}
+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`);
+    }
+    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)
+    }
+}
+function assertModelEfforts(profileId, modelId, binding) {
+    const efforts = binding.efforts;
+    if (!efforts || Object.keys(efforts).length === 0) {
+        if (binding.defaultEffort || binding.allowEffortSelect) {
+            throw new TheoremError('config', `Profile ${profileId} model '${modelId}': defaultEffort and allowEffortSelect require efforts`);
+        }
+        return;
+    }
+    for (const [alias, level] of Object.entries(efforts)) {
+        if (!THINKING_LEVELS.includes(level)) {
+            throw new TheoremError('config', `Profile ${profileId} model '${modelId}' effort '${alias}': '${level}' is not a thinking level (${THINKING_LEVELS.join(', ')})`);
+        }
+    }
+    const keys = Object.keys(efforts);
+    const defaultAlias = binding.defaultEffort ?? (keys.length === 1 ? keys[0] : undefined);
+    if (!defaultAlias) {
+        throw new TheoremError('config', `Profile ${profileId} model '${modelId}' must set defaultEffort when more than one effort is declared`);
+    }
+    if (!efforts[defaultAlias]) {
+        throw new TheoremError('config', `Profile ${profileId} model '${modelId}' defaultEffort '${defaultAlias}' is not declared`);
+    }
+    if (binding.allowEffortSelect && keys.length < 2) {
+        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 {
+        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) {
+    if (!kinds?.length)
+        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)
+                `(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 isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** `*` spans a map's entries; a path through an absent parent yields nothing. */
+function valuesAt(root, path) {
+    let level = [root];
+    for (const key of path) {
+        level = level.flatMap((value) => {
+            if (!isRecord(value))
+                return [];
+            return key === '*' ? Object.values(value) : [value[key]];
+        });
+    }
+    return level;
+}
+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. */
+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)
+    }
+    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)
+    }
+    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 field under an optional parent the definition leaves out is not required. */
+function assertRequiredFields(input) {
+    const { id, type } = input;
+    const root = input;
+    for (const [path, profileTypes] of REQUIRED_PATHS) {
+        if (profileTypes && !profileTypes.includes(type))
+            continue;
+        const keys = path.split('.');
+        const parents = valuesAt(root, keys.slice(0, -1));
+        const last = keys[keys.length - 1];
+        const missing = parents.some((parent) => {
+            if (!isRecord(parent))
+                return false;
+            const value = parent[last];
+            return value === undefined || value === null || value === '';
+        });
+        if (missing) {
+            throw new TheoremError('config', `Profile ${id}: type '${type}' must set ${path}`);
+        }
+    }
+}
+/** Covers untyped hosts that the definition types can't stop. */
+function assertFieldScope(input) {
+    const [field] = outOfScopeFields(input);
+    if (!field)
+        return;
+    const { offValue, reason } = field.scope;
+    const allowed = offValue === undefined ? '' : ` (other than ${offValue})`;
+    throw new TheoremError('config', `Profile ${input.id}: type '${input.type}' must not set ${field.path}${allowed} — ${reason}`);
+}
+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 assertEgress(profileId, guardrails) {
+    const egress = guardrails?.egress;
+    const fail = (message) => new TheoremError('config', `Profile ${profileId}: ${message}`);
+    if (egress && (egress.enforce === undefined) === (egress.checks === 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');
+    }
+    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`);
+        }
+    }
+    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`);
+    }
+}
+/** 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`);
+    }
+}
+function assertObservability(profileId, spec) {
+    try {
+        const policy = resolveObservabilityPolicy(spec);
+        if (!Number.isFinite(policy.retainForDays)) {
+            throw new TheoremError('config', `Profile ${profileId}: observability.retainForDays must be a finite number`);
+        }
+        if (policy.rotateAfterMiB <= 0 || !Number.isFinite(policy.rotateAfterMiB)) {
+            throw new TheoremError('config', `Profile ${profileId}: observability.rotateAfterMiB must be a positive number`);
+        }
+    }
+    catch (err) {
+        if (err instanceof TheoremError && err.message.startsWith('Profile ')) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new TheoremError('config', `Profile ${profileId}: ${message}`);
+    }
+}
+function assertIdentitySystem(input) {
+    if (input.type === 'host' || input.type === 'decision' || input.type === 'speech')
+        return;
+    const { system, systemByRole } = input.identity;
+    if (system !== undefined)
+        assertSystemPrompt(system, `Profile ${input.id} identity.system`);
+    for (const [role, prompt] of Object.entries(systemByRole ?? {})) {
+        assertSystemPrompt(prompt, `Profile ${input.id} identity.systemByRole.${role}`);
+    }
+}
+function defineProfile(input) {
+    assertProfileShape(input);
+    assertFieldScope(input);
+    assertRequiredFields(input);
+    if (input.lexicon)
+        validateLexiconOverrides(input.lexicon, `Profile ${input.id}`);
+    assertIdentitySystem(input);
+    assertRedactSensitive(input.id, input.guardrails);
+    if (input.type === 'host') {
+        return defineHostProfile(input);
+    }
+    if (input.type === 'decision') {
+        return defineDecisionProfile(input);
+    }
+    assertModelsNonEmpty(input.id, input.models);
+    assertTurnBehaviour(input.id, input);
+    assertEgress(input.id, input.guardrails);
+    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 }
+        : {
+            handle: input.identity.handle,
+            system: input.identity.system,
+            systemByRole: input.identity.systemByRole,
+        };
+    const guardrails = input.guardrails;
+    const observability = input.observability;
+    const lexicon = input.lexicon;
+    const modelFields = profileModelFields(input);
+    let profile;
+    switch (input.type) {
+        case 'text':
+            profile = {
+                type: 'text',
+                id: input.id,
+                identity,
+                ...modelFields,
+                tools: input.tools,
+                inputs: input.inputs,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
+                guardrails,
+                observability,
+                lexicon,
+            };
+            break;
+        case 'image':
+            profile = {
+                type: 'image',
+                id: input.id,
+                identity,
+                ...modelFields,
+                image: input.image,
+                tools: input.tools,
+                inputs: input.inputs,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
+                guardrails,
+                observability,
+                lexicon,
+            };
+            assertImageAccept(profile.id, profile.inputs.attachments?.accept);
+            assertImagePinValues(profile.id, profile.image);
+            break;
+        case 'speech':
+            profile = {
+                type: 'speech',
+                id: input.id,
+                identity,
+                ...modelFields,
+                speech: input.speech,
+                outputs: input.outputs,
+                turnBehaviour: input.turnBehaviour,
+                guardrails: speechGuardrails(input),
+                observability,
+                lexicon,
+            };
+            break;
+        case 'live': {
+            profile = {
+                type: 'live',
+                id: input.id,
+                identity,
+                ...modelFields,
+                live: input.live,
+                tools: { allow: input.tools.allow },
+                turnBehaviour: input.turnBehaviour,
+                guardrails,
+                observability,
+                lexicon,
+            };
+            assertLiveIngressConfigured(profile);
+            assertLiveCompression(profile.id, profile.live.contextCompression);
+            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)
+        }
+    }
+    assertStructuredSlot(profile);
+    assertTypeProtocols(profile);
+    return profile;
+}
+/** 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')
+        return;
+    const structured = profile.outputs?.structured;
+    if (!structured || typeof structured === 'string')
+        return;
+    const choices = profileInputs(profile)?.slots?.[structured.by];
+    if (!choices) {
+        throw new TheoremError('config', `Profile ${profile.id}: outputs.structured.by '${structured.by}' is not a slot in inputs.slots`);
+    }
+    const unknown = Object.keys(structured.map).filter((value) => !choices.includes(value));
+    if (unknown.length) {
+        throw new TheoremError('config', `Profile ${profile.id}: outputs.structured.map maps ${unknown.join(', ')}, not a choice of slot '${structured.by}'`);
+    }
+}
+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)
+    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)
+    },
+};
+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)
+        }
+    }
+    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)
+        }
+        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)
+        }
+    });
+}
+function assertImageAccept(profileId, accept) {
+    const outside = accept?.filter((rule) => !mimeAllowed(IMAGE_ATTACHMENT_ACCEPT_MIMES, rule));
+    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, ` +
+        `not ${outside.join(', ')}`);
+}
+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 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)
+        `${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)
+}
+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)
+    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)
+    }
+    if (spec.profile === undefined) {
+        if (owner.type !== 'text' || owner.inputs.text === false) {
+            throw new TheoremError('config', `${tag}: a profile that compacts itself must be a text profile that takes text`);
+        }
+        return;
+    }
+    const compactor = registered.get(spec.profile);
+    if (!compactor) {
+        throw new TheoremError('config', `${tag}: compaction profile '${spec.profile}' must be registered before '${owner.id}'`);
+    }
+    if (compactor.type !== 'text' || compactor.inputs.text === false) {
+        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)
+    }
+    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)
+    }
+}
+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)
+    }
+    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)
+    }
+}
+function assertCustomToolsOnly(tools, profile) {
+    for (const id of profileToolAllow(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 — declare it on models.*.builtInTools instead`);
+        }
+    }
+}
+function assertProfileToolLoader(tools, profile) {
+    const loaderId = profileToolsSpec(profile)?.t2Loader;
+    if (!loaderId) {
+        return;
+    }
+    if (!profileToolAllow(profile).includes(loaderId)) {
+        throw new TheoremError('config', `Profile ${profile.id} tools.t2Loader '${loaderId}' must also be listed in tools.allow`);
+    }
+    const tool = tools.get(loaderId);
+    if (tool?.type !== 'function') {
+        throw new TheoremError('config', `Profile ${profile.id} tools.t2Loader '${loaderId}' must be a registered type: 'function' tool`);
+    }
+}
+function* modelBuiltinIds(profile) {
+    for (const [modelId, binding] of Object.entries(profile.models)) {
+        for (const id of binding.builtInTools ?? []) {
+            yield { modelId, id };
+        }
+    }
+}
+function assertModelBuiltInTools(tools, profile) {
+    for (const { modelId, id } of modelBuiltinIds(profile)) {
+        const tool = tools.get(id);
+        if (tool?.type !== 'builtin') {
+            throw new TheoremError('config', `Profile ${profile.id} model '${modelId}' lists '${id}' in builtInTools — not a registered builtin`);
+        }
+    }
+}
+function assertMediaLimits(profile) {
+    const inputs = profileInputs(profile);
+    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`);
+    }
+    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`);
+        }
+    }
+}
+/** Profiles are checked against `tools`, so register a scope's tools before its profiles. */
+function createProfileRegistry(tools) {
+    const profiles = new Map();
+    const register = (profileInput) => {
+        const profile = defineProfile(profileInput);
+        assertCustomToolsOnly(tools, profile);
+        assertProfileToolLoader(tools, profile);
+        if (profile.type !== 'host' && profile.type !== 'decision') {
+            assertModelBuiltInTools(tools, profile);
+            assertMediaLimits(profile);
+            for (const [modelId, binding] of Object.entries(profile.models)) {
+                if (binding.compaction) {
+                    assertCompactionSpec(profiles, profile, modelId, binding.compaction);
+                }
+            }
+        }
+        profiles.set(profile.id, profile);
+    };
+    return {
+        register,
+        registerMany(profilesList) {
+            for (const p of profilesList) {
+                register(p);
+            }
+        },
+        get(id) {
+            const profile = profiles.get(id);
+            if (!profile) {
+                throw new TheoremError('config', `Unknown profile '${id}'`);
+            }
+            return profile;
+        },
+        find: (id) => profiles.get(id),
+        has: (id) => profiles.has(id),
+        list: () => [...profiles.values()],
+        clear: () => profiles.clear(),
+    };
+}
+export { createProfileRegistry, defineProfile };