@kat-ai/sdk 0.1.0

package/dist/client.d.mts

@@ -0,0 +1,45 @@
+export { E as ExecutionTrace, a as LogEntry, L as LogLevel, T as TraceStep } from './core-pLiFHTBe.mjs';
+
+/**
+ * Client-safe exports for browser/client-side usage
+ *
+ * This module provides types and minimal runtime utilities without any
+ * Node.js dependencies, making it safe to import in client components
+ * (e.g., Next.js 'use client', React components, browser scripts).
+ *
+ * For server-side code, import from '@kat/core' instead.
+ */
+
+type StreamAnnotation = {
+    type: 'trace_step';
+    step: any;
+} | {
+    type: 'trace_complete';
+    trace: any;
+} | {
+    type: 'session_id';
+    sessionId: string;
+} | {
+    type: 'follow_up';
+    questions: string[];
+};
+type TraceEvent = {
+    type: 'step';
+    step: any;
+} | {
+    type: 'trace_complete';
+    trace: any;
+} | {
+    type: 'session_id';
+    sessionId: string;
+} | {
+    type: 'follow_up';
+    questions: string[];
+};
+/**
+ * Parse stream data annotation from the stream
+ * This is a pure function with no external dependencies
+ */
+declare function parseStreamAnnotation(data: unknown): StreamAnnotation | null;
+
+export { type StreamAnnotation, type TraceEvent, parseStreamAnnotation };

package/dist/client.d.ts

@@ -0,0 +1,45 @@
+export { E as ExecutionTrace, a as LogEntry, L as LogLevel, T as TraceStep } from './core-pLiFHTBe.js';
+
+/**
+ * Client-safe exports for browser/client-side usage
+ *
+ * This module provides types and minimal runtime utilities without any
+ * Node.js dependencies, making it safe to import in client components
+ * (e.g., Next.js 'use client', React components, browser scripts).
+ *
+ * For server-side code, import from '@kat/core' instead.
+ */
+
+type StreamAnnotation = {
+    type: 'trace_step';
+    step: any;
+} | {
+    type: 'trace_complete';
+    trace: any;
+} | {
+    type: 'session_id';
+    sessionId: string;
+} | {
+    type: 'follow_up';
+    questions: string[];
+};
+type TraceEvent = {
+    type: 'step';
+    step: any;
+} | {
+    type: 'trace_complete';
+    trace: any;
+} | {
+    type: 'session_id';
+    sessionId: string;
+} | {
+    type: 'follow_up';
+    questions: string[];
+};
+/**
+ * Parse stream data annotation from the stream
+ * This is a pure function with no external dependencies
+ */
+declare function parseStreamAnnotation(data: unknown): StreamAnnotation | null;
+
+export { type StreamAnnotation, type TraceEvent, parseStreamAnnotation };

package/dist/client.js

