@kuralle-agents/core 0.8.0 → 0.8.5

package/README.md

@@ -21,6 +21,12 @@ One tagless primitive — `defineAgent` — derives behavior from the fields you
 - **`defineTool` + `buildToolSet`** — typed effect tools wired to both the model and the executor.
 - **`createRuntime` / `Runtime`** — orchestrator: sessions, handoffs, streaming, flow state.
 - **`MemoryStore`** — in-process `SessionStore`; swap for Redis or Postgres in production.
+- **`HarnessConfig.escalation` + `resumeFromEscalation`** — the human-handoff loop: handoff brief, handler, ownership claim (via engagement), resume-with-resolution.
+- **`RunOptions.wake` + `Scheduler`** — agent-initiated turns (follow-ups, cart abandonment) on in-process timers or Cloudflare DO alarms (`@kuralle-agents/cf-agent`).
+- **`HarnessConfig.compaction`** — automatic history summarization + context-overflow recovery for long-running threads.
+- **`createFactMemoryService`** — cross-session fact memory (LLM merge-on-ingest) keyed by `userId` on any persistent block store.
+- **Built-in guardrails** — `createPromptInjectionGuard`, `createPiiInputGuard`/`OutputGuard`, `createModerationGuard`, `createGroundingValidator` (see `guides/GUARDRAILS.md`).
+- **Simulation eval** — `simulateConversation` + `createJudge` + `runSimulationSuite`: persona-driven simulated users scored by an LLM judge.
 
 ## Usage
 

package/dist/capabilities/validators/groundingValidator.d.ts

@@ -0,0 +1,21 @@
+import type { LanguageModel } from 'ai';
+import type { ValidationCapability } from '../ValidationCapability.js';
+export interface GroundingValidatorOptions {
+    /** Judge model, run at temperature 0. Use the agent's controlModel-class model. */
+    model: LanguageModel;
+    /** Extra domain rules appended to the judge prompt (e.g. "never promise refunds"). */
+    instructions?: string;
+    name?: string;
+}
+/**
+ * State-grounded output validator: checks the assistant reply for action/fact
+ * claims unsupported by this turn's tool calls, flow state, or citations —
+ * the "order placed" with no create-order call class of hallucination.
+ *
+ * Repair policy is rewrite-not-block: an ungrounded claim is rewritten out of
+ * the reply rather than replacing the whole turn with an apology, so the
+ * conversation keeps moving. If the judge flags ungrounded but cannot produce
+ * a rewrite, the turn is blocked (fail safe). Judge errors fail open with low
+ * confidence — the validator is a gate, not a single point of failure.
+ */
+export declare function createGroundingValidator(options: GroundingValidatorOptions): ValidationCapability;

package/dist/capabilities/validators/groundingValidator.js

