@kat-ai/sdk 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,2829 @@
+import { S as Slots, T as TraceStep, b as TraceEvent, A as AgentContext, I as Intent, C as ConversationMessage, E as ExecutionTrace, M as MultiChoiceOption, c as ChatResponse, d as ChatCitation, P as Plan, e as StepResult, D as DisambiguationResult, f as PlanStepKBCall, K as KBRetrieval, g as PlanStepSynthesis } from './core-pLiFHTBe.mjs';
+export { y as ChatOutcome, x as ChatRequest, q as DisambiguationAction, r as DisambiguationDetails, u as KBRelevanceInfo, t as LLMExtractionFacts, a as LogEntry, L as LogLevel, p as PendingQuestion, w as PlanModification, n as PlanStep, m as PlanStepType, v as PlanningReasoning, o as TraceStepType, l as clearSessionLogs, h as createSessionLogger, j as emitTraceStep, k as getSessionLogs, s as subscribeToLogs, i as subscribeToTraceSteps } from './core-pLiFHTBe.mjs';
+import { z } from 'zod';
+
+/**
+ * Configuration Types
+ *
+ * Zod schemas and TypeScript types for agent configuration.
+ */
+
+/** Slot definition schema */
+declare const SlotDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["string", "boolean", "enum"]>;
+    required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    description: z.ZodString;
+    prompt: z.ZodString;
+    examples: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    normalization: z.ZodOptional<z.ZodEnum<["lower_snake", "lowercase", "uppercase", "none"]>>;
+    enumValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    format: z.ZodOptional<z.ZodObject<{
+        true: z.ZodString;
+        false: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        true: string;
+        false: string;
+    }, {
+        true: string;
+        false: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "boolean" | "enum";
+    name: string;
+    required: boolean;
+    description: string;
+    prompt: string;
+    examples?: string[] | undefined;
+    normalization?: "lower_snake" | "lowercase" | "uppercase" | "none" | undefined;
+    enumValues?: string[] | undefined;
+    format?: {
+        true: string;
+        false: string;
+    } | undefined;
+}, {
+    type: "string" | "boolean" | "enum";
+    name: string;
+    description: string;
+    prompt: string;
+    required?: boolean | undefined;
+    examples?: string[] | undefined;
+    normalization?: "lower_snake" | "lowercase" | "uppercase" | "none" | undefined;
+    enumValues?: string[] | undefined;
+    format?: {
+        true: string;
+        false: string;
+    } | undefined;
+}>;
+type SlotDefinition$1 = z.infer<typeof SlotDefinitionSchema>;
+/** LLM configuration schema */
+declare const LLMConfigSchema: z.ZodObject<{
+    provider: z.ZodEnum<["openai", "anthropic"]>;
+    models: z.ZodObject<{
+        planning: z.ZodString;
+        extraction: z.ZodString;
+        synthesis: z.ZodString;
+        questionGeneration: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        planning: string;
+        extraction: string;
+        synthesis: string;
+        questionGeneration?: string | undefined;
+    }, {
+        planning: string;
+        extraction: string;
+        synthesis: string;
+        questionGeneration?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    provider: "openai" | "anthropic";
+    models: {
+        planning: string;
+        extraction: string;
+        synthesis: string;
+        questionGeneration?: string | undefined;
+    };
+}, {
+    provider: "openai" | "anthropic";
+    models: {
+        planning: string;
+        extraction: string;
+        synthesis: string;
+        questionGeneration?: string | undefined;
+    };
+}>;
+type LLMConfig = z.infer<typeof LLMConfigSchema>;
+/** Prompts configuration schema */
+declare const PromptsConfigSchema: z.ZodObject<{
+    plannerSystemRole: z.ZodString;
+    synthesisSystemRole: z.ZodString;
+    planningInstructions: z.ZodOptional<z.ZodString>;
+    synthesisInstructions: z.ZodOptional<z.ZodString>;
+    extractionInstructions: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    plannerSystemRole: string;
+    synthesisSystemRole: string;
+    planningInstructions?: string | undefined;
+    synthesisInstructions?: string | undefined;
+    extractionInstructions?: string | undefined;
+}, {
+    plannerSystemRole: string;
+    synthesisSystemRole: string;
+    planningInstructions?: string | undefined;
+    synthesisInstructions?: string | undefined;
+    extractionInstructions?: string | undefined;
+}>;
+type PromptsConfig = z.infer<typeof PromptsConfigSchema>;
+/** Goal examples for extraction */
+declare const GoalExamplesSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description?: string | undefined;
+}, {
+    name: string;
+    description?: string | undefined;
+}>, "many">;
+type GoalExamples = z.infer<typeof GoalExamplesSchema>;
+/** Messages configuration schema */
+declare const MessagesConfigSchema: z.ZodObject<{
+    allKBsFailed: z.ZodString;
+    noRelevantInfo: z.ZodString;
+    synthesisError: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    allKBsFailed: string;
+    noRelevantInfo: string;
+    synthesisError: string;
+}, {
+    allKBsFailed: string;
+    noRelevantInfo: string;
+    synthesisError: string;
+}>;
+type MessagesConfig = z.infer<typeof MessagesConfigSchema>;
+/** Citations configuration schema */
+declare const CitationsConfigSchema: z.ZodObject<{
+    format: z.ZodEnum<["brackets", "footnotes", "superscript"]>;
+    labelPrefix: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    format: "brackets" | "footnotes" | "superscript";
+    labelPrefix: string;
+}, {
+    format: "brackets" | "footnotes" | "superscript";
+    labelPrefix: string;
+}>;
+type CitationsConfig = z.infer<typeof CitationsConfigSchema>;
+/** Behavior configuration schema */
+declare const BehaviorConfigSchema: z.ZodObject<{
+    maxDisambiguationAttempts: z.ZodDefault<z.ZodNumber>;
+    fallbackStrategy: z.ZodDefault<z.ZodEnum<["use_first", "use_all", "fail"]>>;
+    enablePlanModification: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    maxDisambiguationAttempts: number;
+    fallbackStrategy: "use_first" | "use_all" | "fail";
+    enablePlanModification: boolean;
+}, {
+    maxDisambiguationAttempts?: number | undefined;
+    fallbackStrategy?: "use_first" | "use_all" | "fail" | undefined;
+    enablePlanModification?: boolean | undefined;
+}>;
+type BehaviorConfig = z.infer<typeof BehaviorConfigSchema>;
+/** KB Provider configuration schema */
+declare const KBProviderConfigSchema: z.ZodObject<{
+    type: z.ZodDefault<z.ZodEnum<["pinecone", "elasticsearch", "custom"]>>;
+    topK: z.ZodDefault<z.ZodNumber>;
+    normalizeNames: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "custom" | "pinecone" | "elasticsearch";
+    topK: number;
+    normalizeNames: boolean;
+}, {
+    type?: "custom" | "pinecone" | "elasticsearch" | undefined;
+    topK?: number | undefined;
+    normalizeNames?: boolean | undefined;
+}>;
+type KBProviderConfig = z.infer<typeof KBProviderConfigSchema>;
+/** Session/logging configuration schema */
+declare const SessionConfigSchema: z.ZodObject<{
+    maxLogsPerSession: z.ZodDefault<z.ZodNumber>;
+    maxTraceStepsPerSession: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    maxLogsPerSession: number;
+    maxTraceStepsPerSession: number;
+}, {
+    maxLogsPerSession?: number | undefined;
+    maxTraceStepsPerSession?: number | undefined;
+}>;
+type SessionConfig = z.infer<typeof SessionConfigSchema>;
+/** Providers configuration schema (aggregates all provider settings) */
+declare const ProvidersConfigSchema: z.ZodObject<{
+    kb: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodDefault<z.ZodEnum<["pinecone", "elasticsearch", "custom"]>>;
+        topK: z.ZodDefault<z.ZodNumber>;
+        normalizeNames: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "custom" | "pinecone" | "elasticsearch";
+        topK: number;
+        normalizeNames: boolean;
+    }, {
+        type?: "custom" | "pinecone" | "elasticsearch" | undefined;
+        topK?: number | undefined;
+        normalizeNames?: boolean | undefined;
+    }>>>;
+    session: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        maxLogsPerSession: z.ZodDefault<z.ZodNumber>;
+        maxTraceStepsPerSession: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        maxLogsPerSession: number;
+        maxTraceStepsPerSession: number;
+    }, {
+        maxLogsPerSession?: number | undefined;
+        maxTraceStepsPerSession?: number | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    kb: {
+        type: "custom" | "pinecone" | "elasticsearch";
+        topK: number;
+        normalizeNames: boolean;
+    };
+    session: {
+        maxLogsPerSession: number;
+        maxTraceStepsPerSession: number;
+    };
+}, {
+    kb?: {
+        type?: "custom" | "pinecone" | "elasticsearch" | undefined;
+        topK?: number | undefined;
+        normalizeNames?: boolean | undefined;
+    } | undefined;
+    session?: {
+        maxLogsPerSession?: number | undefined;
+        maxTraceStepsPerSession?: number | undefined;
+    } | undefined;
+}>;
+type ProvidersConfig = z.infer<typeof ProvidersConfigSchema>;
+/** Main agent configuration schema */
+declare const AgentConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    domain: z.ZodString;
+    llm: z.ZodObject<{
+        provider: z.ZodEnum<["openai", "anthropic"]>;
+        models: z.ZodObject<{
+            planning: z.ZodString;
+            extraction: z.ZodString;
+            synthesis: z.ZodString;
+            questionGeneration: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            planning: string;
+            extraction: string;
+            synthesis: string;
+            questionGeneration?: string | undefined;
+        }, {
+            planning: string;
+            extraction: string;
+            synthesis: string;
+            questionGeneration?: string | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        provider: "openai" | "anthropic";
+        models: {
+            planning: string;
+            extraction: string;
+            synthesis: string;
+            questionGeneration?: string | undefined;
+        };
+    }, {
+        provider: "openai" | "anthropic";
+        models: {
+            planning: string;
+            extraction: string;
+            synthesis: string;
+            questionGeneration?: string | undefined;
+        };
+    }>;
+    prompts: z.ZodObject<{
+        plannerSystemRole: z.ZodString;
+        synthesisSystemRole: z.ZodString;
+        planningInstructions: z.ZodOptional<z.ZodString>;
+        synthesisInstructions: z.ZodOptional<z.ZodString>;
+        extractionInstructions: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        plannerSystemRole: string;
+        synthesisSystemRole: string;
+        planningInstructions?: string | undefined;
+        synthesisInstructions?: string | undefined;
+        extractionInstructions?: string | undefined;
+    }, {
+        plannerSystemRole: string;
+        synthesisSystemRole: string;
+        planningInstructions?: string | undefined;
+        synthesisInstructions?: string | undefined;
+        extractionInstructions?: string | undefined;
+    }>;
+    messages: z.ZodObject<{
+        allKBsFailed: z.ZodString;
+        noRelevantInfo: z.ZodString;
+        synthesisError: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        allKBsFailed: string;
+        noRelevantInfo: string;
+        synthesisError: string;
+    }, {
+        allKBsFailed: string;
+        noRelevantInfo: string;
+        synthesisError: string;
+    }>;
+    slots: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["string", "boolean", "enum"]>;
+        required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        description: z.ZodString;
+        prompt: z.ZodString;
+        examples: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        normalization: z.ZodOptional<z.ZodEnum<["lower_snake", "lowercase", "uppercase", "none"]>>;
+        enumValues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        format: z.ZodOptional<z.ZodObject<{
+            true: z.ZodString;
+            false: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            true: string;
+            false: string;
+        }, {
+            true: string;
+            false: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "boolean" | "enum";
+        name: string;
+        required: boolean;
+        description: string;
+        prompt: string;
+        examples?: string[] | undefined;
+        normalization?: "lower_snake" | "lowercase" | "uppercase" | "none" | undefined;
+        enumValues?: string[] | undefined;
+        format?: {
+            true: string;
+            false: string;
+        } | undefined;
+    }, {
+        type: "string" | "boolean" | "enum";
+        name: string;
+        description: string;
+        prompt: string;
+        required?: boolean | undefined;
+        examples?: string[] | undefined;
+        normalization?: "lower_snake" | "lowercase" | "uppercase" | "none" | undefined;
+        enumValues?: string[] | undefined;
+        format?: {
+            true: string;
+            false: string;
+        } | undefined;
+    }>, "many">;
+    slotPriority: z.ZodArray<z.ZodString, "many">;
+    goals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+    }>, "many">>;
+    defaultKbId: z.ZodString;
+    citations: z.ZodObject<{
+        format: z.ZodEnum<["brackets", "footnotes", "superscript"]>;
+        labelPrefix: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        format: "brackets" | "footnotes" | "superscript";
+        labelPrefix: string;
+    }, {
+        format: "brackets" | "footnotes" | "superscript";
+        labelPrefix: string;
+    }>;
+    behavior: z.ZodObject<{
+        maxDisambiguationAttempts: z.ZodDefault<z.ZodNumber>;
+        fallbackStrategy: z.ZodDefault<z.ZodEnum<["use_first", "use_all", "fail"]>>;
+        enablePlanModification: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxDisambiguationAttempts: number;
+        fallbackStrategy: "use_first" | "use_all" | "fail";
+        enablePlanModification: boolean;
+    }, {
+        maxDisambiguationAttempts?: number | undefined;
+        fallbackStrategy?: "use_first" | "use_all" | "fail" | undefined;
+        enablePlanModification?: boolean | undefined;
+    }>;
+    providers: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        kb: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            type: z.ZodDefault<z.ZodEnum<["pinecone", "elasticsearch", "custom"]>>;
+            topK: z.ZodDefault<z.ZodNumber>;
+            normalizeNames: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "custom" | "pinecone" | "elasticsearch";
+            topK: number;
+            normalizeNames: boolean;
+        }, {
+            type?: "custom" | "pinecone" | "elasticsearch" | undefined;
+            topK?: number | undefined;
+            normalizeNames?: boolean | undefined;
+        }>>>;
+        session: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            maxLogsPerSession: z.ZodDefault<z.ZodNumber>;
+            maxTraceStepsPerSession: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            maxLogsPerSession: number;
+            maxTraceStepsPerSession: number;
+        }, {
+            maxLogsPerSession?: number | undefined;
+            maxTraceStepsPerSession?: number | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        kb: {
+            type: "custom" | "pinecone" | "elasticsearch";
+            topK: number;
+            normalizeNames: boolean;
+        };
+        session: {
+            maxLogsPerSession: number;
+            maxTraceStepsPerSession: number;
+        };
+    }, {
+        kb?: {
+            type?: "custom" | "pinecone" | "elasticsearch" | undefined;
+            topK?: number | undefined;
+            normalizeNames?: boolean | undefined;
+        } | undefined;
+        session?: {
+            maxLogsPerSession?: number | undefined;
+            maxTraceStepsPerSession?: number | undefined;
+        } | undefined;
+    }>>>;
+    slotMappings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    domain: string;
+    llm: {
+        provider: "openai" | "anthropic";
+        models: {
+            planning: string;
+            extraction: string;
+            synthesis: string;
+            questionGeneration?: string | undefined;
+        };
+    };
+    prompts: {
+        plannerSystemRole: string;
+        synthesisSystemRole: string;
+        planningInstructions?: string | undefined;
+        synthesisInstructions?: string | undefined;
+        extractionInstructions?: string | undefined;
+    };
+    messages: {
+        allKBsFailed: string;
+        noRelevantInfo: string;
+        synthesisError: string;
+    };
+    slots: {
+        type: "string" | "boolean" | "enum";
+        name: string;
+        required: boolean;
+        description: string;
+        prompt: string;
+        examples?: string[] | undefined;
+        normalization?: "lower_snake" | "lowercase" | "uppercase" | "none" | undefined;
+        enumValues?: string[] | undefined;
+        format?: {
+            true: string;
+            false: string;
+        } | undefined;
+    }[];
+    slotPriority: string[];
+    defaultKbId: string;
+    citations: {
+        format: "brackets" | "footnotes" | "superscript";
+        labelPrefix: string;
+    };
+    behavior: {
+        maxDisambiguationAttempts: number;
+        fallbackStrategy: "use_first" | "use_all" | "fail";
+        enablePlanModification: boolean;
+    };
+    providers: {
+        kb: {
+            type: "custom" | "pinecone" | "elasticsearch";
+            topK: number;
+            normalizeNames: boolean;
+        };
+        session: {
+            maxLogsPerSession: number;
+            maxTraceStepsPerSession: number;
+        };
+    };
+    goals?: {
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
+    slotMappings?: Record<string, Record<string, string>> | undefined;
+}, {
+    name: string;
+    domain: string;
+    llm: {
+        provider: "openai" | "anthropic";
+        models: {
+            planning: string;
+            extraction: string;
+            synthesis: string;
+            questionGeneration?: string | undefined;
+        };
+    };
+    prompts: {
+        plannerSystemRole: string;
+        synthesisSystemRole: string;
+        planningInstructions?: string | undefined;
+        synthesisInstructions?: string | undefined;
+        extractionInstructions?: string | undefined;
+    };
+    messages: {
+        allKBsFailed: string;
+        noRelevantInfo: string;
+        synthesisError: string;
+    };
+    slots: {
+        type: "string" | "boolean" | "enum";
+        name: string;
+        description: string;
+        prompt: string;
+        required?: boolean | undefined;
+        examples?: string[] | undefined;
+        normalization?: "lower_snake" | "lowercase" | "uppercase" | "none" | undefined;
+        enumValues?: string[] | undefined;
+        format?: {
+            true: string;
+            false: string;
+        } | undefined;
+    }[];
+    slotPriority: string[];
+    defaultKbId: string;
+    citations: {
+        format: "brackets" | "footnotes" | "superscript";
+        labelPrefix: string;
+    };
+    behavior: {
+        maxDisambiguationAttempts?: number | undefined;
+        fallbackStrategy?: "use_first" | "use_all" | "fail" | undefined;
+        enablePlanModification?: boolean | undefined;
+    };
+    goals?: {
+        name: string;
+        description?: string | undefined;
+    }[] | undefined;
+    providers?: {
+        kb?: {
+            type?: "custom" | "pinecone" | "elasticsearch" | undefined;
+            topK?: number | undefined;
+            normalizeNames?: boolean | undefined;
+        } | undefined;
+        session?: {
+            maxLogsPerSession?: number | undefined;
+            maxTraceStepsPerSession?: number | undefined;
+        } | undefined;
+    } | undefined;
+    slotMappings?: Record<string, Record<string, string>> | undefined;
+}>;
+type AgentConfig = z.infer<typeof AgentConfigSchema>;
+/** Helper type for dynamic Slots based on config */
+type DynamicSlots = {
+    [key: string]: string | boolean | undefined;
+};
+
+/**
+ * Composition and Manifest Types
+ *
+ * Type definitions for knowledge base manifests and composition configuration.
+ */
+
+type SlotValuePrimitive = 'string' | 'boolean' | 'enum';
+type SlotNormalization = 'lower_snake' | 'lowercase' | 'uppercase' | 'none';
+/**
+ * Evidence supporting a manifest component decision.
+ * Contains the LLM's reasoning plus citations to source material.
+ */
+interface ComponentEvidence$1 {
+    /** LLM explanation of why this component exists */
+    reasoning: string;
+    /** Actual KB content (document snippets) that informed this decision */
+    documentSnippets: Array<{
+        content: string;
+        sourceFile: string;
+        score: number;
+    }>;
+    /** Q&A exchanges that surfaced the evidence during introspection */
+    qaExchanges: Array<{
+        questionNumber: number;
+        question: string;
+        answerExcerpt: string;
+    }>;
+}
+/**
+ * Describes how the extractor should handle vague/ambiguous input for this slot.
+ * - 'identifier': Requires a specific identifier (model number, serial, product name). Device types alone are not sufficient.
+ * - 'categorization': Requires explicit indication of a category. Vague descriptions should leave slot empty for clarification.
+ * - 'freeform': Accept any relevant text the user provides.
+ */
+type SlotExtractionBehavior = 'identifier' | 'categorization' | 'freeform';
+interface SlotDefinition {
+    name: string;
+    type: SlotValuePrimitive;
+    description: string;
+    /** Whether this slot is required to answer queries */
+    required?: boolean;
+    prompt?: string;
+    examples?: string[];
+    normalization?: SlotNormalization;
+    enumValues?: string[];
+    /** Evidence supporting why this slot was identified */
+    evidence?: ComponentEvidence$1;
+    /** How the extractor should handle vague/ambiguous input for this slot */
+    extractionBehavior?: SlotExtractionBehavior;
+    /**
+     * LLM-generated guidance for the extractor explaining how to handle this slot.
+     * This is domain-specific advice about what constitutes a valid value vs. ambiguous input.
+     */
+    extractionGuidance?: string;
+}
+interface KBInputField {
+    slot: string;
+    required?: boolean;
+    description?: string;
+    /** Evidence supporting why this input was identified */
+    evidence?: ComponentEvidence$1;
+}
+interface QueryTemplateSection {
+    text: string;
+    requires?: string[];
+    optional?: boolean;
+    fallback?: string;
+}
+interface KBQueryTemplate {
+    preamble?: string;
+    sections?: QueryTemplateSection[];
+    closing?: string[];
+}
+interface KBRelevanceHints {
+    goalKeywords?: string[];
+    slotTriggers?: string[];
+    domains?: string[];
+}
+/**
+ * Defines the scope boundaries for a knowledge base.
+ * Used by the LLM to determine if a query is within scope.
+ */
+interface SlotDependency {
+    slot: string;
+    dependsOn: string[];
+    condition?: string;
+    required?: boolean;
+}
+interface SlotValidation {
+    format?: string;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    enum?: string[];
+    examples?: string[];
+    errorMessage?: string;
+}
+interface KBTerminology {
+    synonyms?: Record<string, string[]>;
+    aliases?: Record<string, string[]>;
+}
+interface KBResponsePatterns {
+    alwaysInclude?: string[];
+    safetyWarnings?: string[];
+    disclaimers?: string[];
+    format?: string;
+}
+interface KBConversationPatterns {
+    commonFollowUps?: string[];
+    clarificationNeeded?: string[];
+    multiTurnExamples?: string[];
+}
+interface KBEdgeCases {
+    scenarios?: string[];
+    handling?: string;
+    additionalContext?: string[];
+}
+interface KBQualityIndicators {
+    highConfidenceTriggers?: string[];
+    lowConfidenceTriggers?: string[];
+    accuracyFactors?: string[];
+}
+interface KBScopeDefinition {
+    /** Human-readable description of what this KB helps with */
+    description: string;
+    /** Example queries that ARE within scope */
+    inScopeExamples?: string[];
+    /** Example queries that are OUT of scope (even if they mention valid products) */
+    outOfScopeExamples?: string[];
+    /** Intent categories that this KB explicitly cannot help with */
+    excludedIntents?: string[];
+    /** Edge cases that are in scope */
+    edgeCaseExamples?: string[];
+    /** Cases that might be in scope (ambiguous) */
+    ambiguousCases?: string[];
+    /** Evidence supporting the scope boundaries */
+    evidence?: ComponentEvidence$1;
+}
+/**
+ * A capability with optional evidence.
+ * Capabilities are typically strings, but can include evidence when introspected.
+ */
+interface KBCapability {
+    text: string;
+    /** Evidence supporting why this capability was identified */
+    evidence?: ComponentEvidence$1;
+}
+interface KBGoal {
+    name: string;
+    description: string;
+    /** Evidence supporting why this goal was identified */
+    evidence?: ComponentEvidence$1;
+}
+interface KBManifest {
+    id: string;
+    assistantName: string;
+    domain: string;
+    description: string;
+    /** Capabilities can be simple strings OR objects with evidence */
+    capabilities: (string | KBCapability)[];
+    outputs: string[];
+    /**
+     * Declarative KB inputs (used when {@link slots} is empty or omitted in JSON manifests).
+     * Converted to {@link SlotDefinition}s at catalog build time.
+     */
+    inputs?: KBInputField[];
+    slots: SlotDefinition[];
+    relevance?: KBRelevanceHints;
+    queryTemplate?: KBQueryTemplate;
+    scope?: KBScopeDefinition;
+    goals?: KBGoal[];
+    slotDependencies?: SlotDependency[];
+    slotPriority?: string[];
+    slotValidations?: Record<string, SlotValidation>;
+    terminology?: KBTerminology;
+    responsePatterns?: KBResponsePatterns;
+    conversationPatterns?: KBConversationPatterns;
+    edgeCases?: KBEdgeCases;
+    qualityIndicators?: KBQualityIndicators;
+    /** Evidence for the overall description */
+    descriptionEvidence?: ComponentEvidence$1;
+}
+interface CompositionRegistry {
+    manifests: KBManifest[];
+    slotMap: Map<string, SlotDefinition>;
+}
+type SlotSchemaShape = z.ZodRawShape;
+
+/**
+ * KB Metadata Types
+ *
+ * Type definitions for knowledge base metadata used throughout the framework.
+ */
+
+interface KBMeta {
+    id: string;
+    assistantName: string;
+    domain: string;
+    description: string;
+    inputEntities: string[];
+    outputEntities: string[];
+    capabilities: string[];
+    inputPrompts: Record<string, string>;
+    relevance?: KBRelevanceHints;
+    queryTemplate?: KBQueryTemplate;
+    inputRequirements: KBInputField[];
+    scope?: KBScopeDefinition;
+    slots?: SlotDefinition[];
+}
+
+/**
+ * Options for LLM generation
+ */
+interface LLMOptions {
+    /** Model identifier (e.g., 'gpt-4o-mini', 'gpt-4o') */
+    model: string;
+    /** Temperature for generation (0-1) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+}
+/**
+ * Result from text generation
+ */
+interface LLMTextResult {
+    text: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Result from structured object generation
+ */
+interface LLMObjectResult<T> {
+    object: T;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Result from streaming text generation
+ */
+interface LLMStreamResult {
+    /** The readable stream of text chunks */
+    stream: ReadableStream<Uint8Array>;
+    /** Promise that resolves to the full text when streaming completes */
+    textPromise: Promise<string>;
+    /** Promise that resolves to usage information when streaming completes */
+    usagePromise?: Promise<{
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    }>;
+}
+/**
+ * Interface for LLM providers (OpenAI, Anthropic, etc.)
+ *
+ * Implementations must provide methods for generating text, structured objects, and streaming.
+ */
+interface LLMProvider {
+    /** Provider name for logging/debugging */
+    readonly name: string;
+    /**
+     * Generate text from a prompt
+     *
+     * @param prompt - The prompt to send to the LLM
+     * @param options - Generation options (model, temperature, etc.)
+     * @returns Generated text and usage information
+     */
+    generateText(prompt: string, options: LLMOptions): Promise<LLMTextResult>;
+    /**
+     * Generate a structured object from a prompt using a Zod schema
+     *
+     * @param schema - Zod schema defining the expected output structure
+     * @param prompt - The prompt to send to the LLM
+     * @param options - Generation options (model, temperature, etc.)
+     * @returns Parsed object matching the schema and usage information
+     */
+    generateObject<T>(schema: z.ZodSchema<T>, prompt: string, options: LLMOptions): Promise<LLMObjectResult<T>>;
+    /**
+     * Stream text generation from a prompt
+     *
+     * @param prompt - The prompt to send to the LLM
+     * @param options - Generation options (model, temperature, etc.)
+     * @returns Stream result with readable stream and promises for full text/usage
+     */
+    streamText(prompt: string, options: LLMOptions): Promise<LLMStreamResult>;
+}
+/**
+ * A context snippet retrieved from a knowledge base
+ */
+interface KBSnippet {
+    /** Content of the snippet */
+    content: string;
+    /** Reference information for citations */
+    reference?: {
+        id?: string;
+        source?: string;
+        file?: {
+            name?: string;
+            signedUrl?: string;
+            signed_url?: string;
+            metadata?: Record<string, any>;
+        };
+        pages?: number[];
+    };
+    /** Label for citation (e.g., 'S1', 'S2') */
+    label?: string;
+    /** Short preview text */
+    preview?: string;
+    /** Human-friendly reference summary */
+    referenceSummary?: string;
+    /** MIME type of the source content */
+    contentType?: string;
+    /** Name of the source file */
+    fileName?: string;
+}
+/**
+ * Query options for knowledge base retrieval
+ */
+interface KBQueryOptions {
+    /** Number of top results to retrieve */
+    topK?: number;
+    /** Optional filter criteria */
+    filter?: Record<string, any>;
+}
+/**
+ * Result from a knowledge base query
+ */
+interface KBQueryResult {
+    /** Retrieved context snippets */
+    snippets: KBSnippet[];
+    /** Generated answer from the KB (if applicable) */
+    answer: string;
+}
+/**
+ * Metadata about a knowledge base
+ */
+interface KBMetadata {
+    /** Unique identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description of the KB's purpose */
+    description: string;
+    /** What the KB can do */
+    capabilities: string[];
+    /** Required input entities/slots */
+    inputEntities: string[];
+    /** Entities the KB can provide */
+    outputEntities: string[];
+}
+/**
+ * Interface for knowledge base providers (Pinecone, Elasticsearch, etc.)
+ *
+ * Implementations handle querying specific KB backends and returning context snippets.
+ */
+interface KBProvider {
+    /** Provider type for logging (e.g., 'pinecone') */
+    readonly type: string;
+    /**
+     * Query the knowledge base for relevant context
+     *
+     * @param kbId - Identifier of the specific KB to query
+     * @param query - The query string
+     * @param options - Query options (topK, filters)
+     * @returns Snippets and generated answer
+     */
+    query(kbId: string, query: string, options?: KBQueryOptions): Promise<KBQueryResult>;
+    /**
+     * Get metadata about a specific knowledge base
+     *
+     * @param kbId - Identifier of the KB
+     * @returns KB metadata or undefined if not found
+     */
+    getMetadata(kbId: string): KBMetadata | undefined;
+    /**
+     * List all available knowledge bases
+     *
+     * @returns Array of KB metadata
+     */
+    listKBs(): KBMetadata[];
+}
+/**
+ * Context for template rendering
+ */
+interface TemplateContext {
+    /** Slot values to interpolate */
+    slots: Partial<Slots>;
+    /** User's original utterance */
+    userUtterance: string;
+    /** Additional context variables */
+    [key: string]: any;
+}
+/**
+ * Interface for template engines (Mustache, Handlebars, etc.)
+ *
+ * Implementations render query templates with slot values and context.
+ */
+interface TemplateEngine {
+    /** Engine name for logging */
+    readonly name: string;
+    /**
+     * Render a template string with context
+     *
+     * @param template - Template string with placeholders
+     * @param context - Context containing slot values and other variables
+     * @returns Rendered string
+     */
+    render(template: string, context: TemplateContext): string;
+}
+/**
+ * Agent thinking/reasoning entry
+ */
+interface AgentThinking {
+    phase: 'disambiguation' | 'planning' | 'execution' | 'synthesis';
+    timestamp: string;
+    reasoning: string;
+    details?: any;
+}
+/**
+ * Interface for collecting execution traces
+ *
+ * Implementations handle recording trace steps and agent thinking for observability.
+ * This separates tracing concerns from business logic.
+ */
+interface TraceCollector {
+    /** Session ID for this trace */
+    readonly sessionId: string;
+    /**
+     * Start a new trace step
+     *
+     * @param step - The trace step to record
+     */
+    addStep(step: TraceStep): void;
+    /**
+     * Update the most recent trace step
+     *
+     * @param updates - Partial updates to apply to the step
+     */
+    updateLastStep(updates: Partial<TraceStep>): void;
+    /**
+     * Record agent thinking/reasoning
+     *
+     * @param thinking - The thinking entry to record
+     */
+    recordThinking(thinking: AgentThinking): void;
+    /**
+     * Get all collected trace steps
+     */
+    getSteps(): TraceStep[];
+    /**
+     * Get all recorded thinking entries
+     */
+    getThinking(): AgentThinking[];
+    /**
+     * Emit a trace step for real-time streaming
+     *
+     * @param step - The trace step to emit
+     */
+    emit(step: TraceStep): void;
+    /**
+     * Add a step and emit it in one call
+     *
+     * @param step - The trace step to add and emit
+     */
+    addAndEmit(step: TraceStep): void;
+}
+/**
+ * Interface for session-scoped logging
+ */
+interface Logger {
+    log(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, error?: Error, data?: any): void;
+    debug(message: string, data?: any): void;
+}
+/**
+ * Normalization rules for slot values
+ */
+type NormalizationRule = 'lowercase' | 'uppercase' | 'lower_snake' | 'none';
+/**
+ * Interface for normalizing slot values
+ */
+interface SlotNormalizer {
+    /**
+     * Normalize a slot value according to its rules
+     *
+     * @param slotName - Name of the slot
+     * @param value - Raw value to normalize
+     * @returns Normalized value
+     */
+    normalize(slotName: string, value: string | boolean): string;
+    /**
+     * Format a slot value for display
+     *
+     * @param slotName - Name of the slot
+     * @param value - Value to format
+     * @returns Formatted string
+     */
+    format(slotName: string, value: string | boolean | undefined): string;
+}
+/**
+ * Container for all framework providers and services
+ *
+ * This is passed to engines to provide access to all dependencies.
+ */
+interface FrameworkContext {
+    /** LLM provider for text/object generation */
+    llm: LLMProvider;
+    /** Knowledge base provider for context retrieval */
+    kb: KBProvider;
+    /** Template engine for query building */
+    template: TemplateEngine;
+    /** Logger for the current session */
+    logger: Logger;
+    /** Trace collector for observability */
+    trace: TraceCollector;
+    /** Slot normalizer */
+    normalizer: SlotNormalizer;
+    /** KB catalog (dynamic for SaaS, static fallback otherwise) */
+    kbCatalog?: KBMeta[];
+}
+
+/**
+ * Trace Adapter System
+ *
+ * Pluggable adapters for emitting trace events to different outputs.
+ * Implement the TraceAdapter interface to create custom trace UIs.
+ */
+
+/**
+ * TraceAdapter Interface
+ *
+ * Implement this interface to create custom trace outputs (e.g., custom UI, logging, analytics).
+ * Uses a single emit() method with a discriminated union for all event types.
+ *
+ * @example
+ * ```typescript
+ * class MyCustomTraceAdapter implements TraceAdapter {
+ *   emit(event: TraceEvent) {
+ *     switch (event.type) {
+ *       case 'step':
+ *         myUI.showStep(event.step);
+ *         break;
+ *       case 'trace_complete':
+ *         myAnalytics.track('agent_complete', event.trace);
+ *         break;
+ *       case 'follow_up':
+ *         myUI.showQuestions(event.questions);
+ *         break;
+ *       case 'session_id':
+ *         myLogger.setSessionId(event.sessionId);
+ *         break;
+ *     }
+ *   }
+ * }
+ * ```
+ */
+interface TraceAdapter {
+    /**
+     * Emit a trace event.
+     * Handle different event types by switching on event.type.
+     */
+    emit(event: TraceEvent): void | Promise<void>;
+}
+/**
+ * Data stream writer interface for Vercel AI SDK compatibility
+ */
+interface DataStreamWriter {
+    writeData(data: unknown): void;
+}
+/**
+ * SSE Trace Adapter
+ *
+ * Emits trace steps via Server-Sent Events using the existing logger infrastructure.
+ * This is the default adapter for the standard (non-streaming) app.
+ */
+declare class SSETraceAdapter implements TraceAdapter {
+    private readonly sessionId;
+    constructor(sessionId: string);
+    emit(event: TraceEvent): void;
+}
+/**
+ * Stream annotation for Vercel AI SDK data stream protocol
+ */
+interface StreamAnnotation$1 {
+    type: 'trace_step' | 'trace_complete' | 'follow_up' | 'session_id';
+    step?: unknown;
+    trace?: unknown;
+    questions?: string[];
+    sessionId?: string;
+}
+/**
+ * Vercel Data Stream Trace Adapter
+ *
+ * Emits trace steps as data stream annotations for Vercel AI SDK streaming responses.
+ * Use with createDataStreamResponse() from the 'ai' package.
+ */
+declare class VercelDataStreamAdapter implements TraceAdapter {
+    private dataStream;
+    /**
+     * Set the data stream to write to.
+     * Must be called before any trace methods.
+     */
+    setDataStream(dataStream: DataStreamWriter): void;
+    emit(event: TraceEvent): void;
+}
+/**
+ * Buffering Vercel Data Stream Trace Adapter
+ *
+ * Buffers trace events for progressive streaming. Events are stored in a buffer
+ * and can be flushed to a response stream on demand. This enables true progressive
+ * streaming where trace annotations are interleaved with text chunks.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new BufferingVercelDataStreamAdapter();
+ * const streamingResult = await runAgentStreaming({ message, traceAdapter: adapter });
+ * return toVercelAIStreamingResponse(streamingResult, adapter);
+ * ```
+ */
+declare class BufferingVercelDataStreamAdapter implements TraceAdapter {
+    private buffer;
+    private onFlush;
+    /**
+     * Set a callback to be invoked when annotations are ready to flush.
+     * Used internally by toVercelAIStreamingResponse.
+     */
+    setFlushCallback(callback: (annotations: StreamAnnotation$1[]) => void): void;
+    /**
+     * Get and clear all buffered annotations.
+     */
+    flush(): StreamAnnotation$1[];
+    /**
+     * Check if there are buffered annotations.
+     */
+    hasBufferedAnnotations(): boolean;
+    emit(event: TraceEvent): void;
+}
+/**
+ * No-Op Trace Adapter
+ *
+ * Does nothing with trace events. Useful for testing or when tracing is not needed.
+ */
+declare class NoOpTraceAdapter implements TraceAdapter {
+    emit(_event: TraceEvent): void;
+}
+/**
+ * Callback Trace Adapter
+ *
+ * Allows passing a callback function for trace events.
+ * Convenient for simple custom integrations without creating a full class.
+ */
+declare class CallbackTraceAdapter implements TraceAdapter {
+    private readonly callback;
+    constructor(callback: (event: TraceEvent) => void | Promise<void>);
+    emit(event: TraceEvent): void | Promise<void>;
+}
+/**
+ * Create an SSE trace adapter for a session
+ */
+declare function createSSETraceAdapter(sessionId: string): TraceAdapter;
+/**
+ * Create a Vercel data stream trace adapter
+ */
+declare function createVercelDataStreamAdapter(): VercelDataStreamAdapter;
+/**
+ * Create a buffering Vercel data stream trace adapter for progressive streaming
+ */
+declare function createBufferingVercelDataStreamAdapter(): BufferingVercelDataStreamAdapter;
+/**
+ * Create a no-op trace adapter
+ */
+declare function createNoOpTraceAdapter(): TraceAdapter;
+/**
+ * Create a callback-based trace adapter
+ */
+declare function createCallbackTraceAdapter(callback: (event: TraceEvent) => void | Promise<void>): TraceAdapter;
+
+/**
+ * Agent Types
+ *
+ * Unified types for the high-level agent API.
+ * These types simplify the response handling by providing a discriminated union
+ * for all possible agent outcomes.
+ */
+
+/**
+ * Citation reference from a KB snippet
+ */
+interface Citation {
+    /** Citation label (e.g., 'S1', 'S2') */
+    label: string;
+    /** KB that provided this citation */
+    kbId: string;
+    /** Human-readable summary of the reference */
+    referenceSummary: string;
+    /** Preview of the content */
+    preview?: string;
+    /** Full content */
+    content?: string;
+    /** Reference metadata including signed URLs */
+    reference?: {
+        id?: string;
+        file?: {
+            name?: string;
+            signedUrl?: string;
+            metadata?: Record<string, unknown>;
+        };
+    };
+    /** MIME type of the source content */
+    contentType?: string;
+    /** Name of the source file */
+    fileName?: string;
+}
+/**
+ * Outcome when the agent provides a complete answer
+ */
+interface AnswerOutcome {
+    type: 'answer';
+    /** The synthesized answer text */
+    answer: string;
+    /** Citations for the answer */
+    citations: Citation[];
+    /** Full execution trace */
+    trace: ExecutionTrace;
+}
+/**
+ * Outcome when the agent needs more information
+ */
+interface FollowUpOutcome {
+    type: 'follow_up';
+    /** The question to ask the user */
+    question: string;
+    /** The slot that needs to be filled */
+    slot: string;
+    /** Optional multi-choice options for the user to select from */
+    options?: MultiChoiceOption[];
+    /** Full execution trace */
+    trace: ExecutionTrace;
+}
+/**
+ * Outcome when the request is blocked
+ */
+interface BlockedOutcome {
+    type: 'blocked';
+    /** Reason why the request was blocked */
+    reason: string;
+    /** Full execution trace */
+    trace: ExecutionTrace;
+}
+/**
+ * Outcome when the query is outside the agent's scope
+ */
+interface OutOfScopeOutcome {
+    type: 'out_of_scope';
+    /** Redirect message for the user */
+    message: string;
+    /** Available capabilities the agent can help with */
+    capabilities: string[];
+    /** Full execution trace */
+    trace: ExecutionTrace;
+}
+/**
+ * All possible agent outcomes as a discriminated union.
+ * Use `outcome.type` to determine which outcome occurred.
+ *
+ * @example
+ * ```typescript
+ * const result = await runAgent({ message: 'Help with my toaster' });
+ *
+ * switch (result.outcome.type) {
+ *   case 'answer':
+ *     console.log(result.outcome.answer);
+ *     break;
+ *   case 'follow_up':
+ *     console.log('Need more info:', result.outcome.question);
+ *     break;
+ *   case 'blocked':
+ *     console.log('Cannot help:', result.outcome.reason);
+ *     break;
+ *   case 'out_of_scope':
+ *     console.log('Out of scope:', result.outcome.message);
+ *     break;
+ * }
+ * ```
+ */
+type AgentOutcome = AnswerOutcome | FollowUpOutcome | BlockedOutcome | OutOfScopeOutcome;
+/**
+ * Complete result from running the agent.
+ * Contains the outcome, updated context, and session information.
+ */
+interface AgentResult {
+    /** The outcome of the agent execution */
+    outcome: AgentOutcome;
+    /** Updated agent context for multi-turn conversations */
+    context: AgentContext;
+    /** Session ID for tracking the conversation */
+    sessionId: string;
+    /** The extracted intent from the user's message */
+    intent: Intent;
+}
+/**
+ * Options for running the agent
+ */
+interface RunAgentOptions {
+    /** The user's message */
+    message: string;
+    /** Optional session ID (generated if not provided) */
+    sessionId?: string;
+    /** Previous agent context for multi-turn conversations */
+    previousContext?: AgentContext;
+    /** Previous intent (alternative to previousContext) */
+    previousIntent?: Intent;
+    /** Full conversation history */
+    conversationHistory?: ConversationMessage[];
+    /** Custom trace adapter for observability */
+    traceAdapter?: TraceAdapter;
+    /**
+     * Dynamic agent configuration (for multi-tenant SaaS).
+     * If provided, overrides the static agent.config.json.
+     */
+    config?: AgentConfig;
+    /**
+     * Dynamic KB manifests (for multi-tenant SaaS).
+     * If provided, overrides manifests loaded from composition/manifests/.
+     */
+    manifests?: KBManifest[];
+}
+/**
+ * Options for running the agent with streaming
+ */
+interface RunAgentStreamingOptions extends RunAgentOptions {
+    /** Callback for each text chunk during streaming synthesis */
+    onChunk?: (chunk: string) => void;
+}
+/**
+ * Result from streaming agent execution
+ */
+interface StreamingAgentResult {
+    /** Readable stream of the answer text (only for 'answer' outcomes) */
+    stream: ReadableStream<string> | null;
+    /** Promise that resolves to the complete agent result */
+    result: Promise<AgentResult>;
+}
+
+/**
+ * Agent Runner
+ *
+ * High-level function that orchestrates the complete agent flow:
+ * 1. Context initialization
+ * 2. Disambiguation (understanding user intent)
+ * 3. Planning (determining which KBs to query)
+ * 4. Execution (querying KBs and synthesizing answer)
+ *
+ * This replaces the 300-500 lines of boilerplate in example apps.
+ */
+
+/**
+ * Run the agent with a user message.
+ *
+ * This is the main entry point for the high-level API. It handles:
+ * - Context initialization and restoration
+ * - Disambiguation (understanding intent)
+ * - Planning (selecting KBs)
+ * - Execution (querying KBs and synthesizing)
+ *
+ * @example
+ * ```typescript
+ * // Simple usage
+ * const result = await runAgent({ message: 'My toaster is broken' });
+ *
+ * // Multi-turn conversation
+ * const result2 = await runAgent({
+ *   message: 'It's a T100',
+ *   previousContext: result.context,
+ * });
+ *
+ * // With custom trace adapter
+ * const result3 = await runAgent({
+ *   message: 'Help me fix it',
+ *   traceAdapter: new MyCustomTraceAdapter(),
+ * });
+ * ```
+ */
+declare function runAgent(options: RunAgentOptions): Promise<AgentResult>;
+
+/**
+ * Streaming Agent Runner
+ *
+ * High-level function that orchestrates the complete agent flow with streaming synthesis:
+ * 1. Context initialization
+ * 2. Disambiguation (understanding user intent)
+ * 3. Planning (determining which KBs to query)
+ * 4. Execution with streaming synthesis
+ *
+ * Use this for Vercel AI SDK integrations that need streaming responses.
+ */
+
+declare function runAgentStreaming(options: RunAgentStreamingOptions): Promise<StreamingAgentResult>;
+
+/**
+ * Next.js Response Builder
+ *
+ * Converts AgentResult to Next.js API responses (NextResponse.json).
+ * Use this for standard (non-streaming) Next.js API routes.
+ */
+
+/**
+ * Convert an AgentResult to a ChatResponse object.
+ *
+ * This is the raw response body, which you can return with NextResponse.json()
+ * or use with any other framework.
+ *
+ * The response includes:
+ * - sessionId: For conversation tracking
+ * - outcome: The type of result ('answer', 'follow_up', 'blocked', 'out_of_scope')
+ * - answer/followUpQuestion: The response text
+ * - options: Multi-choice options for follow-up questions
+ * - citations: References from KB responses
+ * - context/intent: For multi-turn conversations
+ * - trace: Full execution trace (optional)
+ */
+declare function toChatResponse(result: AgentResult): ChatResponse;
+/**
+ * Convert an AgentResult to a Next.js Response.
+ *
+ * This returns a standard Response object that works with Next.js API routes.
+ * For frameworks that need NextResponse, you can import NextResponse and use:
+ * `NextResponse.json(toChatResponse(result))`
+ *
+ * @example
+ * ```typescript
+ * // In a Next.js API route
+ * import { runAgent, toNextResponse } from '@/lib';
+ *
+ * export async function POST(request: NextRequest) {
+ *   const { message } = await request.json();
+ *   const result = await runAgent({ message });
+ *   return toNextResponse(result);
+ * }
+ * ```
+ */
+declare function toNextResponse(result: AgentResult): Response;
+/**
+ * Convert an error to a Next.js error response.
+ */
+declare function toNextErrorResponse(error: Error | string, sessionId?: string): Response;
+
+/**
+ * Citation Utilities
+ *
+ * Shared utilities for extracting and processing citations from execution traces.
+ * These utilities are used by both the example app and SaaS backend.
+ */
+
+/**
+ * Extract citations from an execution trace.
+ *
+ * This extracts all contextSnippets from trace steps and converts them
+ * to ChatCitation format. Uses global sequential labeling (S1, S2, S3...)
+ * to ensure unique labels across all KBs.
+ *
+ * @param trace - The execution trace to extract citations from
+ * @returns Array of ChatCitation objects
+ *
+ * @example
+ * ```typescript
+ * const citations = extractCitationsFromTrace(result.outcome.trace);
+ * ```
+ */
+declare function extractCitationsFromTrace(trace?: ExecutionTrace): ChatCitation[];
+/**
+ * Filter citations to only those that are actually referenced in the answer text.
+ *
+ * Looks for citation markers like [S1], [S2], etc. in the text and returns
+ * only the citations that match those labels.
+ *
+ * @param citations - All available citations
+ * @param answerText - The answer text that may contain citation markers
+ * @returns Filtered array of citations that are referenced in the text
+ *
+ * @example
+ * ```typescript
+ * const allCitations = extractCitationsFromTrace(trace);
+ * const usedCitations = filterCitedOnly(allCitations, response.answer);
+ * ```
+ */
+declare function filterCitedOnly<T extends {
+    label: string;
+}>(citations: T[], answerText: string): T[];
+/**
+ * Convert a full Citation (from agent types) to a ChatCitation (for API responses).
+ *
+ * @param citation - The full Citation object
+ * @returns A ChatCitation suitable for API responses
+ */
+declare function toChatCitation(citation: Citation): ChatCitation;
+/**
+ * Convert an array of full Citations to ChatCitations.
+ *
+ * @param citations - Array of full Citation objects
+ * @returns Array of ChatCitation objects
+ */
+declare function toChatCitations(citations: Citation[]): ChatCitation[];
+
+/**
+ * Streaming Utilities for Vercel AI SDK
+ *
+ * Provides utilities for streaming chat responses with trace step integration.
+ * These types represent the wire format for Vercel AI SDK data streams.
+ *
+ * Note: The wire format uses 'trace_step' while the internal TraceEvent uses 'step'.
+ * The adapter handles the mapping between internal events and wire format.
+ */
+
+/**
+ * Wire format type for Vercel AI SDK data stream annotations.
+ * These match the format expected by the Vercel AI SDK client.
+ */
+type StreamAnnotation = {
+    type: 'trace_step';
+    step: TraceStep;
+} | {
+    type: 'trace_complete';
+    trace: ExecutionTrace;
+} | {
+    type: 'session_id';
+    sessionId: string;
+} | {
+    type: 'follow_up';
+    questions: string[];
+};
+/**
+ * Convert a TraceEvent to wire format StreamAnnotation
+ */
+declare function traceEventToAnnotation(event: TraceEvent): StreamAnnotation;
+/**
+ * Create a trace step annotation to append to a StreamData instance
+ */
+declare function createTraceStepAnnotation(step: TraceStep): StreamAnnotation;
+/**
+ * Create a trace complete annotation to append to a StreamData instance
+ */
+declare function createTraceCompleteAnnotation(trace: ExecutionTrace): StreamAnnotation;
+/**
+ * Create a session ID annotation to append to a StreamData instance
+ */
+declare function createSessionIdAnnotation(sessionId: string): StreamAnnotation;
+/**
+ * Parse stream data annotation from the stream
+ */
+declare function parseStreamAnnotation(data: unknown): StreamAnnotation | null;
+
+/**
+ * Vercel AI SDK Response Builder
+ *
+ * Converts AgentResult and streaming results to Vercel AI SDK responses.
+ * Use this for streaming responses with the `ai` package.
+ */
+
+/**
+ * Options for creating a Vercel AI streaming response
+ */
+interface VercelAIResponseOptions {
+    /** Include trace data in the stream annotations */
+    includeTrace?: boolean;
+    /** Custom error message handler */
+    onError?: (error: Error) => string;
+}
+/**
+ * Create a Vercel AI SDK compatible streaming response.
+ *
+ * This creates a Response with a ReadableStream that includes:
+ * - Data stream annotations for trace steps
+ * - The streamed text content
+ * - Trace complete annotation at the end
+ *
+ * @example
+ * ```typescript
+ * import { runAgentStreaming, toVercelAIResponse } from '@/lib';
+ *
+ * export async function POST(request: NextRequest) {
+ *   const { message } = await request.json();
+ *   const streamingResult = await runAgentStreaming({ message });
+ *   return toVercelAIResponse(streamingResult);
+ * }
+ * ```
+ */
+declare function toVercelAIResponse(streamingResult: StreamingAgentResult, options?: VercelAIResponseOptions): Promise<Response>;
+/**
+ * Create a simple Vercel AI response for non-streaming results.
+ *
+ * Use this when you have an AgentResult from runAgent() (non-streaming)
+ * but want to return it in a Vercel AI compatible format.
+ */
+declare function toVercelAISimpleResponse(result: AgentResult, options?: VercelAIResponseOptions): Response;
+/**
+ * Utility to extract the text answer from an AgentResult
+ */
+declare function getAnswerText(result: AgentResult): string;
+/**
+ * Create a truly streaming Vercel AI SDK response.
+ *
+ * Unlike `toVercelAIResponse()`, this function does NOT await the full result.
+ * Instead, it interleaves trace annotations with text chunks as they become available,
+ * providing a truly progressive streaming experience.
+ *
+ * IMPORTANT: The `traceAdapter` passed to `runAgentStreaming()` must be a
+ * `BufferingVercelDataStreamAdapter` for progressive trace delivery.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   runAgentStreaming,
+ *   toVercelAIStreamingResponse,
+ *   createBufferingVercelDataStreamAdapter,
+ * } from '@/lib';
+ *
+ * export async function POST(request: NextRequest) {
+ *   const { message } = await request.json();
+ *   const traceAdapter = createBufferingVercelDataStreamAdapter();
+ *   const streamingResult = await runAgentStreaming({ message, traceAdapter });
+ *   return toVercelAIStreamingResponse(streamingResult, traceAdapter);
+ * }
+ * ```
+ */
+declare function toVercelAIStreamingResponse(streamingResult: StreamingAgentResult, traceAdapter: BufferingVercelDataStreamAdapter, options?: VercelAIResponseOptions): Response;
+
+/**
+ * Trace Collector Implementation
+ *
+ * Implementation of the TraceCollector interface for collecting execution traces.
+ * Separates tracing concerns from business logic.
+ */
+
+/**
+ * Step counter for generating unique step IDs.
+ *
+ * Tracks counts per step type (e.g., disambiguation, planning, slot_filling, synthesis)
+ * and generates incrementing IDs like `disambiguation_1`, `disambiguation_2`, etc.
+ *
+ * Can be initialized from AgentContext.stepCounts to persist across conversation turns.
+ */
+declare class StepCounter {
+    private counts;
+    /**
+     * Create a new StepCounter, optionally initializing from existing counts.
+     *
+     * @param initialCounts - Optional initial counts (e.g., from AgentContext.stepCounts)
+     */
+    constructor(initialCounts?: Record<string, number>);
+    /**
+     * Create a StepCounter from an AgentContext.
+     * Use this to continue counting from where a previous request left off.
+     */
+    static fromContext(context: {
+        stepCounts?: Record<string, number>;
+    }): StepCounter;
+    /**
+     * Get the next step ID for a given step type.
+     * Increments the counter and returns the new ID.
+     *
+     * @param stepType - The type of step (e.g., 'disambiguation', 'planning')
+     * @returns A unique step ID like 'disambiguation_1'
+     */
+    next(stepType: string): string;
+    /**
+     * Get the current count for a step type (without incrementing).
+     */
+    current(stepType: string): number;
+    /**
+     * Reset the counter for a specific step type or all step types.
+     */
+    reset(stepType?: string): void;
+    /**
+     * Get all counts as a plain object.
+     * Use this to persist the counter state to AgentContext.stepCounts.
+     */
+    toObject(): Record<string, number>;
+    /**
+     * Update an AgentContext with the current step counts.
+     * Call this before returning the context to the client.
+     */
+    syncToContext(context: {
+        stepCounts?: Record<string, number>;
+    }): void;
+}
+/**
+ * Create a new trace collector instance
+ */
+declare function createTraceCollector(sessionId: string): TraceCollector;
+
+/**
+ * Middleware Module
+ *
+ * Composable middleware functions for building custom agent pipelines.
+ * Use these when you need more control than the high-level runAgent() provides.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createPipelineContext,
+ *   withDisambiguation,
+ *   withPlanning,
+ *   withExecution,
+ *   compose,
+ * } from '@/lib/middleware';
+ *
+ * // Create a custom pipeline
+ * const myPipeline = compose(
+ *   withDisambiguation(),
+ *   withPlanning(),
+ *   withExecution(),
+ * );
+ *
+ * // Run it
+ * const context = createPipelineContext({ message: 'Help me' });
+ * const result = await myPipeline(context);
+ * ```
+ */
+
+/**
+ * Pipeline context passed through middleware functions
+ */
+interface PipelineContext {
+    message: string;
+    sessionId: string;
+    conversationHistory?: ConversationMessage[];
+    agentContext: AgentContext;
+    stepCounter: StepCounter;
+    traceSteps: TraceStep[];
+    frameworkContext: FrameworkContext;
+    traceAdapter: TraceAdapter;
+    intent?: Intent;
+    disambiguationAction?: {
+        type: 'ASK_SLOT' | 'CALL_KB' | 'PARTIAL_PROCEED' | 'BLOCKED' | 'OUT_OF_SCOPE';
+        [key: string]: unknown;
+    };
+    relevantKBs?: KBMeta[];
+    plan?: Plan;
+    stepResults?: StepResult[];
+    answer?: string;
+    shouldStop?: boolean;
+    stopReason?: 'follow_up' | 'blocked' | 'out_of_scope';
+}
+/**
+ * Middleware function type
+ */
+type Middleware = (context: PipelineContext, next: () => Promise<PipelineContext>) => Promise<PipelineContext>;
+/**
+ * Create an initial pipeline context
+ */
+interface CreatePipelineContextOptions {
+    message: string;
+    sessionId?: string;
+    previousContext?: AgentContext;
+    previousIntent?: Intent;
+    conversationHistory?: ConversationMessage[];
+    traceAdapter?: TraceAdapter;
+}
+declare function createPipelineContext(options: CreatePipelineContextOptions): PipelineContext;
+/**
+ * Compose multiple middleware functions into a single function
+ */
+declare function compose(...middlewares: Middleware[]): (context: PipelineContext) => Promise<PipelineContext>;
+/**
+ * Disambiguation middleware
+ *
+ * Extracts intent and determines routing.
+ * Sets: intent, disambiguationAction, relevantKBs
+ * May set: shouldStop, stopReason
+ */
+declare function withDisambiguation(): Middleware;
+/**
+ * Planning middleware
+ *
+ * Creates an execution plan based on intent and relevant KBs.
+ * Requires: intent, relevantKBs
+ * Sets: plan
+ */
+declare function withPlanning(): Middleware;
+/**
+ * Execution middleware
+ *
+ * Executes the plan (KB calls + synthesis).
+ * Requires: intent, plan
+ * Sets: stepResults, answer
+ */
+declare function withExecution(): Middleware;
+/**
+ * Build the final execution trace from pipeline context
+ */
+declare function buildTrace(context: PipelineContext): ExecutionTrace;
+/**
+ * Logging middleware - logs each phase
+ */
+declare function withLogging(): Middleware;
+/**
+ * Error handling middleware - catches and logs errors
+ */
+declare function withErrorHandling(onError?: (error: Error, context: PipelineContext) => void): Middleware;
+
+/**
+ * Pure state reducer for disambiguation.
+ * No LLM calls - just deterministic state transitions based on facts.
+ */
+
+/** Details about why a KB was selected during routing */
+interface KBRoutingReason {
+    kbId: string;
+    selectedBy: 'llm_hint' | 'slot_trigger' | 'input_match' | 'fallback';
+    trigger?: string;
+}
+/** Details about the routing decision for tracing */
+interface RoutingDecision {
+    kbHintsReceived: string[];
+    kbsFromHints: string[];
+    slotTriggersMatched: Array<{
+        kbId: string;
+        trigger: string;
+    }>;
+    kbsFromSlotTriggers: string[];
+    kbsFromFallback: string[];
+    finalKBs: string[];
+    routingReasons: KBRoutingReason[];
+}
+
+/**
+ * Disambiguation orchestrator.
+ * Thin layer that coordinates between:
+ * - LLM extractor (facts)
+ * - State reducer (decisions)
+ * - Question generator (phrasing)
+ */
+
+/**
+ * Main disambiguation function.
+ * Orchestrates the three-layer architecture:
+ * 1. Extract facts from LLM (handles all reasoning including yes/no, confirmations, etc.)
+ * 2. Run state reducer to get action
+ * 3. Generate question if needed
+ *
+ * @param utterance - The user's current message
+ * @param kbCatalog - Available knowledge bases
+ * @param context - Current agent context (optional)
+ * @param conversationHistory - Full conversation history (optional)
+ * @param frameworkContext - Framework context with LLM provider
+ */
+declare function disambiguate(utterance: string, kbCatalog: KBMeta[], context: AgentContext | undefined, conversationHistory: ConversationMessage[] | undefined, frameworkContext: FrameworkContext): Promise<DisambiguationResult>;
+
+/**
+ * Creates an execution plan to answer a user's query using available knowledge bases.
+ *
+ * This is the main planning function that uses an LLM to intelligently select and sequence
+ * knowledge base calls to answer the user's question. The planner:
+ * 1. Analyzes the user's intent and goals
+ * 2. Selects relevant knowledge bases from the catalog
+ * 3. Determines the optimal sequence of KB calls
+ * 4. Adds synthesis steps when multiple KBs are needed
+ * 5. Provides reasoning and confidence scores
+ *
+ * The function respects disambiguation results: if `relevantKBs` is provided (from the
+ * disambiguation/reducer phase), it only considers those KBs, ensuring the plan aligns
+ * with the user's current goals rather than the original query.
+ *
+ * @param intent - The user's intent containing their query, goals, available slots, and missing information
+ * @param kbCatalog - Full catalog of available knowledge bases with their metadata
+ * @param context - Optional agent context containing conversation history, collected information, and previous thinking
+ * @param relevantKBs - Optional filtered list of KBs from disambiguation. If provided, only these KBs will be considered.
+ *                      This allows the planner to adapt to evolving user goals during multi-turn conversations.
+ *
+ * @returns A promise resolving to:
+ *   - plan: The execution plan with steps, reasoning, and confidence
+ *   - updatedContext: Updated agent context with planning reasoning added to agentThinking
+ *
+ * @example
+ * ```typescript
+ * const { plan, updatedContext } = await plan(
+ *   { userUtterance: "How do I resolve this issue?", goals: ["help"], ... },
+ *   kbCatalog,
+ *   existingContext,
+ *   relevantKBs // Only consider specific KBs if disambiguation narrowed it down
+ * );
+ * ```
+ */
+declare function plan(intent: Intent, kbCatalog: KBMeta[], context?: AgentContext, relevantKBs?: KBMeta[], frameworkContext?: FrameworkContext): Promise<{
+    plan: Plan;
+    updatedContext: AgentContext;
+}>;
+
+/**
+ * Core Executor Module
+ *
+ * Main entry point for plan execution using the framework context.
+ * This is the refactored version that uses dependency injection.
+ */
+
+/**
+ * Execute a plan using the framework context
+ *
+ * This is the main entry point for plan execution with dependency injection.
+ *
+ * @param intent - User intent containing the original utterance and goals
+ * @param plan - The execution plan with steps to run
+ * @param context - Optional agent context with prior conversation state
+ * @param frameworkContext - Framework context with all providers
+ * @returns Object containing the generated answer and execution trace
+ */
+declare function executePlanWithContext(intent: Intent, plan: Plan, context: AgentContext | undefined, frameworkContext: FrameworkContext): Promise<{
+    answer: string;
+    trace: ExecutionTrace;
+}>;
+
+/**
+ * KB Runner Module
+ *
+ * Handles execution of KB call steps in the plan.
+ */
+
+/**
+ * Result from running a single KB call step
+ */
+interface KBCallResult {
+    stepResult: StepResult;
+    kbRetrieval?: KBRetrieval;
+    success: boolean;
+}
+/**
+ * Execute a single KB call step
+ *
+ * @param step - The KB call step to execute
+ * @param intent - User intent containing the original utterance and goals
+ * @param previousKBCalls - Array of previously executed KB calls for context
+ * @param frameworkContext - Framework context with all providers
+ * @returns Result object containing stepResult, optional kbRetrieval, and success status
+ */
+declare function executeKBCallStep(step: PlanStepKBCall, intent: Intent, previousKBCalls: Array<{
+    kbId: string;
+    stepId: string;
+    success: boolean;
+}>, frameworkContext: FrameworkContext): Promise<KBCallResult>;
+
+/**
+ * Synthesis Module
+ *
+ * Handles the synthesis of final answers from KB responses.
+ */
+
+/**
+ * Result from synthesis step
+ */
+interface SynthesisResult {
+    answer: string;
+    stepResult: StepResult;
+}
+/**
+ * Result from streaming synthesis step
+ */
+interface StreamingSynthesisResult {
+    stream: ReadableStream<Uint8Array>;
+    stepResult: StepResult;
+}
+/**
+ * Synthesize a final answer from KB responses
+ *
+ * This is the main synthesis function that orchestrates the answer generation process.
+ * It uses helper functions to:
+ * 1. Collect and organize KB responses
+ * 2. Gather and label context snippets for citation
+ * 3. Check for missing/insufficient information
+ * 4. Generate the final synthesized answer
+ * 5. Process citations and format the response
+ */
+declare function synthesizeAnswer(synthesisStep: PlanStepSynthesis, intent: Intent, stepResults: StepResult[], frameworkContext: FrameworkContext): Promise<SynthesisResult>;
+/**
+ * Synthesize a final answer from KB responses with streaming support
+ *
+ * This version uses streamText for progressive text generation.
+ */
+declare function synthesizeAnswerStreaming(synthesisStep: PlanStepSynthesis, intent: Intent, stepResults: StepResult[], frameworkContext: FrameworkContext): Promise<StreamingSynthesisResult>;
+/**
+ * Handle the case when all KB calls failed
+ */
+declare function handleAllKBsFailed(stepResults: StepResult[], kbCount: number, frameworkContext: FrameworkContext): SynthesisResult;
+
+/**
+ * Snippet Formatter Module
+ *
+ * Handles formatting and summarizing snippet references for display
+ */
+/**
+ * Formats a snippet reference into a human-readable string
+ * Extracts metadata like title, name, category, row_id, and source
+ * Produces concise titles suitable for citation display chips
+ *
+ * @param snippet - Snippet object with reference metadata
+ * @returns Formatted string like "FAQ 106 - DrySwift 600" or "Warranty 28 - Toaster"
+ */
+declare function summarizeSnippetReference(snippet: any): string;
+
+/**
+ * Plan Executor Mediator
+ *
+ * Orchestrates plan creation, execution, and adaptive modification.
+ * This module breaks the potential circular dependency between planner and executor
+ * by acting as a mediator layer.
+ *
+ * Architecture:
+ * ```
+ *   Agent Runner
+ *        │
+ *        ▼
+ *   Plan Executor (this module)
+ *        │
+ *   ┌────┴────┐
+ *   ▼         ▼
+ * Planner  Executor
+ * ```
+ *
+ * The planner and executor don't import each other directly - all coordination
+ * happens through this module. This enables:
+ * - Adaptive planning (modifying plans based on execution results)
+ * - Clean dependency graph with no cycles
+ * - Single point of control for plan lifecycle
+ */
+
+/**
+ * Options for adaptive plan execution
+ */
+interface AdaptiveExecutionOptions {
+    /** Whether to attempt plan modification on failure (default: true) */
+    enableAdaptivePlanning?: boolean;
+    /** Maximum number of plan modification attempts (default: 1) */
+    maxModificationAttempts?: number;
+}
+/**
+ * Execute a plan with adaptive modification support
+ *
+ * This function provides intelligent plan execution with the ability to
+ * modify the plan mid-execution if things don't go as expected.
+ *
+ * Adaptive planning scenarios:
+ * 1. All KB calls fail → Try alternative KBs if available
+ * 2. Partial information → Adjust synthesis to work with what we have
+ * 3. Unexpected results → Re-route to different KBs
+ *
+ * @param intent - User intent containing the original utterance and goals
+ * @param plan - Initial execution plan
+ * @param context - Agent context with conversation state
+ * @param frameworkContext - Framework context with all providers
+ * @param options - Optional adaptive execution settings
+ * @returns Object containing the generated answer and execution trace
+ *
+ * @example
+ * ```typescript
+ * const { answer, trace } = await executePlanAdaptively(
+ *   intent,
+ *   plan,
+ *   context,
+ *   frameworkContext,
+ *   { enableAdaptivePlanning: true }
+ * );
+ * ```
+ */
+declare function executePlanAdaptively(intent: Intent, plan: Plan, context: AgentContext | undefined, frameworkContext: FrameworkContext, options?: AdaptiveExecutionOptions): Promise<{
+    answer: string;
+    trace: ExecutionTrace;
+}>;
+/**
+ * Create and execute a plan in one step
+ *
+ * Convenience function that combines plan creation and execution.
+ * Useful for simple cases where you don't need to inspect the plan
+ * before execution.
+ *
+ * @param intent - User intent
+ * @param kbCatalog - Available knowledge bases
+ * @param context - Agent context
+ * @param frameworkContext - Framework context
+ * @returns Execution result with answer and trace
+ */
+declare function planAndExecute(intent: Intent, kbCatalog: any[], context: AgentContext | undefined, frameworkContext: FrameworkContext): Promise<{
+    answer: string;
+    trace: ExecutionTrace;
+    plan: Plan;
+}>;
+
+/**
+ * Agent Context Factory
+ *
+ * Creates and manages the conversation state context for agents.
+ */
+
+/**
+ * Initialize a new AgentContext
+ *
+ * @param userUtterance - The user's initial message or current utterance
+ * @param previousContext - Optional previous context to merge with (for multi-turn conversations)
+ * @returns A new or merged AgentContext
+ */
+declare function createAgentContext(userUtterance: string, previousContext?: AgentContext): AgentContext;
+
+/**
+ * KB Catalog Module
+ *
+ * Manages the catalog of available knowledge bases by converting
+ * manifest definitions into runtime KBMeta objects.
+ */
+
+/** Catalog of all available knowledge bases (static, from files) */
+declare const kbCatalog: KBMeta[];
+/**
+ * Build a KB catalog from manifests (for dynamic/SaaS use)
+ *
+ * @param manifests - Array of KB manifests
+ * @param config - Optional config to use for slot definitions
+ * @returns Array of KBMeta objects
+ */
+declare function buildKBCatalog(manifests: KBManifest[], config?: AgentConfig): KBMeta[];
+/**
+ * Get metadata for a specific knowledge base from the static catalog
+ *
+ * @param kbId - The unique identifier of the knowledge base
+ * @returns KBMeta object if found, undefined otherwise
+ */
+declare function getKBMeta(kbId: string): KBMeta | undefined;
+/**
+ * Get metadata for a specific knowledge base from a dynamic catalog
+ *
+ * @param kbId - The unique identifier of the knowledge base
+ * @param catalog - The catalog to search in
+ * @returns KBMeta object if found, undefined otherwise
+ */
+declare function getKBMetaFromCatalog(kbId: string, catalog: KBMeta[]): KBMeta | undefined;
+
+declare function loadCompositionRegistry(): CompositionRegistry;
+declare function getSlotDefinitions(): SlotDefinition[];
+declare function getSlotDefinition$1(name: string): SlotDefinition | undefined;
+declare function buildSlotsSchema$1(): z.ZodObject<SlotSchemaShape>;
+declare function getKBManifests(): KBManifest[];
+declare function getKBManifestById(kbId: string): KBManifest | undefined;
+/**
+ * Get all unique capabilities across all knowledge base manifests.
+ * Used for generating redirect messages that show what the agent can help with.
+ */
+declare function getAllCapabilities(): string[];
+/**
+ * Get all unique domains across all knowledge base manifests.
+ * Used for generating redirect messages.
+ */
+declare function getAllDomains(): string[];
+
+/**
+ * Load and validate the agent configuration from agent.config.json
+ */
+declare function loadConfig(configPath?: string): AgentConfig;
+/**
+ * Get the current config (loads if not already loaded)
+ * If a runtime config is set, returns that instead.
+ */
+declare function getConfig(): AgentConfig;
+/**
+ * Set a runtime config override (for SaaS multi-tenant use).
+ * This allows dynamic config without a static agent.config.json file.
+ *
+ * @param config - The config to use, or null to clear
+ */
+declare function setRuntimeConfig(config: AgentConfig | null): void;
+/**
+ * Get the current runtime config (if set)
+ */
+declare function getRuntimeConfig(): AgentConfig | null;
+/**
+ * Build a Zod schema for slots based on config
+ */
+declare function buildSlotsSchema(config?: AgentConfig): z.ZodObject<any>;
+/**
+ * Get slot definition by name
+ */
+declare function getSlotDefinition(slotName: string, config?: AgentConfig): SlotDefinition$1 | undefined;
+/**
+ * Format a slot value based on its type
+ */
+declare function formatSlotValue(slotName: string, value: string | boolean | undefined, config?: AgentConfig): string | undefined;
+/**
+ * Get the LLM model for a specific purpose
+ */
+declare function getModel(purpose: 'planning' | 'extraction' | 'synthesis' | 'questionGeneration', config?: AgentConfig): string;
+/**
+ * Format citation label based on config
+ */
+declare function formatCitationLabel(index: number, config?: AgentConfig): string;
+/**
+ * Clear cached config (useful for testing)
+ *
+ * @param resetBasePath - If true, also resets the base path to default (cwd)
+ * @param clearRuntime - If true, also clears the runtime config override
+ */
+declare function clearConfigCache(resetBasePath?: boolean, clearRuntime?: boolean): void;
+/**
+ * Get prompt template with substitutions
+ */
+declare function getPrompt(key: 'plannerSystemRole' | 'synthesisSystemRole' | 'planningInstructions' | 'synthesisInstructions', config?: AgentConfig): string;
+/**
+ * Get fallback message
+ */
+declare function getMessage(key: 'allKBsFailed' | 'noRelevantInfo' | 'synthesisError', config?: AgentConfig): string;
+/**
+ * Get session configuration
+ */
+declare function getSessionConfig(config?: AgentConfig): {
+    maxLogsPerSession: number;
+    maxTraceStepsPerSession: number;
+};
+
+/**
+ * Framework Context Factory
+ *
+ * Creates and manages the dependency injection container for the framework.
+ */
+
+/**
+ * Options for creating a framework context
+ */
+interface ContextOptions {
+    sessionId: string;
+}
+/**
+ * Create a framework context with all providers initialized
+ *
+ * This is the main entry point for dependency injection.
+ * All engines and components should receive this context.
+ */
+declare function createFrameworkContext(options: ContextOptions): FrameworkContext;
+
+/**
+ * Default OpenAI chat model IDs and env-based resolution.
+ *
+ * Agent runtime continues to use `agent.config.json` (`llm.models`) via `getModel()`.
+ * These helpers apply to introspection, CLI helpers, and other code paths that
+ * do not load an agent config.
+ *
+ * Env precedence for introspection:
+ * 1. Explicit `ProgressiveIntrospectionConfig.llmModel` / API base field
+ * 2. `KBS_INTROSPECTION_MODEL`
+ * 3. `KBS_DEFAULT_OPENAI_MODEL`
+ * 4. `OPENAI_DEFAULT_CHAT_MODEL`
+ * 5. {@link DEFAULT_OPENAI_CHAT_MODEL_ID}
+ */
+declare const DEFAULT_OPENAI_CHAT_MODEL_ID: "gpt-4o-mini";
+/**
+ * Model id for progressive introspection and manifest generation (OpenAI).
+ */
+declare function resolveIntrospectionOpenAiModelId(explicit?: string | null): string;
+/**
+ * Generic default chat model when no agent config applies (CLI tools, eval grader, etc.).
+ */
+declare function resolveDefaultOpenAiChatModelId(explicit?: string | null): string;
+/** Stronger model for structured JSON / complex generation (`KBS_STRONG_OPENAI_MODEL`, default gpt-4o). */
+declare function resolveStrongOpenAiModelId(explicit?: string | null): string;
+
+/**
+ * Usage Tracker
+ *
+ * Tracks token usage and dollar cost across all LLM calls during introspection.
+ * Supports both OpenAI (generateObject) and Pinecone (assistant.chat) providers.
+ */
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+}
+interface UsageEntry {
+    phase: string;
+    step: string;
+    model: string;
+    provider: 'openai' | 'pinecone';
+    usage: TokenUsage;
+    cost: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    timestamp: number;
+}
+interface PhaseUsage {
+    tokens: TokenUsage;
+    cost: number;
+    calls: number;
+}
+interface UsageSummary {
+    totalTokens: TokenUsage;
+    totalCost: number;
+    byPhase: Record<string, PhaseUsage>;
+    byProvider: Record<string, PhaseUsage>;
+    entries: UsageEntry[];
+}
+interface UsageRecordInput {
+    phase?: string;
+    step: string;
+    model: string;
+    provider: 'openai' | 'pinecone';
+    usage: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens?: number;
+    };
+}
+declare class UsageTracker {
+    private entries;
+    private onUpdate?;
+    private _currentPhase;
+    constructor(onUpdate?: (summary: UsageSummary) => void);
+    /**
+     * Set the current phase. Subsequent record() calls will use this phase
+     * unless an explicit phase is provided.
+     */
+    setPhase(phase: string): void;
+    record(input: UsageRecordInput): void;
+    getSummary(): UsageSummary;
+}
+
+/**
+ * Progressive Introspection Types
+ *
+ * Type definitions for the progressive introspection engine that generates
+ * KB manifests by iteratively querying Pinecone assistants.
+ */
+
+/**
+ * Schema extraction result for L2 level
+ */
+interface SchemaExtraction {
+    intent: string;
+    slots: Array<{
+        name: string;
+        type: string;
+        required: boolean;
+        validation_rule?: string;
+        enumValues?: string[];
+    }>;
+    is_deterministic: boolean;
+    reasoning?: string;
+}
+/**
+ * Configuration for the progressive introspection process
+ */
+interface ProgressiveIntrospectionConfig {
+    /** Maximum depth to drill down into categories/entities (default: 3) */
+    maxDepth: number;
+    /** Maximum expansions per discovered entity (default: 5) */
+    maxBranchFactor: number;
+    /** Minimum new entities needed to continue drilling (default: 2) */
+    expansionThreshold: number;
+    /** Total question budget cap (default: 50) */
+    maxTotalQuestions: number;
+    /** Maximum retries per question when getting generic responses (default: 3) */
+    maxRetries: number;
+    /** Minimum confidence threshold to accept a response (default: 0.4) */
+    minConfidenceThreshold: number;
+    /**
+     * OpenAI model id for introspection LLM calls.
+     * Override via config, or env: `KBS_INTROSPECTION_MODEL`, `KBS_DEFAULT_OPENAI_MODEL`, `OPENAI_DEFAULT_CHAT_MODEL`.
+     */
+    llmModel: string;
+}
+/**
+ * Default configuration for progressive introspection
+ */
+declare const DEFAULT_PROGRESSIVE_CONFIG: ProgressiveIntrospectionConfig;
+/**
+ * Objective types for question formulation
+ */
+type QuestionObjective = 'seed_discovery' | 'expand_category' | 'drill_entity' | 'find_relationships' | 'validate_scope' | 'gather_examples';
+/**
+ * Context provided to the question formulator
+ */
+interface QuestionFormulationContext {
+    /** What we're trying to discover */
+    objective: QuestionObjective;
+    /** The specific category/entity we're exploring (if applicable) */
+    target?: string;
+    /** Parent context for hierarchical drilling */
+    parentContext?: string;
+    /** Current depth in the exploration tree */
+    depth: number;
+    /** What we already know (to avoid redundant questions) */
+    knownEntities: string[];
+    knownCategories: string[];
+    /** Recent conversation history for context */
+    recentQA: {
+        question: string;
+        answer: string;
+    }[];
+    /** Questions that got generic/evasive responses */
+    failedApproaches: string[];
+    /** Domain hint if available */
+    domain?: string;
+}
+/**
+ * Expected response type from a question
+ */
+type ExpectedResponseType = 'list' | 'explanation' | 'examples' | 'boundaries' | 'relationships';
+/**
+ * Output from the question formulator
+ */
+interface FormulatedQuestion {
+    /** The actual question to ask */
+    question: string;
+    /** Why this question should work */
+    rationale: string;
+    /** What kind of response we expect */
+    expectedResponseType: ExpectedResponseType;
+    /** Alternative questions if this one fails */
+    fallbackQuestions: string[];
+}
+/**
+ * Classification of a response from the validator
+ */
+type ResponseClassification = 'substantive' | 'generic' | 'evasive' | 'off_topic' | 'repetitive';
+/**
+ * Suggested strategy when a response isn't valid
+ */
+type RetryStrategy = 'rephrase' | 'simplify' | 'anchor_with_examples' | 'try_different_angle' | 'skip';
+/**
+ * Output from the response validator
+ */
+interface ResponseValidation {
+    /** Whether the response is useful */
+    isValid: boolean;
+    /** Classification of the response */
+    classification: ResponseClassification;
+    /** Confidence in the classification (0-1) */
+    confidence: number;
+    /** What's wrong if not valid */
+    issue?: string;
+    /** Suggested approach for retry */
+    suggestedRetryStrategy?: RetryStrategy;
+    /** New entities extracted from the response */
+    extractedEntities: string[];
+    /** New categories extracted from the response */
+    extractedCategories: string[];
+    /** Summary of what we learned */
+    newInformation?: string;
+}
+/**
+ * A task in the expansion queue
+ */
+interface ExpansionTask {
+    type: 'category' | 'entity' | 'relationship' | 'examples';
+    target: string;
+    depth: number;
+    parentContext?: string;
+    context: {
+        question: string;
+        answer: string;
+    }[];
+}
+/**
+ * Category discovered during introspection
+ */
+interface DiscoveredCategory {
+    name: string;
+    depth: number;
+    parent?: string;
+    children: string[];
+    entities: string[];
+    explored: boolean;
+}
+/**
+ * Entity discovered during introspection
+ */
+interface DiscoveredEntity {
+    name: string;
+    category?: string;
+    depth: number;
+    relatedEntities: string[];
+    explored: boolean;
+}
+/**
+ * Relationship between entities
+ */
+interface DiscoveredRelationship {
+    from: string;
+    to: string;
+    type: string;
+}
+/**
+ * A single conversation exchange with validation
+ */
+interface ConversationEntry {
+    question: string;
+    answer: string;
+    validation?: ResponseValidation;
+}
+/**
+ * Document snippet from Context API
+ */
+interface DocumentSnippet {
+    content: string;
+    score: number;
+    sourceFile: string;
+}
+/**
+ * Evidence supporting a manifest component decision.
+ * Contains the LLM's reasoning plus citations to source material.
+ */
+interface ComponentEvidence {
+    /** LLM explanation of why this component exists */
+    reasoning: string;
+    /** Actual KB content (document snippets) that informed this decision */
+    documentSnippets: Array<{
+        content: string;
+        sourceFile: string;
+        score: number;
+    }>;
+    /** Q&A exchanges that surfaced the evidence during introspection */
+    qaExchanges: Array<{
+        questionNumber: number;
+        question: string;
+        answerExcerpt: string;
+    }>;
+}
+/**
+ * State of the progressive introspection process
+ */
+interface IntrospectionState {
+    /** Discovered categories with their exploration status */
+    categories: Map<string, DiscoveredCategory>;
+    /** Discovered entities */
+    entities: Map<string, DiscoveredEntity>;
+    /** Discovered relationships between entities */
+    relationships: DiscoveredRelationship[];
+    /** Full conversation history */
+    conversationHistory: ConversationEntry[];
+    /** Queue of tasks to process */
+    expansionQueue: ExpansionTask[];
+    /** Total questions asked */
+    questionsAsked: number;
+    /** Capabilities discovered (with optional evidence) */
+    capabilities: Array<{
+        text: string;
+        evidence?: ComponentEvidence;
+    }>;
+    /** Scope information */
+    scopeInfo: {
+        inScope: string[];
+        outOfScope: string[];
+    };
+    /** Example questions discovered */
+    exampleQuestions: string[];
+    /** Source files discovered from context API */
+    sourceFiles: Set<string>;
+    /** Raw snippets from documents (actual content) */
+    documentSnippets: DocumentSnippet[];
+    /** Extracted schemas from L2 discovery (intents with slots) */
+    extractedSchemas?: SchemaExtraction[];
+}
+/**
+ * Result from asking a question and validating the response
+ */
+interface AskResult {
+    success: boolean;
+    question: string;
+    response?: string;
+    validation?: ResponseValidation;
+    attempts: number;
+    failedApproaches: string[];
+    /** Raw snippets from context API (actual document content) */
+    snippets?: Array<{
+        content: string;
+        score: number;
+        reference: unknown;
+    }>;
+    /** Source files discovered */
+    sourceFiles?: string[];
+}
+/**
+ * Callbacks for reporting introspection progress.
+ * Used by CLI and SaaS to provide their own presentation layer.
+ */
+interface IntrospectionCallbacks {
+    /** Called when a new phase starts */
+    onPhaseStart?: (phase: 'seed_discovery' | 'entity_expansion' | 'relationship_discovery' | 'abstraction_refinement' | 'enum_extraction' | 'manifest_generation', assistantName: string) => void;
+    /** Called with phase progress updates */
+    onPhaseProgress?: (phase: string, message: string) => void;
+    /** Called when a question is being asked */
+    onQuestion?: (questionNum: number, totalBudget: number, question: string, objective: QuestionObjective) => void;
+    /** Called when an answer is received */
+    onAnswer?: (questionNum: number, answer: string) => void;
+    /** Called when a response is validated */
+    onValidation?: (questionNum: number, validation: ResponseValidation) => void;
+    /** Called when entities/categories are discovered */
+    onDiscovery?: (categories: number, entities: number, sourceFiles: number) => void;
+    /** Called when a step in manifest generation completes */
+    onManifestStep?: (step: number, totalSteps: number, description: string) => void;
+    /** Called on error */
+    onError?: (assistantName: string, error: string) => void;
+    /** Called when introspection completes for an assistant */
+    onComplete?: (assistantName: string, manifest: KBManifest) => void;
+    /** Called when LLM usage is recorded (fires after each LLM call) */
+    onUsageUpdate?: (summary: UsageSummary) => void;
+}
+/**
+ * Options for running progressive introspection
+ */
+interface ProgressiveIntrospectionOptions {
+    /** Pinecone assistant name to introspect */
+    assistantName: string;
+    /** KB ID for the generated manifest (defaults to assistant name) */
+    kbId?: string;
+    /** Domain hint (will be inferred if not provided) */
+    domain?: string;
+    /** Progressive introspection configuration */
+    config?: Partial<ProgressiveIntrospectionConfig>;
+    /** Callbacks for progress reporting */
+    callbacks?: IntrospectionCallbacks;
+    /** Pinecone API key (uses env var if not provided) */
+    pineconeApiKey?: string;
+    /** OpenAI API key (uses env var if not provided) */
+    openaiApiKey?: string;
+}
+/**
+ * Result from progressive introspection
+ */
+interface ProgressiveIntrospectionResult {
+    /** Generated manifest */
+    manifest: KBManifest;
+    /** Introspection state with all discovered information */
+    state: IntrospectionState;
+    /** Summary statistics */
+    stats: {
+        questionsAsked: number;
+        categoriesDiscovered: number;
+        entitiesDiscovered: number;
+        sourceFilesFound: number;
+        documentSnippetsCaptured: number;
+        /** LLM token usage and cost breakdown */
+        usage?: UsageSummary;
+    };
+}
+
+/**
+ * Progressive Introspection Engine
+ *
+ * Core orchestrator for the 4-phase progressive introspection process:
+ * 1. Seed Discovery - Initial exploration of KB content
+ * 2. Entity Expansion - Drill down into discovered categories/entities
+ * 3. Relationship Discovery - Find connections between entities
+ * 4. Manifest Inference - Extract intents, slots, capabilities from conversation
+ */
+
+/**
+ * Initialize a fresh introspection state
+ */
+declare function initializeState(): IntrospectionState;
+/**
+ * Run progressive introspection on a Pinecone assistant
+ */
+declare function progressiveIntrospect(options: ProgressiveIntrospectionOptions): Promise<ProgressiveIntrospectionResult>;
+
+/**
+ * Question Formulator
+ *
+ * LLM-assisted question generation for progressive introspection.
+ * Generates targeted questions to discover KB content and capabilities.
+ */
+
+/**
+ * Generate a targeted question using LLM assistance
+ */
+declare function formulateQuestion(context: QuestionFormulationContext, tracker?: UsageTracker, llmModel?: string): Promise<FormulatedQuestion>;
+/**
+ * Seed objectives for initial discovery phase
+ */
+declare const SEED_OBJECTIVES: QuestionObjective[];
+
+/**
+ * Response Validator
+ *
+ * LLM-assisted validation of assistant responses to detect generic,
+ * evasive, or unhelpful responses during introspection.
+ */
+
+/**
+ * Validate a response from the assistant
+ */
+declare function validateResponse(question: string, response: string, expectedType: ExpectedResponseType, target: string | undefined, knownInformation: string[], tracker?: UsageTracker, llmModel?: string): Promise<ResponseValidation>;
+
+/**
+ * Manifest Generator
+ *
+ * Converts introspection state into a KB manifest using multi-step
+ * LLM-assisted generation for each manifest component.
+ */
+
+/**
+ * Generate a complete manifest from introspection state
+ */
+declare function generateManifestFromState(base: {
+    kbId: string;
+    assistantName: string;
+    domain?: string;
+    llmModel?: string;
+}, state: IntrospectionState, callbacks?: IntrospectionCallbacks, tracker?: UsageTracker): Promise<KBManifest>;
+
+/**
+ * Multi-KB Orchestration Framework
+ *
+ * Main entry point for the framework. Import from here for the public API.
+ *
+ * ## High-Level API (Recommended)
+ *
+ * Use `runAgent()` or `runAgentStreaming()` for simple integrations:
+ *
+ * @example
+ * ```ts
+ * import { runAgent, toNextResponse } from '@/lib';
+ *
+ * const result = await runAgent({ message: 'Help me with my toaster' });
+ * return toNextResponse(result);
+ * ```
+ *
+ * ## Low-Level API (Advanced)
+ *
+ * For custom pipelines, use the individual orchestration functions:
+ *
+ * @example
+ * ```ts
+ * import {
+ *   disambiguate,
+ *   plan,
+ *   executePlanWithContext,
+ *   kbCatalog,
+ * } from '@/lib';
+ * ```
+ */
+/** Agent runners - single function to run the complete agent pipeline */
+
+/** Smoke-test constant to verify local linking is working. */
+declare const KAT_LINK_CHECK: "@kat/core is locally linked!";
+
+export { type StreamAnnotation as AdapterStreamAnnotation, type AdaptiveExecutionOptions, type AgentConfig, AgentConfigSchema, AgentContext, type AgentOutcome, type AgentResult, type AgentThinking, type AnswerOutcome, type AskResult, type BehaviorConfig, BehaviorConfigSchema, type BlockedOutcome, BufferingVercelDataStreamAdapter, CallbackTraceAdapter, ChatCitation, ChatResponse, type Citation, type CitationsConfig, CitationsConfigSchema, type ComponentEvidence, type CompositionRegistry, type SlotDefinition$1 as ConfigSlotDefinition, type ContextOptions, type ConversationEntry, ConversationMessage, type CreatePipelineContextOptions, DEFAULT_OPENAI_CHAT_MODEL_ID, DEFAULT_PROGRESSIVE_CONFIG, type DataStreamWriter, DisambiguationResult, type DiscoveredCategory, type DiscoveredEntity, type DiscoveredRelationship, type DocumentSnippet, type DynamicSlots, ExecutionTrace, type ExpansionTask, type ExpectedResponseType, type FollowUpOutcome, type FormulatedQuestion, type FrameworkContext, type GoalExamples, GoalExamplesSchema, Intent, type IntrospectionCallbacks, type IntrospectionState, KAT_LINK_CHECK, type KBCapability, type KBConversationPatterns, type KBEdgeCases, type KBGoal, type KBInputField, type KBManifest, type KBMeta, type KBMetadata, type KBProvider, type KBProviderConfig, KBProviderConfigSchema, type KBQualityIndicators, type KBQueryOptions, type KBQueryResult, type KBQueryTemplate, type KBRelevanceHints, type KBResponsePatterns, KBRetrieval, type KBRoutingReason, type KBScopeDefinition, type KBSnippet, type KBTerminology, type LLMConfig, LLMConfigSchema, type LLMObjectResult, type LLMOptions, type LLMProvider, type LLMStreamResult, type LLMTextResult, type Logger, type MessagesConfig, MessagesConfigSchema, type Middleware, MultiChoiceOption, NoOpTraceAdapter, type NormalizationRule, type OutOfScopeOutcome, type PhaseUsage, type PipelineContext, Plan, PlanStepKBCall, PlanStepSynthesis, type ProgressiveIntrospectionConfig, type ProgressiveIntrospectionOptions, type ProgressiveIntrospectionResult, type PromptsConfig, PromptsConfigSchema, type ProvidersConfig, ProvidersConfigSchema, type QueryTemplateSection, type QuestionFormulationContext, type QuestionObjective, type ResponseClassification, type ResponseValidation, type RetryStrategy, type RoutingDecision, type RunAgentOptions, type RunAgentStreamingOptions, SEED_OBJECTIVES, SSETraceAdapter, type SessionConfig, SessionConfigSchema, type SlotDefinition, SlotDefinitionSchema, type SlotDependency, type SlotExtractionBehavior, type SlotNormalization, type SlotNormalizer, type SlotSchemaShape, type SlotValidation, type SlotValuePrimitive, Slots, StepCounter, StepResult, type StreamAnnotation, type StreamingAgentResult, type StreamingSynthesisResult, type SynthesisResult, type TemplateContext, type TemplateEngine, type TokenUsage, type TraceAdapter, type TraceCollector, TraceEvent, TraceStep, type UsageEntry, type UsageRecordInput, type UsageSummary, UsageTracker, type VercelAIResponseOptions, VercelDataStreamAdapter, buildKBCatalog, buildSlotsSchema, buildSlotsSchema$1 as buildSlotsSchemaFromRegistry, buildTrace, clearConfigCache, compose, createAgentContext, createBufferingVercelDataStreamAdapter, createCallbackTraceAdapter, createFrameworkContext, createNoOpTraceAdapter, createPipelineContext, createSSETraceAdapter, createSessionIdAnnotation, createTraceCollector, createTraceCompleteAnnotation, createTraceStepAnnotation, createVercelDataStreamAdapter, disambiguate, executeKBCallStep, executePlanAdaptively, executePlanWithContext, extractCitationsFromTrace, filterCitedOnly, formatCitationLabel, formatSlotValue, formulateQuestion, generateManifestFromState, getAllCapabilities, getAllDomains, getAnswerText, getConfig, getKBManifestById, getKBManifests, getKBMeta, getKBMetaFromCatalog, getMessage, getModel, getPrompt, getRuntimeConfig, getSessionConfig, getSlotDefinition, getSlotDefinition$1 as getSlotDefinitionFromRegistry, getSlotDefinitions, handleAllKBsFailed, initializeState, kbCatalog, loadCompositionRegistry, loadConfig, parseStreamAnnotation, plan, planAndExecute, progressiveIntrospect, resolveDefaultOpenAiChatModelId, resolveIntrospectionOpenAiModelId, resolveStrongOpenAiModelId, runAgent, runAgentStreaming, setRuntimeConfig, summarizeSnippetReference, synthesizeAnswer, synthesizeAnswerStreaming, toChatCitation, toChatCitations, toChatResponse, toNextErrorResponse, toNextResponse, toVercelAIResponse, toVercelAISimpleResponse, toVercelAIStreamingResponse, traceEventToAnnotation, validateResponse, withDisambiguation, withErrorHandling, withExecution, withLogging, withPlanning };