@theoremjs/agents 0.3.0 → 0.3.1

package/esm/src/kernel/engine/live-inbound.js

@@ -1,19 +1,44 @@
-import { wrapUserData } from '../../guardrails/canary.js';
-import { guardrailFromHits, projectGuardrailTurnEvent } from '../../guardrails/events.js';
-import { detectionForTrust, resolveGuardrailPolicy } from '../../guardrails/policy.js';
-import { detectText } from '../../guardrails/sanitize.js';
+import { wrapContext, wrapUserData } from '../../guardrails/canary.js';
+import { boundaryReader, detectAt, detectEvent } from '../../guardrails/detect-at.js';
+import { guardrailTurnEvent, projectGuardrailTurnEvent } from '../../guardrails/events.js';
+import { resolveGuardrailPolicy } from '../../guardrails/policy.js';
+import { sanitizeContext } from '../../guardrails/sanitize.js';
 import { resolveObservabilityPolicy } from '../../observability/resolve-policy.js';
-// Resolves through the shared policy so Live ingress and the turn engine cannot drift on what an unset switch means.
+import { CONTEXT_SENDERS } from '../schema.js';
+// why: Resolves through the shared policy so Live ingress and the turn engine cannot drift on what an unset switch means.
+/** Reads text a live session receives from the user at the `live_user` boundary, wraps what crosses as user data, and returns the guardrail event when something matched. */
 function prepareLiveInboundText(profile, text) {
-    const policy = resolveGuardrailPolicy(profile.guardrails);
-    const detected = detectText(text, detectionForTrust(policy, 'untrusted'));
-    const raw = guardrailFromHits('live_inbound', 'untrusted', detected.hits, 'redact');
+    const { detect } = resolveGuardrailPolicy(profile.guardrails);
+    const detected = detectAt(text, 'live_user', detect);
+    const event = detectEvent('live_user', detected);
     const includeMatch = resolveObservabilityPolicy(profile.observability).include
         .guardrailMatchPreview;
-    const guardrail = raw ? projectGuardrailTurnEvent(raw, includeMatch) : undefined;
+    const guardrail = event
+        ? projectGuardrailTurnEvent(guardrailTurnEvent(event), includeMatch)
+        : undefined;
     return {
-        text: wrapUserData(detected.text),
+        ...(detected.text === undefined ? {} : { text: wrapUserData(detected.text) }),
         ...(guardrail ? { guardrail } : {}),
     };
 }
-export { prepareLiveInboundText };
+/** Reads each sender's context at the `context` boundary, as a turn does. A package a match blocks does not reach the model. */
+function prepareLiveContext(profile, context) {
+    const { detect } = resolveGuardrailPolicy(profile.guardrails);
+    const includeMatch = resolveObservabilityPolicy(profile.observability).include
+        .guardrailMatchPreview;
+    const texts = [];
+    const guardrails = [];
+    for (const sender of [...CONTEXT_SENDERS].reverse()) {
+        if (context[sender] === undefined)
+            continue;
+        const read = sanitizeContext({ [sender]: context[sender] }, () => boundaryReader('context', detect));
+        for (const event of read.events) {
+            guardrails.push(projectGuardrailTurnEvent(guardrailTurnEvent(event), includeMatch));
+        }
+        const text = read.context?.[sender];
+        if (!read.blocked && typeof text === 'string')
+            texts.push(wrapContext(sender, text));
+    }
+    return { texts, guardrails };
+}
+export { prepareLiveContext, prepareLiveInboundText };

package/esm/src/kernel/engine/live-ingress.d.ts

@@ -1,9 +1,15 @@
 import type { LiveIngressSpec, Profile } from '../types.js';
+/** A channel a live session can take input on: audio, video, or text. */
 export type LiveIngressChannel = keyof LiveIngressSpec;
 /** Default when `live.ingress.<channel>` is omitted — mic and camera on, typed text off. */
 export declare function liveIngressChannelDefault(channel: LiveIngressChannel): boolean;
+/** True when the ingress spec enables the channel. */
 export declare function liveIngressEnabledFromSpec(ingress: LiveIngressSpec | undefined, channel: LiveIngressChannel): boolean;
+/** True when the live profile enables the channel. */
 export declare function liveIngressEnabled(profile: Profile, channel: LiveIngressChannel): boolean;
+/** True when the live profile enables at least one channel. */
 export declare function hasAnyLiveIngress(profile: Profile): boolean;
+/** Throws when the live profile enables no input channel. */
 export declare function assertLiveIngressConfigured(profile: Profile): void;
+/** Throws when the live profile does not enable the channel. */
 export declare function assertLiveIngress(profile: Profile, channel: LiveIngressChannel): void;

package/esm/src/kernel/engine/live-ingress.js

@@ -2,7 +2,7 @@ import { TheoremError } from '../../guardrails/error.js';
 const LIVE_INGRESS_CHANNELS = ['audio', 'video', 'text'];
 function assertLiveProfile(profile) {
     if (profile.type !== 'live') {
-        throw new TheoremError('request', `Profile '${profile.id}' is not type 'live'`); // lexicon-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
+        throw new TheoremError('request', `Profile '${profile.id}' is not type 'live'`); // labels-exempt: developer contract / internal diagnostic — not end-user or model copy (P2)
     }
     return profile;
 }