@@ -0,0 +1,26 @@
+'use strict';
+
+// src/client.ts
+function parseStreamAnnotation(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const obj = data;
+  if (obj.type === "trace_step" && obj.step) {
+    return { type: "trace_step", step: obj.step };
+  }
+  if (obj.type === "trace_complete" && obj.trace) {
+    return { type: "trace_complete", trace: obj.trace };
+  }
+  if (obj.type === "session_id" && typeof obj.sessionId === "string") {
+    return { type: "session_id", sessionId: obj.sessionId };
+  }
+  if (obj.type === "follow_up" && Array.isArray(obj.questions)) {
+    return { type: "follow_up", questions: obj.questions };
+  }
+  return null;
+}
+
+exports.parseStreamAnnotation = parseStreamAnnotation;
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"names":[],"mappings":";;;AAgCO,SAAS,sBAAsB,IAAA,EAAwC;AAC1E,EAAA,IAAI,CAAC,IAAA,IAAQ,OAAO,IAAA,KAAS,QAAA,EAAU;AACnC,IAAA,OAAO,IAAA;AAAA,EACX;AAEA,EAAA,MAAM,GAAA,GAAM,IAAA;AAEZ,EAAA,IAAI,GAAA,CAAI,IAAA,KAAS,YAAA,IAAgB,GAAA,CAAI,IAAA,EAAM;AACvC,IAAA,OAAO,EAAE,IAAA,EAAM,YAAA,EAAc,IAAA,EAAM,IAAI,IAAA,EAAK;AAAA,EAChD;AAEA,EAAA,IAAI,GAAA,CAAI,IAAA,KAAS,gBAAA,IAAoB,GAAA,CAAI,KAAA,EAAO;AAC5C,IAAA,OAAO,EAAE,IAAA,EAAM,gBAAA,EAAkB,KAAA,EAAO,IAAI,KAAA,EAAM;AAAA,EACtD;AAEA,EAAA,IAAI,IAAI,IAAA,KAAS,YAAA,IAAgB,OAAO,GAAA,CAAI,cAAc,QAAA,EAAU;AAChE,IAAA,OAAO,EAAE,IAAA,EAAM,YAAA,EAAc,SAAA,EAAW,IAAI,SAAA,EAAU;AAAA,EAC1D;AAEA,EAAA,IAAI,IAAI,IAAA,KAAS,WAAA,IAAe,MAAM,OAAA,CAAQ,GAAA,CAAI,SAAS,CAAA,EAAG;AAC1D,IAAA,OAAO,EAAE,IAAA,EAAM,WAAA,EAAa,SAAA,EAAW,IAAI,SAAA,EAAsB;AAAA,EACrE;AAEA,EAAA,OAAO,IAAA;AACX","file":"client.js","sourcesContent":["/**\n * Client-safe exports for browser/client-side usage\n * \n * This module provides types and minimal runtime utilities without any\n * Node.js dependencies, making it safe to import in client components\n * (e.g., Next.js 'use client', React components, browser scripts).\n * \n * For server-side code, import from '@kat/core' instead.\n */\n\n// Re-export types only - these are pure types with no runtime code\nexport type { LogLevel, LogEntry } from './logger';\nexport type { TraceStep, ExecutionTrace } from './types/core';\n\n// StreamAnnotation type - wire format for Vercel AI SDK\nexport type StreamAnnotation =\n    | { type: 'trace_step'; step: any }\n    | { type: 'trace_complete'; trace: any }\n    | { type: 'session_id'; sessionId: string }\n    | { type: 'follow_up'; questions: string[] };\n\n// TraceEvent type - internal event format\nexport type TraceEvent =\n    | { type: 'step'; step: any }\n    | { type: 'trace_complete'; trace: any }\n    | { type: 'session_id'; sessionId: string }\n    | { type: 'follow_up'; questions: string[] };\n\n/**\n * Parse stream data annotation from the stream\n * This is a pure function with no external dependencies\n */\nexport function parseStreamAnnotation(data: unknown): StreamAnnotation | null {\n    if (!data || typeof data !== 'object') {\n        return null;\n    }\n\n    const obj = data as Record<string, unknown>;\n\n    if (obj.type === 'trace_step' && obj.step) {\n        return { type: 'trace_step', step: obj.step };\n    }\n\n    if (obj.type === 'trace_complete' && obj.trace) {\n        return { type: 'trace_complete', trace: obj.trace };\n    }\n\n    if (obj.type === 'session_id' && typeof obj.sessionId === 'string') {\n        return { type: 'session_id', sessionId: obj.sessionId };\n    }\n\n    if (obj.type === 'follow_up' && Array.isArray(obj.questions)) {\n        return { type: 'follow_up', questions: obj.questions as string[] };\n    }\n\n    return null;\n}\n"]}

package/dist/client.mjs