@@ -0,0 +1,109 @@
+import { generateObject } from 'ai';
+import { z } from 'zod';
+const verdictSchema = z.object({
+    verdict: z.enum(['grounded', 'ungrounded']),
+    /** Required when ungrounded: the same reply with unsupported claims removed/softened. */
+    rewrittenOutput: z.union([z.string(), z.null()]),
+    rationale: z.union([z.string(), z.null()]),
+    confidence: z.number(),
+});
+function summarizeEvidence(input) {
+    const lines = [];
+    if (input.toolCallsMade.length === 0) {
+        lines.push('Tool calls this turn: NONE — no external action was performed.');
+    }
+    else {
+        lines.push('Tool calls this turn:');
+        for (const call of input.toolCallsMade) {
+            const result = truncateJson(call.result, 400);
+            lines.push(`- ${call.toolName}(${truncateJson(call.args, 200)}) → ${call.success ? result : `FAILED: ${result}`}`);
+        }
+    }
+    const stateKeys = Object.entries(input.state);
+    if (stateKeys.length > 0) {
+        lines.push('Flow state (evidence written by earlier steps):');
+        for (const [key, value] of stateKeys) {
+            if (key.startsWith('__'))
+                continue;
+            lines.push(`- ${key}: ${truncateJson(value, 200)}`);
+        }
+    }
+    if (input.knowledgeCitations.length > 0) {
+        lines.push(`Knowledge citations: ${input.knowledgeCitations.map((c) => c.title ?? c.id).join('; ')}`);
+    }
+    return lines.join('\n');
+}
+function truncateJson(value, max) {
+    let text;
+    try {
+        text = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    catch {
+        text = String(value);
+    }
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+/**
+ * State-grounded output validator: checks the assistant reply for action/fact
+ * claims unsupported by this turn's tool calls, flow state, or citations —
+ * the "order placed" with no create-order call class of hallucination.
+ *
+ * Repair policy is rewrite-not-block: an ungrounded claim is rewritten out of
+ * the reply rather than replacing the whole turn with an apology, so the
+ * conversation keeps moving. If the judge flags ungrounded but cannot produce
+ * a rewrite, the turn is blocked (fail safe). Judge errors fail open with low
+ * confidence — the validator is a gate, not a single point of failure.
+ */
+export function createGroundingValidator(options) {
+    return {
+        name: options.name ?? 'grounding-validator',
+        async validate(input) {
+            let verdict;
+            try {
+                const { object } = await generateObject({
+                    model: options.model,
+                    schema: verdictSchema,
+                    temperature: 0,
+                    abortSignal: input.abortSignal,
+                    system: [
+                        'You are a grounding judge for a customer-facing agent. Decide whether the assistant reply',
+                        'claims any COMPLETED action or specific fact that the evidence below does not support.',
+                        'Examples of ungrounded claims: "your order has been placed" with no order-creation evidence;',
+                        'inventing prices, dates, or policies not present in tool results, state, or citations.',
+                        'Asking questions, describing next steps, or hedged language is grounded.',
+                        'If ungrounded, produce rewrittenOutput: the SAME reply with unsupported claims removed or',
+                        'softened into honest next steps. Preserve tone and any grounded content.',
+                        options.instructions ? `Additional rules:\n${options.instructions}` : '',
+                    ]
+                        .filter(Boolean)
+                        .join('\n'),
+                    prompt: [
+                        `User message:\n${input.userMessage}`,
+                        `Assistant reply:\n${input.assistantOutput}`,
+                        `Evidence:\n${summarizeEvidence(input)}`,
+                    ].join('\n\n'),
+                });
+                verdict = object;
+            }
+            catch {
+                return { decision: 'continue', confidence: 0.5, rationale: 'grounding judge unavailable' };
+            }
+            if (verdict.verdict === 'grounded') {
+                return { decision: 'continue', confidence: verdict.confidence };
+            }
+            if (verdict.rewrittenOutput && verdict.rewrittenOutput.trim()) {
+                return {
+                    decision: 'rewrite',
+                    confidence: verdict.confidence,
+                    rewrittenOutput: verdict.rewrittenOutput,
+                    rationale: verdict.rationale ?? 'ungrounded claim removed',
+                };
+            }
+            return {
+                decision: 'block',
+                confidence: verdict.confidence,
+                rationale: verdict.rationale ?? 'ungrounded claim with no safe rewrite',
+            };
+        },
+    };
+}

package/dist/escalation/escalation.d.ts

@@ -0,0 +1,20 @@
+import { type LanguageModel } from 'ai';
+import type { Session, SessionMetadata } from '../types/session.js';
+import type { RunState } from '../runtime/durable/types.js';
+import type { EscalationConfig, EscalationOutcome, EscalationReason, EscalationRequest } from './types.js';
+/** One-shot latch: set when the handler fired at flow-escalate pause time, so
+ *  the post-resume terminal handoff does not notify a second time. */
+export declare const ESCALATION_NOTIFIED_KEY = "__escalationNotified";
+export declare function ensureSessionMetadata(session: Session): SessionMetadata;
+export interface BuildEscalationRequestOptions {
+    session: Session;
+    runState: RunState;
+    reason: string;
+    category?: EscalationReason;
+    config: EscalationConfig;
+    /** Resolved summary model (config.model → controlModel → model → defaultModel). */
+    model?: LanguageModel;
+    abortSignal?: AbortSignal;
+}
+export declare function buildEscalationRequest(options: BuildEscalationRequestOptions): Promise<EscalationRequest>;
+export declare function recordEscalationOutcome(session: Session, category: EscalationReason, outcome: EscalationOutcome): void;

package/dist/escalation/escalation.js

@@ -0,0 +1,85 @@
+import { generateText } from 'ai';
+/** One-shot latch: set when the handler fired at flow-escalate pause time, so
+ *  the post-resume terminal handoff does not notify a second time. */
+export const ESCALATION_NOTIFIED_KEY = '__escalationNotified';
+const SUMMARY_PROMPT = [
+    'Write a concise handoff brief for a human agent taking over this conversation.',
+    'Cover: who the user is (if known), what they want, what has been done or promised',
+    '(with exact ids/amounts), why this is being escalated, and the next action the human should take.',
+    'Maximum 120 words. Do not invent details.',
+].join(' ');
+function textProjection(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((part) => part.type === 'text' && typeof part.text === 'string')
+        .map((part) => part.text)
+        .join(' ');
+}
+export function ensureSessionMetadata(session) {
+    if (!session.metadata) {
+        const now = new Date();
+        session.metadata = {
+            createdAt: now,
+            lastActiveAt: now,
+            totalTokens: 0,
+            totalSteps: 0,
+            handoffHistory: [],
+        };
+    }
+    return session.metadata;
+}
+export async function buildEscalationRequest(options) {
+    const { session, runState, reason, category, config, model } = options;
+    const recentCount = config.recentMessageCount ?? 12;
+    const recentMessages = runState.messages
+        .slice(-recentCount)
+        .map((message) => ({ role: message.role, content: textProjection(message.content) }))
+        .filter((message) => message.content.trim().length > 0);
+    const state = {};
+    for (const [key, value] of Object.entries(runState.state)) {
+        if (!key.startsWith('__')) {
+            state[key] = value;
+        }
+    }
+    let summary;
+    const summarize = config.summarize ?? true;
+    if (summarize && model && recentMessages.length > 0) {
+        try {
+            const transcript = recentMessages
+                .map((message) => `${message.role}: ${message.content}`)
+                .join('\n');
+            const result = await generateText({
+                model,
+                system: SUMMARY_PROMPT,
+                prompt: `Escalation reason: ${reason}\n\nConversation:\n${transcript}`,
+                abortSignal: options.abortSignal,
+            });
+            summary = result.text.trim() || undefined;
+        }
+        catch {
+            summary = undefined; // the handoff proceeds without a brief — never blocks on the summarizer
+        }
+    }
+    return {
+        sessionId: session.id,
+        userId: session.userId,
+        agentId: runState.activeAgentId,
+        reason,
+        category,
+        summary,
+        state,
+        recentMessages,
+        at: new Date().toISOString(),
+    };
+}
+export function recordEscalationOutcome(session, category, outcome) {
+    const metadata = ensureSessionMetadata(session);
+    metadata.lastEscalation = {
+        at: new Date().toISOString(),
+        reason: category,
+        handlerOutcome: outcome.status,
+    };
+}

package/dist/escalation/types.d.ts

@@ -1,3 +1,4 @@
+import type { LanguageModel } from 'ai';
 export type EscalationReason = 'low-confidence' | 'user-request' | 'frustration' | 'tool-call' | 'safety-block';
 export type EscalationOutcome = {
     status: 'queued';
@@ -10,3 +11,42 @@ export type EscalationOutcome = {
     status: 'failed';
     error: string;
 };
+/**
+ * The handoff package built when a conversation escalates to a human:
+ * everything the receiving agent needs to take over without re-asking.
+ */
+export interface EscalationRequest {
+    sessionId: string;
+    userId?: string;
+    agentId: string;
+    /** Free-form reason from the triggering control (tool call, validator, flow transition). */
+    reason: string;
+    /** Typed category when the trigger provided one. */
+    category?: EscalationReason;
+    /** LLM-generated handoff brief (when summarization is enabled and a model is available). */
+    summary?: string;
+    /** Collected flow state snapshot (internal `__`-prefixed keys excluded). */
+    state: Record<string, unknown>;
+    /** Recent conversation tail as a text projection, oldest first. */
+    recentMessages: Array<{
+        role: string;
+        content: string;
+    }>;
+    /** ISO8601 timestamp. */
+    at: string;
+}
+/**
+ * Host-provided escalation sink: queue a ticket, claim thread ownership,
+ * page an operator. Must not throw for expected failures — return
+ * `{ status: 'failed', error }` instead (the runtime also catches).
+ */
+export type EscalationHandler = (request: EscalationRequest) => Promise<EscalationOutcome>;
+export interface EscalationConfig {
+    handler: EscalationHandler;
+    /** Generate the LLM handoff brief. Default: true. */
+    summarize?: boolean;
+    /** Summary model. Default: the active agent's controlModel → model → defaultModel. */
+    model?: LanguageModel;
+    /** Recent messages included in the request. Default: 12. */
+    recentMessageCount?: number;
+}

package/dist/eval/simulation.d.ts

@@ -0,0 +1,99 @@
+import type { LanguageModel } from 'ai';
+import type { TurnHandle } from '../types/stream.js';
+import type { UserInputContent } from '../runtime/userInput.js';
+/**
+ * Simulated-user evaluation: an LLM role-plays a customer persona against a
+ * real runtime, and an LLM judge scores the resulting transcript against a
+ * rubric. This is the pre-deploy gate that scripted turn assertions
+ * (`EvalRunner`) cannot provide — scripted turns test the happy path you
+ * thought of; simulated users find the conversations you didn't.
+ */
+export interface SimulatedUserPersona {
+    /** Who the user is, e.g. "a busy parent in Colombo ordering a birthday cake". */
+    profile: string;
+    /** What they are trying to accomplish — the goal the judge scores against. */
+    goal: string;
+    /** Behavioral style, e.g. "impatient; sends short fragmented messages; switches topics". */
+    temperament?: string;
+    /** First user message. Generated from the persona when omitted. */
+    openingMessage?: string;
+}
+export interface SimulatedTranscriptTurn {
+    role: 'user' | 'assistant';
+    content: string;
+}
+export type SimulationEnd = 'goal-met' | 'user-gave-up' | 'max-turns';
+export interface SimulationResult {
+    transcript: SimulatedTranscriptTurn[];
+    turns: number;
+    endedBy: SimulationEnd;
+    sessionId: string;
+    toolsCalled: string[];
+    escalated: boolean;
+}
+/** The runtime surface the simulator drives (satisfied by `Runtime`). */
+export interface SimulatableRuntime {
+    run(opts: {
+        sessionId?: string;
+        input?: UserInputContent;
+    }): TurnHandle;
+}
+export interface SimulateConversationOptions {
+    runtime: SimulatableRuntime;
+    persona: SimulatedUserPersona;
+    /** Model that plays the user. */
+    userModel: LanguageModel;
+    /** Max user turns before the simulation stops. Default: 10. */
+    maxTurns?: number;
+    sessionId?: string;
+}
+export declare function simulateConversation(options: SimulateConversationOptions): Promise<SimulationResult>;
+export interface JudgeDimension {
+    key: string;
+    description: string;
+}
+export declare const DEFAULT_JUDGE_DIMENSIONS: JudgeDimension[];
+export interface JudgeVerdict {
+    scores: Record<string, {
+        score: number;
+        rationale: string;
+    }>;
+    /** Mean of dimension scores, 1–5. */
+    overall: number;
+    pass: boolean;
+    summary: string;
+}
+export interface CreateJudgeOptions {
+    model: LanguageModel;
+    dimensions?: JudgeDimension[];
+    /** Minimum mean score (1–5) to pass. Default: 3.5. */
+    passThreshold?: number;
+    /** Extra domain rules appended to the judge prompt. */
+    instructions?: string;
+}
+export interface ConversationJudge {
+    judge(result: SimulationResult, persona: SimulatedUserPersona): Promise<JudgeVerdict>;
+}
+export declare function createJudge(options: CreateJudgeOptions): ConversationJudge;
+export interface SimulationScenario {
+    name: string;
+    persona: SimulatedUserPersona;
+    maxTurns?: number;
+}
+export interface SimulationSuiteResult {
+    scenarios: Array<{
+        name: string;
+        result: SimulationResult;
+        verdict: JudgeVerdict;
+    }>;
+    passed: boolean;
+    passRate: number;
+}
+export interface RunSimulationSuiteOptions {
+    runtime: SimulatableRuntime;
+    scenarios: SimulationScenario[];
+    userModel: LanguageModel;
+    judge: ConversationJudge;
+}
+/** Run every scenario and judge each transcript. `passed` is the CI gate. */
+export declare function runSimulationSuite(options: RunSimulationSuiteOptions): Promise<SimulationSuiteResult>;

package/dist/eval/simulation.js

@@ -0,0 +1,168 @@
+import { generateObject } from 'ai';
+import { z } from 'zod';
+import { newSessionId } from '../runtime/openRun.js';
+const userTurnSchema = z.object({
+    /** Null when the user would stop talking instead of replying. */
+    message: z.union([z.string(), z.null()]),
+    status: z.enum(['continue', 'goal-met', 'give-up']),
+});
+function renderTranscript(transcript) {
+    return transcript
+        .map((turn) => `${turn.role === 'user' ? 'You' : 'Agent'}: ${turn.content}`)
+        .join('\n');
+}
+async function nextUserTurn(model, persona, transcript) {
+    const { object } = await generateObject({
+        model,
+        schema: userTurnSchema,
+        temperature: 0.7,
+        system: [
+            'You are role-playing a customer talking to a business chat agent. Stay fully in character.',
+            `Who you are: ${persona.profile}`,
+            `Your goal: ${persona.goal}`,
+            persona.temperament ? `Your style: ${persona.temperament}` : '',
+            'Write your next message as this customer would (short, natural chat messages — not essays).',
+            "Set status to 'goal-met' when the agent has fully accomplished your goal,",
+            "'give-up' if you would abandon the conversation in frustration, otherwise 'continue'.",
+            "When status is not 'continue', message may be null or a short closing line.",
+        ]
+            .filter(Boolean)
+            .join('\n'),
+        prompt: transcript.length === 0
+            ? 'Write your opening message to the agent.'
+            : `Conversation so far:\n${renderTranscript(transcript)}\n\nWrite your next message.`,
+    });
+    return object;
+}
+export async function simulateConversation(options) {
+    const maxTurns = options.maxTurns ?? 10;
+    const sessionId = options.sessionId ?? newSessionId();
+    const transcript = [];
+    const toolsCalled = [];
+    let escalated = false;
+    let endedBy = 'max-turns';
+    for (let turn = 0; turn < maxTurns; turn += 1) {
+        let userMessage;
+        if (turn === 0 && options.persona.openingMessage) {
+            userMessage = options.persona.openingMessage;
+        }
+        else {
+            const next = await nextUserTurn(options.userModel, options.persona, transcript);
+            if (next.status !== 'continue') {
+                if (next.message?.trim()) {
+                    transcript.push({ role: 'user', content: next.message });
+                }
+                endedBy = next.status === 'goal-met' ? 'goal-met' : 'user-gave-up';
+                break;
+            }
+            if (!next.message?.trim()) {
+                endedBy = 'user-gave-up';
+                break;
+            }
+            userMessage = next.message;
+        }
+        transcript.push({ role: 'user', content: userMessage });
+        const handle = options.runtime.run({ sessionId, input: userMessage });
+        let reply = '';
+        for await (const part of handle.events) {
+            if (part.type === 'text-delta')
+                reply += part.delta;
+            if (part.type === 'tool-call')
+                toolsCalled.push(part.toolName);
+            if (part.type === 'escalation' || (part.type === 'handoff' && part.targetAgent === 'human')) {
+                escalated = true;
+            }
+        }
+        const result = await handle;
+        transcript.push({ role: 'assistant', content: reply || result.text });
+    }
+    return {
+        transcript,
+        turns: transcript.filter((turn) => turn.role === 'user').length,
+        endedBy,
+        sessionId,
+        toolsCalled,
+        escalated,
+    };
+}
+export const DEFAULT_JUDGE_DIMENSIONS = [
+    { key: 'goalCompletion', description: 'Did the agent fully accomplish what the user wanted?' },
+    {
+        key: 'grounding',
+        description: 'Did the agent avoid claiming actions or facts it did not perform/know (no invented orders, prices, policies)?',
+    },
+    { key: 'tone', description: 'Was the agent natural, concise, and appropriate for chat?' },
+    {
+        key: 'efficiency',
+        description: 'Did the agent resolve the request without unnecessary turns or repeated questions?',
+    },
+];
+const judgeSchema = z.object({
+    scores: z.array(z.object({
+        key: z.string(),
+        /** 1 (poor) to 5 (excellent). */
+        score: z.number(),
+        rationale: z.string(),
+    })),
+    summary: z.string(),
+});
+export function createJudge(options) {
+    const dimensions = options.dimensions ?? DEFAULT_JUDGE_DIMENSIONS;
+    const passThreshold = options.passThreshold ?? 3.5;
+    return {
+        async judge(result, persona) {
+            const { object } = await generateObject({
+                model: options.model,
+                schema: judgeSchema,
+                temperature: 0,
+                system: [
+                    'You are an evaluation judge for customer-facing conversational agents.',
+                    'Score the AGENT (not the user) on each dimension from 1 (poor) to 5 (excellent), with a one-sentence rationale each:',
+                    ...dimensions.map((dimension) => `- ${dimension.key}: ${dimension.description}`),
+                    options.instructions ? `Additional rules:\n${options.instructions}` : '',
+                    'Be strict: claiming an action that has no evidence in the transcript is a grounding failure.',
+                ]
+                    .filter(Boolean)
+                    .join('\n'),
+                prompt: [
+                    `User persona: ${persona.profile}`,
+                    `User goal: ${persona.goal}`,
+                    `Conversation ended by: ${result.endedBy}. Tools called: ${result.toolsCalled.join(', ') || 'none'}.`,
+                    `Transcript:\n${renderTranscript(result.transcript)}`,
+                ].join('\n\n'),
+            });
+            const scores = {};
+            for (const entry of object.scores) {
+                scores[entry.key] = { score: entry.score, rationale: entry.rationale };
+            }
+            const values = Object.values(scores).map((entry) => entry.score);
+            const overall = values.length > 0 ? values.reduce((sum, score) => sum + score, 0) / values.length : 0;
+            return {
+                scores,
+                overall,
+                pass: overall >= passThreshold && result.endedBy !== 'user-gave-up',
+                summary: object.summary,
+            };
+        },
+    };
+}
+/** Run every scenario and judge each transcript. `passed` is the CI gate. */
+export async function runSimulationSuite(options) {
+    const scenarios = [];
+    for (const scenario of options.scenarios) {
+        const result = await simulateConversation({
+            runtime: options.runtime,
+            persona: scenario.persona,
+            userModel: options.userModel,
+            maxTurns: scenario.maxTurns,
+        });
+        const verdict = await options.judge.judge(result, scenario.persona);
+        scenarios.push({ name: scenario.name, result, verdict });
+    }
+    const passedCount = scenarios.filter((entry) => entry.verdict.pass).length;
+    return {
+        scenarios,
+        passed: passedCount === scenarios.length,
+        passRate: scenarios.length > 0 ? passedCount / scenarios.length : 1,
+    };
+}

package/dist/index.d.ts

@@ -12,6 +12,8 @@ export { buildMarkOutcomeTool, OUTCOMES_MARK_TOOL_NAME } from './outcomes/index.
 export { EvalRunner } from './eval/EvalRunner.js';
 export { scoreTurn, aggregateScores } from './eval/scoring.js';
 export type { EvalScenario, EvalTurn, ScenarioScore, TurnScore } from './eval/types.js';
+export { simulateConversation, createJudge, runSimulationSuite, DEFAULT_JUDGE_DIMENSIONS, } from './eval/simulation.js';
+export type { SimulatedUserPersona, SimulatedTranscriptTurn, SimulationResult, SimulationEnd, SimulatableRuntime, SimulateConversationOptions, JudgeDimension, JudgeVerdict, CreateJudgeOptions, ConversationJudge, SimulationScenario, SimulationSuiteResult, RunSimulationSuiteOptions, } from './eval/simulation.js';
 export { SessionWorkingMemory } from './runtime/WorkingMemory.js';
 export type { Tool, ToolSet, ToolDefinition, ToolWithFiller, ToolExecutionOptions, ToolExecutionContext, } from './tools/Tool.js';
 export { createTool, createToolWithFiller } from './tools/Tool.js';
@@ -34,6 +36,14 @@ export type { Metrics } from './hooks/builtin/metrics.js';
 export { createObservabilityHooks } from './hooks/builtin/observability.js';
 export type { ObservabilityConfig } from './hooks/builtin/observability.js';
 export type { SessionTrace, TraceStreamEvent } from './types/telemetry.js';
+export { createPromptInjectionGuard } from './processors/builtin/promptInjectionGuard.js';
+export type { PromptInjectionGuardOptions } from './processors/builtin/promptInjectionGuard.js';
+export { createPiiInputGuard, createPiiOutputGuard, redactPii, } from './processors/builtin/piiGuard.js';
+export type { PiiDetector, PiiGuardOptions, PiiMatch, PiiScanResult, } from './processors/builtin/piiGuard.js';
+export { createModerationGuard, createModerationOutputGuard, } from './processors/builtin/moderationGuard.js';
+export type { ModerationGuardOptions } from './processors/builtin/moderationGuard.js';
+export { createGroundingValidator } from './capabilities/validators/groundingValidator.js';
+export type { GroundingValidatorOptions } from './capabilities/validators/groundingValidator.js';
 export { ToolEnforcer, createToolEnforcer } from './guards/ToolEnforcer.js';
 export * as StopConditions from './guards/StopConditions.js';
 export * from './guards/rules.js';
@@ -47,6 +57,8 @@ export type { MemoryEntry, SearchMemoryRequest, SearchMemoryResponse, MemoryInge
 export { InMemoryMemoryService } from './memory/index.js';
 export { preloadMemoryContext } from './memory/index.js';
 export { extractMemories } from './memory/index.js';
+export { createFactMemoryService } from './memory/index.js';
+export type { FactMemoryServiceOptions } from './memory/index.js';
 export type { PersistentMemoryStore, PersistentMemoryBlock, PersistentMemoryConfig, MemoryBlockScope, WorkingMemoryBlockSpec, WorkingMemoryConfig, } from './memory/index.js';
 export { FilePersistentMemoryStore, InMemoryPersistentMemoryStore, RoutedPersistentMemoryStore, TieredPersistentMemoryStore, scanMemoryWrite, buildMemoryBlockTool, DEFAULT_BLOCK_CHAR_LIMIT, DEFAULT_AUTO_LOAD_BLOCKS, } from './memory/index.js';
 export type { RoutedPersistentMemoryStoreConfig, MemoryRouteFn, } from './memory/index.js';
@@ -55,6 +67,10 @@ export { resolveAgentWorkspace, type ResolvedAgentWorkspace, } from './runtime/r
 export { DEFAULT_CONTEXT_BUDGET, VOICE_CONTEXT_BUDGET, computeMessageHistoryBudget, truncateToTokenBudget, formatMemoryWithBudget, estimateTokenCount, ContextBudget, } from './runtime/ContextBudget.js';
 export type { ContextBudgetConfig } from './runtime/ContextBudget.js';
 export { TokenAccumulator } from './runtime/TokenAccumulator.js';
+export { compactMessages, estimateMessagesTokens, DEFAULT_COMPACTION_TRIGGER_TOKENS, DEFAULT_COMPACTION_KEEP_RECENT, } from './runtime/compaction.js';
+export type { CompactionConfig, CompactionResult } from './runtime/compaction.js';
+export { isContextOverflowError, recoverFromContextOverflow, } from './runtime/contextOverflow.js';
+export type { OverflowRecoveryResult } from './runtime/contextOverflow.js';
 export { applyPromptCache, applyAnthropicCacheControl, buildOpenAIResponsesProviderOptions, isAnthropicLanguageModel, isOpenAIResponsesModel, } from './runtime/promptCache.js';
 export type { AnthropicCacheTtl, OpenAIResponsesCompactOptions } from './runtime/promptCache.js';
 export { handoffFilters, removeToolHistory, keepRecentMessages, removeKeys, composeFilters, } from './runtime/handoffFilters.js';
@@ -64,7 +80,10 @@ export type { ToolExecutor, ConversationState, ConversationEventLog, Conversatio
 export type * from './types/index.js';
 export { CapabilityHost, ExtractionCapability, GuardrailCapability, AutoRetrieveCapability, PassThroughRefinement, PassThroughValidation, toGeminiDeclarations, toAISDKTools, } from './capabilities/index.js';
 export type { Capability, CapabilityAction, ExtractionToolResponseEnvelope, FlowReconfigureTransition, ToolDeclaration, PromptSection as CapabilityPromptSection, GeminiFunctionDeclaration, ExtractionCapabilityConfig, RetrieveProvider, AutoRetrieveCapabilityConfig, RefinementCapability, RefineInput, RefineDecision, ValidationCapability, ValidateInput, ValidateDecision, SourceRef, } from './capabilities/index.js';
-export type { EscalationOutcome, EscalationReason } from './escalation/types.js';
+export type { EscalationOutcome, EscalationReason, EscalationRequest, EscalationHandler, EscalationConfig, } from './escalation/types.js';
+export { buildEscalationRequest, ensureSessionMetadata } from './escalation/escalation.js';
+export { createInProcessScheduler, createWakeJobRunner, createScheduleFollowupTool, wakeJob, isWakeJob, WAKE_JOB_KIND, } from './scheduler/index.js';
+export type { Scheduler, ScheduledJob, InjectableTimer, WakeOptions, WakeJobPayload, WakeDelivery, WakeRunnable, } from './scheduler/index.js';
 export { filterAuditEntries } from './audit/index.js';
 export type { AuditConfig, AuditEntryBase, AuditEntryType, AuditListOptions, AuditReplayOptions, ConversationAuditEntry, ConversationAuditLog, } from './audit/types.js';
 export type { RealtimeAudioClient, RealtimeSessionConfig, RealtimeAudioConfig, RealtimeToolResponse, RealtimeEventMap, RealtimeSessionHandle, } from './realtime/index.js';
@@ -95,7 +114,8 @@ export { DURABLE_RUNS_KEY } from './runtime/durable/types.js';
 export type { RunStore } from './runtime/durable/RunStore.js';
 export type { ChannelDriver, TextDriver } from './runtime/channels/index.js';
 export type { TurnResult } from './types/channel.js';
-export type { RunContext } from './types/run-context.js';
+export type { RunContext, ToolContext, ActionContext } from './types/run-context.js';
+export type { AnyTool } from './types/effectTool.js';
 export { createRuntime, Runtime, type HarnessConfig, type RunOptions, } from './runtime/Runtime.js';
 export type { RuntimeLike } from './runtime/RuntimeLike.js';
 export { userInputToText, hasMediaParts, transcribeAudioParts, type UserInputContent, } from './runtime/userInput.js';