@@ -10,26 +10,31 @@ function assertLiveProfile(profile) {
 export function liveIngressChannelDefault(channel) {
     return channel !== 'text';
 }
+/** True when the ingress spec enables the channel. */
 export function liveIngressEnabledFromSpec(ingress, channel) {
     const value = ingress?.[channel];
     if (value === undefined)
         return liveIngressChannelDefault(channel);
     return value;
 }
+/** True when the live profile enables the channel. */
 export function liveIngressEnabled(profile, channel) {
     const live = assertLiveProfile(profile);
     return liveIngressEnabledFromSpec(live.live.ingress, channel);
 }
+/** True when the live profile enables at least one channel. */
 export function hasAnyLiveIngress(profile) {
     const live = assertLiveProfile(profile);
     return LIVE_INGRESS_CHANNELS.some((channel) => liveIngressEnabledFromSpec(live.live.ingress, channel));
 }
+/** Throws when the live profile enables no input channel. */
 export function assertLiveIngressConfigured(profile) {
     const live = assertLiveProfile(profile);
     if (hasAnyLiveIngress(live))
         return;
     throw new TheoremError('config', `Profile '${live.id}': at least one live.ingress channel (audio, video, text) must be enabled`);
 }
+/** Throws when the live profile does not enable the channel. */
 export function assertLiveIngress(profile, channel) {
     if (liveIngressEnabled(profile, channel))
         return;

package/esm/src/kernel/engine/repair.js

@@ -1,4 +1,4 @@
-import { lexiconText } from '../../guardrails/lexicon.js';
+import { labelText } from '../../guardrails/labels.js';
 const MAX_REPAIR_HISTORY_EXCHANGES = 2;
 const MAX_REPAIR_HISTORY_MESSAGES = MAX_REPAIR_HISTORY_EXCHANGES * 2;
 function scopeHistory(history) {
@@ -7,30 +7,30 @@ function scopeHistory(history) {
     }
     return history.slice(-MAX_REPAIR_HISTORY_MESSAGES);
 }
-function formatHistoryBlock(messages, lexicon) {
+function formatHistoryBlock(messages, labels) {
     if (messages.length === 0) {
         return '';
     }
     const lines = messages.map((m) => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`);
-    const heading = lexiconText('repair.history_heading', { count: messages.length }, lexicon);
+    const heading = labelText('repair.history_heading', { count: messages.length }, labels);
     return `${heading}\n${lines.join('\n')}\n\n`;
 }
 function synthesizeRepairPrompt(args) {
     const { profile, repair, history } = args;
-    const guidance = repair.guidance || lexiconText('repair.default_guidance', {}, profile.lexicon);
-    const historyBlock = formatHistoryBlock(scopeHistory(history), profile.lexicon);
-    let prompt = `${lexiconText('repair.prompt_header', {}, profile.lexicon)}\n\n`;
-    prompt += `${lexiconText('repair.prompt_intro', {}, profile.lexicon)}\n\n`;
-    prompt += `${lexiconText('repair.section_previous_output', {}, profile.lexicon)}\n\`\`\`\n${repair.previousOutput.trim()}\n\`\`\`\n\n`;
-    prompt += `${lexiconText('repair.section_validator_rejection', {}, profile.lexicon)}\n${repair.rejection.trim()}\n\n`;
+    const guidance = repair.guidance || labelText('repair.default_guidance', {}, profile.labels);
+    const historyBlock = formatHistoryBlock(scopeHistory(history), profile.labels);
+    let prompt = `${labelText('repair.prompt_header', {}, profile.labels)}\n\n`;
+    prompt += `${labelText('repair.prompt_intro', {}, profile.labels)}\n\n`;
+    prompt += `${labelText('repair.section_previous_output', {}, profile.labels)}\n\`\`\`\n${repair.previousOutput.trim()}\n\`\`\`\n\n`;
+    prompt += `${labelText('repair.section_validator_rejection', {}, profile.labels)}\n${repair.rejection.trim()}\n\n`;
     if (guidance.trim()) {
-        prompt += `${lexiconText('repair.section_repair_guidance', {}, profile.lexicon)}\n${guidance.trim()}\n\n`;
+        prompt += `${labelText('repair.section_repair_guidance', {}, profile.labels)}\n${guidance.trim()}\n\n`;
     }
     if (historyBlock) {
         prompt += historyBlock;
     }
-    prompt += `${lexiconText('repair.section_instructions', {}, profile.lexicon)}\n`;
-    prompt += lexiconText('repair.prompt_instructions', {}, profile.lexicon);
+    prompt += `${labelText('repair.section_instructions', {}, profile.labels)}\n`;
+    prompt += labelText('repair.prompt_instructions', {}, profile.labels);
     return prompt;
 }
 export { synthesizeRepairPrompt };

package/esm/src/kernel/engine/runner/gates.d.ts

@@ -1,5 +1,5 @@
 import type { BoundSystem } from '../../system-parts.js';
-import type { ModelProvider, Profile, ResolvedGeneration, TurnEvent, TurnRequest } from '../../types.js';
+import type { Profile, ResolvedGeneration, TurnEvent, TurnModel, TurnRequest } from '../../types.js';
 import { type StepExecutionState } from './state.js';
-declare function runAttemptsWithValidation(safe: TurnRequest, profile: Profile, generation: ResolvedGeneration, system: BoundSystem, provider: ModelProvider, state: StepExecutionState): AsyncGenerator<TurnEvent>;
+declare function runAttemptsWithValidation(safe: TurnRequest, profile: Profile, generation: ResolvedGeneration, system: BoundSystem, provider: TurnModel, state: StepExecutionState): AsyncGenerator<TurnEvent>;
 export { runAttemptsWithValidation };