@@ -0,0 +1,24 @@
+// src/client.ts
+function parseStreamAnnotation(data) {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+  const obj = data;
+  if (obj.type === "trace_step" && obj.step) {
+    return { type: "trace_step", step: obj.step };
+  }
+  if (obj.type === "trace_complete" && obj.trace) {
+    return { type: "trace_complete", trace: obj.trace };
+  }
+  if (obj.type === "session_id" && typeof obj.sessionId === "string") {
+    return { type: "session_id", sessionId: obj.sessionId };
+  }
+  if (obj.type === "follow_up" && Array.isArray(obj.questions)) {
+    return { type: "follow_up", questions: obj.questions };
+  }
+  return null;
+}
+
+export { parseStreamAnnotation };
+//# sourceMappingURL=client.mjs.map
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client.ts"],"names":[],"mappings":";AAgCO,SAAS,sBAAsB,IAAA,EAAwC;AAC1E,EAAA,IAAI,CAAC,IAAA,IAAQ,OAAO,IAAA,KAAS,QAAA,EAAU;AACnC,IAAA,OAAO,IAAA;AAAA,EACX;AAEA,EAAA,MAAM,GAAA,GAAM,IAAA;AAEZ,EAAA,IAAI,GAAA,CAAI,IAAA,KAAS,YAAA,IAAgB,GAAA,CAAI,IAAA,EAAM;AACvC,IAAA,OAAO,EAAE,IAAA,EAAM,YAAA,EAAc,IAAA,EAAM,IAAI,IAAA,EAAK;AAAA,EAChD;AAEA,EAAA,IAAI,GAAA,CAAI,IAAA,KAAS,gBAAA,IAAoB,GAAA,CAAI,KAAA,EAAO;AAC5C,IAAA,OAAO,EAAE,IAAA,EAAM,gBAAA,EAAkB,KAAA,EAAO,IAAI,KAAA,EAAM;AAAA,EACtD;AAEA,EAAA,IAAI,IAAI,IAAA,KAAS,YAAA,IAAgB,OAAO,GAAA,CAAI,cAAc,QAAA,EAAU;AAChE,IAAA,OAAO,EAAE,IAAA,EAAM,YAAA,EAAc,SAAA,EAAW,IAAI,SAAA,EAAU;AAAA,EAC1D;AAEA,EAAA,IAAI,IAAI,IAAA,KAAS,WAAA,IAAe,MAAM,OAAA,CAAQ,GAAA,CAAI,SAAS,CAAA,EAAG;AAC1D,IAAA,OAAO,EAAE,IAAA,EAAM,WAAA,EAAa,SAAA,EAAW,IAAI,SAAA,EAAsB;AAAA,EACrE;AAEA,EAAA,OAAO,IAAA;AACX","file":"client.mjs","sourcesContent":["/**\n * Client-safe exports for browser/client-side usage\n * \n * This module provides types and minimal runtime utilities without any\n * Node.js dependencies, making it safe to import in client components\n * (e.g., Next.js 'use client', React components, browser scripts).\n * \n * For server-side code, import from '@kat/core' instead.\n */\n\n// Re-export types only - these are pure types with no runtime code\nexport type { LogLevel, LogEntry } from './logger';\nexport type { TraceStep, ExecutionTrace } from './types/core';\n\n// StreamAnnotation type - wire format for Vercel AI SDK\nexport type StreamAnnotation =\n    | { type: 'trace_step'; step: any }\n    | { type: 'trace_complete'; trace: any }\n    | { type: 'session_id'; sessionId: string }\n    | { type: 'follow_up'; questions: string[] };\n\n// TraceEvent type - internal event format\nexport type TraceEvent =\n    | { type: 'step'; step: any }\n    | { type: 'trace_complete'; trace: any }\n    | { type: 'session_id'; sessionId: string }\n    | { type: 'follow_up'; questions: string[] };\n\n/**\n * Parse stream data annotation from the stream\n * This is a pure function with no external dependencies\n */\nexport function parseStreamAnnotation(data: unknown): StreamAnnotation | null {\n    if (!data || typeof data !== 'object') {\n        return null;\n    }\n\n    const obj = data as Record<string, unknown>;\n\n    if (obj.type === 'trace_step' && obj.step) {\n        return { type: 'trace_step', step: obj.step };\n    }\n\n    if (obj.type === 'trace_complete' && obj.trace) {\n        return { type: 'trace_complete', trace: obj.trace };\n    }\n\n    if (obj.type === 'session_id' && typeof obj.sessionId === 'string') {\n        return { type: 'session_id', sessionId: obj.sessionId };\n    }\n\n    if (obj.type === 'follow_up' && Array.isArray(obj.questions)) {\n        return { type: 'follow_up', questions: obj.questions as string[] };\n    }\n\n    return null;\n}\n"]}

package/dist/core-pLiFHTBe.d.mts

@@ -0,0 +1,406 @@
+/**
+ * Logger Module
+ *
+ * Utility for capturing and streaming logs via SSE (Server-Sent Events).
+ * Provides session-scoped logging and trace step streaming.
+ */
+type LogLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
+interface LogEntry {
+    id: string;
+    sessionId: string;
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    data?: any;
+    stack?: string;
+}
+/**
+ * Subscribe to log entries for a specific session
+ *
+ * @param sessionId - The session identifier to subscribe to
+ * @param callback - Function called when a log entry is emitted
+ * @returns Unsubscribe function to stop receiving logs
+ */
+declare function subscribeToLogs(sessionId: string, callback: (log: LogEntry) => void): () => void;
+/**
+ * Get all stored logs for a session
+ *
+ * @param sessionId - The session identifier
+ * @returns Array of log entries for the session
+ */
+declare function getSessionLogs(sessionId: string): LogEntry[];
+/**
+ * Clear all logs and trace steps for a session
+ *
+ * @param sessionId - The session identifier
+ */
+declare function clearSessionLogs(sessionId: string): void;
+/**
+ * Subscribe to trace steps for a session
+ *
+ * @param sessionId - The session identifier to subscribe to
+ * @param callback - Function called when a trace step is emitted
+ * @returns Unsubscribe function to stop receiving trace steps
+ */
+declare function subscribeToTraceSteps(sessionId: string, callback: (traceStep: any) => void): () => void;
+/**
+ * Emit a trace step for a session
+ *
+ * @param sessionId - The session identifier
+ * @param traceStep - The trace step object to emit
+ */
+declare function emitTraceStep(sessionId: string, traceStep: any): void;
+/**
+ * Create a logger instance for a specific session
+ *
+ * @param sessionId - The session identifier
+ * @returns Logger object with log, info, warn, error, and debug methods
+ */
+declare function createSessionLogger(sessionId: string): {
+    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;
+};
+
+/**
+ * Core Types
+ *
+ * Core type definitions for the multi-KB orchestration framework.
+ */
+/**
+ * Dynamic slots interface - actual slot names come from agent.config.json
+ * This is a generic interface that accepts any slot name defined in config
+ */
+interface Slots {
+    [slotName: string]: string | boolean | undefined;
+}
+interface Intent {
+    intentId: string;
+    userUtterance: string;
+    slots: Slots;
+    goals: string[];
+    missingSlots?: string[];
+    clarificationNeeded?: boolean;
+    clarificationQuestion?: string;
+}
+type PlanStepType = 'kb_call' | 'llm_synthesis';
+interface PlanStepKBCall {
+    id: string;
+    type: 'kb_call';
+    kbId: string;
+    inputs: Partial<Slots>;
+    expectedOutputs: string[];
+}
+interface PlanStepSynthesis {
+    id: string;
+    type: 'llm_synthesis';
+    fromSteps: string[];
+}
+type PlanStep = PlanStepKBCall | PlanStepSynthesis;
+interface Plan {
+    planId: string;
+    steps: PlanStep[];
+    reasoning?: string;
+    confidence?: number;
+}
+type TraceStepType = 'disambiguation' | 'slot_filling' | 'planning' | 'kb_call' | 'synthesis';
+interface TraceStep {
+    stepId: string;
+    stepType: TraceStepType;
+    timestamp: string;
+    description: string;
+    thought?: string;
+    understanding?: string;
+    learned?: string;
+    conclusion?: string;
+    details?: {
+        extractedIntent?: Intent;
+        relevantKBs?: string[];
+        missingSlots?: string[];
+        followUpQuestions?: string[];
+        selectedKBs?: Array<{
+            kbId: string;
+            reason: string;
+        }>;
+        kbId?: string;
+        kbName?: string;
+        query?: string;
+        inputs?: Partial<Slots>;
+        sourceSteps?: string[];
+        error?: string;
+        [key: string]: any;
+    };
+}
+interface StepResult {
+    stepId: string;
+    kbId?: string;
+    requestPayload?: any;
+    responsePayload?: any;
+    contextSnippets?: any[];
+    inputs?: Partial<Slots>;
+    error?: string;
+}
+interface KBRetrieval {
+    kbId: string;
+    kbName: string;
+    stepId: string;
+    query: string;
+    inputs: Partial<Slots>;
+    retrievedInformation: {
+        answer: string;
+        contextSnippets?: Array<{
+            label: string;
+            content: string;
+            referenceSummary: string;
+        }>;
+    };
+    timestamp: string;
+}
+interface AgentContext {
+    userObjective: string;
+    pendingQuestion?: PendingQuestion;
+    missingInformation: {
+        slots: string[];
+        unobtainableSlots: string[];
+        descriptions: Record<string, string>;
+        questionHistory?: Array<{
+            slot: string;
+            question: string;
+            timestamp: string;
+            answered: boolean;
+        }>;
+    };
+    collectedInformation: {
+        slots: Partial<Slots>;
+        collectionHistory: Array<{
+            timestamp: string;
+            slot: string;
+            value: any;
+            source: 'initial_extraction' | 'user_response' | 'merged';
+        }>;
+    };
+    kbRetrievals: KBRetrieval[];
+    agentThinking: Array<{
+        phase: 'disambiguation' | 'planning' | 'execution' | 'synthesis';
+        timestamp: string;
+        reasoning: string;
+        details?: any;
+    }>;
+    stepCounts?: Record<string, number>;
+}
+interface ExecutionTrace {
+    sessionId: string;
+    intent: Intent;
+    plan: Plan;
+    stepResults: StepResult[];
+    traceSteps: TraceStep[];
+    context: AgentContext;
+}
+/** Pending question for form-filling flow */
+interface PendingQuestion {
+    slot: string;
+    question: string;
+    askedAt: string;
+    attempts: number;
+    options?: MultiChoiceOption[];
+}
+/** Multi-choice option for disambiguation questions */
+interface MultiChoiceOption {
+    /** Unique identifier for the option */
+    id: string;
+    /** Display label for the option */
+    label: string;
+    /** Optional description providing more context */
+    description?: string;
+}
+/** Disambiguation actions - explicit decisions from the policy engine */
+type DisambiguationAction = {
+    type: 'ASK_SLOT';
+    slot: string;
+    question: string;
+    options?: MultiChoiceOption[];
+} | {
+    type: 'CALL_KB';
+    kbIds: string[];
+    slots: Partial<Slots>;
+} | {
+    type: 'PARTIAL_PROCEED';
+    kbIds: string[];
+    slots: Partial<Slots>;
+    missingSlots: string[];
+} | {
+    type: 'BLOCKED';
+    reason: string;
+} | {
+    type: 'OUT_OF_SCOPE';
+    redirectMessage: string;
+    availableCapabilities: string[];
+};
+/** Details about why a KB was selected during routing */
+interface KBRoutingReason {
+    kbId: string;
+    selectedBy: 'llm_hint' | 'slot_trigger' | 'input_match' | 'fallback';
+    trigger?: string;
+}
+/** Detailed routing decision for tracing */
+interface RoutingDecision {
+    kbHintsReceived: string[];
+    kbsFromHints: string[];
+    slotTriggersMatched: Array<{
+        kbId: string;
+        trigger: string;
+    }>;
+    kbsFromSlotTriggers: string[];
+    kbsFromFallback: string[];
+    finalKBs: string[];
+    routingReasons: KBRoutingReason[];
+}
+/** Details from the disambiguation process for tracing */
+interface DisambiguationDetails {
+    llmExtraction: {
+        kbHints: string[];
+        goals: string[];
+        reasoning?: string;
+        isOutOfScope?: boolean;
+    };
+    routingDecision: RoutingDecision;
+}
+/** Result from disambiguation with explicit action */
+interface DisambiguationResult {
+    intent: Intent;
+    updatedContext: AgentContext;
+    action: DisambiguationAction;
+    disambiguationDetails?: DisambiguationDetails;
+}
+/** Facts extracted from LLM (no decisions, just observations) */
+interface LLMExtractionFacts {
+    slots: Partial<Slots>;
+    goals: string[];
+    kbHints: string[];
+    intentSummary: string;
+    nonAnswer?: boolean;
+    topicShift?: boolean;
+    isOutOfScope?: boolean;
+    reasoning?: string;
+}
+/** Types for enhanced planning */
+interface KBRelevanceInfo {
+    kbId: string;
+    reason: string;
+    priority: number;
+    requiredSlots: string[];
+    confidence: number;
+}
+interface PlanningReasoning {
+    goalAnalysis: string;
+    kbSelection: KBRelevanceInfo[];
+    dependencyAnalysis: string;
+    riskAssessment: string;
+    alternatives?: string[];
+}
+interface PlanModification {
+    originalPlanId: string;
+    modifiedPlanId: string;
+    changes: Array<{
+        type: 'add_step' | 'remove_step' | 'modify_step' | 'reorder_steps';
+        stepId?: string;
+        newStep?: PlanStep;
+        reason: string;
+    }>;
+    reasoning: string;
+    confidence: number;
+}
+interface ConversationMessage {
+    role: 'user' | 'assistant';
+    content: string;
+    timestamp?: string;
+}
+interface ChatRequest {
+    /** Session ID for conversation tracking */
+    sessionId?: string;
+    /** The user's message */
+    message: string;
+    /** Whether to include execution trace in response */
+    returnTrace?: boolean;
+    /** Previous intent for multi-turn conversations */
+    previousIntent?: Intent;
+    /** Previous agent context for multi-turn conversations */
+    previousContext?: AgentContext;
+    /** Full conversation history with timestamps */
+    conversationHistory?: ConversationMessage[];
+}
+/** Outcome type for chat responses */
+type ChatOutcome = 'answer' | 'follow_up' | 'blocked' | 'out_of_scope';
+interface ChatResponse {
+    /** Session ID for conversation tracking */
+    sessionId: string;
+    /** The type of outcome */
+    outcome: ChatOutcome;
+    /** The answer text (for 'answer' outcome) */
+    answer: string | null;
+    /** Follow-up question (for 'follow_up' outcome) */
+    followUpQuestion: string | null;
+    /** Multi-choice options for follow-up questions */
+    options?: MultiChoiceOption[];
+    /** Citations referenced in the answer */
+    citations: ChatCitation[];
+    /** Agent context for multi-turn conversations */
+    context: AgentContext;
+    /** Extracted intent */
+    intent: Intent;
+    /** Execution trace (if requested) */
+    trace?: ExecutionTrace;
+}
+/**
+ * Citation in chat response.
+ * This is a subset of the full Citation type from agent/types.ts,
+ * optimized for API responses.
+ */
+interface ChatCitation {
+    /** 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;
+    /** MIME type of the source content */
+    contentType?: string;
+    /** Name of the source file */
+    fileName?: string;
+    /** Reference metadata including signed URLs */
+    reference?: {
+        id?: string;
+        file?: {
+            name?: string;
+            signedUrl?: string;
+            metadata?: Record<string, unknown>;
+        };
+    };
+}
+/**
+ * Unified trace event type for all trace adapter communications.
+ *
+ * This discriminated union consolidates all trace-related events into a single type,
+ * simplifying the TraceAdapter interface and eliminating duplicate type definitions.
+ */
+type TraceEvent = {
+    type: 'step';
+    step: TraceStep;
+} | {
+    type: 'trace_complete';
+    trace: ExecutionTrace;
+} | {
+    type: 'session_id';
+    sessionId: string;
+} | {
+    type: 'follow_up';
+    questions: string[];
+};
+
+export { type AgentContext as A, type ConversationMessage as C, type DisambiguationResult as D, type ExecutionTrace as E, type Intent as I, type KBRetrieval as K, type LogLevel as L, type MultiChoiceOption as M, type Plan as P, type Slots as S, type TraceStep as T, type LogEntry as a, type TraceEvent as b, type ChatResponse as c, type ChatCitation as d, type StepResult as e, type PlanStepKBCall as f, type PlanStepSynthesis as g, createSessionLogger as h, subscribeToTraceSteps as i, emitTraceStep as j, getSessionLogs as k, clearSessionLogs as l, type PlanStepType as m, type PlanStep as n, type TraceStepType as o, type PendingQuestion as p, type DisambiguationAction as q, type DisambiguationDetails as r, subscribeToLogs as s, type LLMExtractionFacts as t, type KBRelevanceInfo as u, type PlanningReasoning as v, type PlanModification as w, type ChatRequest as x, type ChatOutcome as y };