@dexto/core 1.1.4 → 1.1.6

package/dist/errors/types.d.ts

@@ -0,0 +1,62 @@
+import { AgentErrorCode } from '../agent/error-codes.js';
+import { ConfigErrorCode } from '../config/error-codes.js';
+import { ContextErrorCode } from '../context/error-codes.js';
+import { LLMErrorCode } from '../llm/error-codes.js';
+import { MCPErrorCode } from '../mcp/error-codes.js';
+import { SessionErrorCode } from '../session/error-codes.js';
+import { StorageErrorCode } from '../storage/error-codes.js';
+import { SystemPromptErrorCode } from '../systemPrompt/error-codes.js';
+import { ToolErrorCode } from '../tools/error-codes.js';
+import { PreferenceErrorCode } from '../preferences/error-codes.js';
+import { RegistryErrorCode } from '../agent/registry/error-codes.js';
+
+/**
+ * Error scopes representing functional domains in the system
+ * Each scope owns its validation and error logic
+ */
+declare enum ErrorScope {
+    LLM = "llm",// LLM operations, model compatibility, input validation for LLMs
+    AGENT = "agent",// Agent lifecycle, configuration
+    CONFIG = "config",// Configuration file operations, parsing, validation
+    CONTEXT = "context",// Context management, message validation, token processing
+    SESSION = "session",// Session lifecycle, management, and state
+    MCP = "mcp",// MCP server connections and protocol
+    TOOLS = "tools",// Tool execution and authorization
+    STORAGE = "storage",// Storage backend operations
+    SYSTEM_PROMPT = "system_prompt",// System prompt contributors and file processing
+    PREFERENCE = "preference",// Global preferences file operations and validation
+    AGENT_REGISTRY = "agent_registry"
+}
+/**
+ * Error types that map directly to HTTP status codes
+ * Each type represents the nature of the error
+ */
+declare enum ErrorType {
+    USER = "user",// 400 - bad input, config errors, validation failures
+    NOT_FOUND = "not_found",// 404 - resource doesn't exist (session, file, etc.)
+    FORBIDDEN = "forbidden",// 403 - permission denied, unauthorized
+    TIMEOUT = "timeout",// 408 - operation timed out
+    RATE_LIMIT = "rate_limit",// 429 - too many requests
+    SYSTEM = "system",// 500 - bugs, internal failures, unexpected states
+    THIRD_PARTY = "third_party",// 502 - upstream provider failures, API errors
+    UNKNOWN = "unknown"
+}
+/**
+ * Union type for all error codes across domains
+ * Provides type safety for error handling
+ */
+type DextoErrorCode = LLMErrorCode | AgentErrorCode | ConfigErrorCode | ContextErrorCode | SessionErrorCode | MCPErrorCode | ToolErrorCode | StorageErrorCode | SystemPromptErrorCode | PreferenceErrorCode | RegistryErrorCode;
+/** Severity of an issue */
+type Severity = 'error' | 'warning';
+/** Generic issue type for validation results */
+interface Issue<C = unknown> {
+    code: DextoErrorCode;
+    message: string;
+    scope: ErrorScope;
+    type: ErrorType;
+    severity: Severity;
+    path?: Array<string | number>;
+    context?: C;
+}
+
+export { type DextoErrorCode, ErrorScope, ErrorType, type Issue, type Severity };

package/dist/errors/types.js

@@ -0,0 +1,29 @@
+var ErrorScope = /* @__PURE__ */ ((ErrorScope2) => {
+  ErrorScope2["LLM"] = "llm";
+  ErrorScope2["AGENT"] = "agent";
+  ErrorScope2["CONFIG"] = "config";
+  ErrorScope2["CONTEXT"] = "context";
+  ErrorScope2["SESSION"] = "session";
+  ErrorScope2["MCP"] = "mcp";
+  ErrorScope2["TOOLS"] = "tools";
+  ErrorScope2["STORAGE"] = "storage";
+  ErrorScope2["SYSTEM_PROMPT"] = "system_prompt";
+  ErrorScope2["PREFERENCE"] = "preference";
+  ErrorScope2["AGENT_REGISTRY"] = "agent_registry";
+  return ErrorScope2;
+})(ErrorScope || {});
+var ErrorType = /* @__PURE__ */ ((ErrorType2) => {
+  ErrorType2["USER"] = "user";
+  ErrorType2["NOT_FOUND"] = "not_found";
+  ErrorType2["FORBIDDEN"] = "forbidden";
+  ErrorType2["TIMEOUT"] = "timeout";
+  ErrorType2["RATE_LIMIT"] = "rate_limit";
+  ErrorType2["SYSTEM"] = "system";
+  ErrorType2["THIRD_PARTY"] = "third_party";
+  ErrorType2["UNKNOWN"] = "unknown";
+  return ErrorType2;
+})(ErrorType || {});
+export {
+  ErrorScope,
+  ErrorType
+};

package/dist/events/index.cjs

@@ -0,0 +1,169 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var events_exports = {};
+__export(events_exports, {
+  AGENT_EVENT_NAMES: () => AGENT_EVENT_NAMES,
+  AgentEventBus: () => AgentEventBus,
+  AgentEventNames: () => AgentEventNames,
+  EVENT_NAMES: () => EVENT_NAMES,
+  EventNames: () => EventNames,
+  SESSION_EVENT_NAMES: () => SESSION_EVENT_NAMES,
+  SessionEventBus: () => SessionEventBus,
+  SessionEventNames: () => SessionEventNames,
+  TypedEventEmitter: () => TypedEventEmitter,
+  eventBus: () => eventBus
+});
+module.exports = __toCommonJS(events_exports);
+var import_events = require("events");
+const AGENT_EVENT_NAMES = [
+  "dexto:conversationReset",
+  "dexto:mcpServerConnected",
+  "dexto:availableToolsUpdated",
+  "dexto:llmSwitched",
+  // Agent state manager events
+  "dexto:stateChanged",
+  "dexto:stateExported",
+  "dexto:stateReset",
+  "dexto:sessionOverrideSet",
+  "dexto:sessionOverrideCleared",
+  "dexto:mcpServerAdded",
+  "dexto:mcpServerRemoved",
+  "dexto:mcpServerUpdated",
+  // Tool confirmation events
+  "dexto:toolConfirmationRequest",
+  "dexto:toolConfirmationResponse"
+];
+const SESSION_EVENT_NAMES = [
+  "llmservice:thinking",
+  "llmservice:chunk",
+  "llmservice:response",
+  "llmservice:toolCall",
+  "llmservice:toolResult",
+  "llmservice:error",
+  "llmservice:switched",
+  "llmservice:unsupportedInput"
+];
+const EVENT_NAMES = [...AGENT_EVENT_NAMES, ...SESSION_EVENT_NAMES];
+const _checkAgentEventNames = true;
+const _checkSessionEventNames = true;
+const _checkEventNames = true;
+void _checkAgentEventNames;
+void _checkSessionEventNames;
+void _checkEventNames;
+const AgentEventNames = Object.freeze([...AGENT_EVENT_NAMES]);
+const SessionEventNames = Object.freeze([
+  ...SESSION_EVENT_NAMES
+]);
+const EventNames = Object.freeze([...EVENT_NAMES]);
+class BaseTypedEventEmitter extends import_events.EventEmitter {
+  // Store listeners with their abort controllers for cleanup
+  _abortListeners = /* @__PURE__ */ new WeakMap();
+  // Implementation
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  // Implementation
+  on(event, listener, options) {
+    if (options?.signal?.aborted) {
+      return this;
+    }
+    super.on(event, listener);
+    if (options?.signal) {
+      const signal = options.signal;
+      if (!this._abortListeners.has(signal)) {
+        this._abortListeners.set(signal, /* @__PURE__ */ new Set());
+      }
+      this._abortListeners.get(signal).add({ event, listener });
+      const abortHandler = () => {
+        this.off(event, listener);
+        const listeners = this._abortListeners.get(signal);
+        if (listeners) {
+          listeners.delete({ event, listener });
+          if (listeners.size === 0) {
+            this._abortListeners.delete(signal);
+          }
+        }
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    return this;
+  }
+  // Implementation
+  once(event, listener, options) {
+    if (options?.signal?.aborted) {
+      return this;
+    }
+    const onceWrapper = (...args) => {
+      if (options?.signal) {
+        const listeners = this._abortListeners.get(options.signal);
+        if (listeners) {
+          listeners.delete({ event, listener: onceWrapper });
+          if (listeners.size === 0) {
+            this._abortListeners.delete(options.signal);
+          }
+        }
+      }
+      listener(...args);
+    };
+    super.once(event, onceWrapper);
+    if (options?.signal) {
+      const signal = options.signal;
+      if (!this._abortListeners.has(signal)) {
+        this._abortListeners.set(signal, /* @__PURE__ */ new Set());
+      }
+      this._abortListeners.get(signal).add({ event, listener: onceWrapper });
+      const abortHandler = () => {
+        this.off(event, onceWrapper);
+        const listeners = this._abortListeners.get(signal);
+        if (listeners) {
+          listeners.delete({ event, listener: onceWrapper });
+          if (listeners.size === 0) {
+            this._abortListeners.delete(signal);
+          }
+        }
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    return this;
+  }
+  // Implementation
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+}
+class AgentEventBus extends BaseTypedEventEmitter {
+}
+class SessionEventBus extends BaseTypedEventEmitter {
+}
+class TypedEventEmitter extends BaseTypedEventEmitter {
+}
+const eventBus = new TypedEventEmitter();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_EVENT_NAMES,
+  AgentEventBus,
+  AgentEventNames,
+  EVENT_NAMES,
+  EventNames,
+  SESSION_EVENT_NAMES,
+  SessionEventBus,
+  SessionEventNames,
+  TypedEventEmitter,
+  eventBus
+});

package/dist/events/index.d.cts

@@ -0,0 +1,272 @@
+import { EventEmitter } from 'events';
+import { LLMProvider, LLMRouter } from '../llm/types.cjs';
+import { ValidatedAgentConfig } from '../agent/schemas.cjs';
+import 'zod';
+
+/**
+ * Agent-level event names - events that occur at the agent/global level
+ */
+declare const AGENT_EVENT_NAMES: readonly ["dexto:conversationReset", "dexto:mcpServerConnected", "dexto:availableToolsUpdated", "dexto:llmSwitched", "dexto:stateChanged", "dexto:stateExported", "dexto:stateReset", "dexto:sessionOverrideSet", "dexto:sessionOverrideCleared", "dexto:mcpServerAdded", "dexto:mcpServerRemoved", "dexto:mcpServerUpdated", "dexto:toolConfirmationRequest", "dexto:toolConfirmationResponse"];
+/**
+ * Session-level event names - events that occur within individual sessions
+ */
+declare const SESSION_EVENT_NAMES: readonly ["llmservice:thinking", "llmservice:chunk", "llmservice:response", "llmservice:toolCall", "llmservice:toolResult", "llmservice:error", "llmservice:switched", "llmservice:unsupportedInput"];
+/**
+ * All event names combined for backward compatibility
+ */
+declare const EVENT_NAMES: readonly ["dexto:conversationReset", "dexto:mcpServerConnected", "dexto:availableToolsUpdated", "dexto:llmSwitched", "dexto:stateChanged", "dexto:stateExported", "dexto:stateReset", "dexto:sessionOverrideSet", "dexto:sessionOverrideCleared", "dexto:mcpServerAdded", "dexto:mcpServerRemoved", "dexto:mcpServerUpdated", "dexto:toolConfirmationRequest", "dexto:toolConfirmationResponse", "llmservice:thinking", "llmservice:chunk", "llmservice:response", "llmservice:toolCall", "llmservice:toolResult", "llmservice:error", "llmservice:switched", "llmservice:unsupportedInput"];
+/**
+ * Combined event map for the agent bus - includes agent events and session events with sessionId
+ * This is what the global agent event bus uses to aggregate all events
+ */
+interface AgentEventMap {
+    /** Fired when Dexto conversation is reset */
+    'dexto:conversationReset': {
+        sessionId: string;
+    };
+    /** Fired when MCP server connection succeeds or fails */
+    'dexto:mcpServerConnected': {
+        name: string;
+        success: boolean;
+        error?: string;
+    };
+    /** Fired when available tools list updates */
+    'dexto:availableToolsUpdated': {
+        tools: string[];
+        source: 'mcp' | 'builtin';
+    };
+    /** Fired when LLM service switched */
+    'dexto:llmSwitched': {
+        newConfig: any;
+        router?: string;
+        historyRetained?: boolean;
+        sessionIds: string[];
+    };
+    /** LLM service started thinking */
+    'llmservice:thinking': {
+        sessionId: string;
+    };
+    /** LLM service sent a streaming chunk */
+    'llmservice:chunk': {
+        type: 'text' | 'reasoning';
+        content: string;
+        isComplete?: boolean;
+        sessionId: string;
+    };
+    /** LLM service final response */
+    'llmservice:response': {
+        content: string;
+        reasoning?: string;
+        provider?: LLMProvider;
+        model?: string;
+        router?: LLMRouter;
+        tokenUsage?: {
+            inputTokens?: number;
+            outputTokens?: number;
+            reasoningTokens?: number;
+            totalTokens?: number;
+        };
+        sessionId: string;
+    };
+    /** LLM service requested a tool call */
+    'llmservice:toolCall': {
+        toolName: string;
+        args: Record<string, any>;
+        callId?: string;
+        sessionId: string;
+    };
+    /** LLM service returned a tool result */
+    'llmservice:toolResult': {
+        toolName: string;
+        result: any;
+        callId?: string;
+        success: boolean;
+        sessionId: string;
+    };
+    /** LLM service error */
+    'llmservice:error': {
+        error: Error;
+        context?: string;
+        recoverable?: boolean;
+        sessionId: string;
+    };
+    /** LLM service switched */
+    'llmservice:switched': {
+        newConfig: any;
+        router?: string;
+        historyRetained?: boolean;
+        sessionId: string;
+    };
+    /** LLM service unsupported input */
+    'llmservice:unsupportedInput': {
+        errors: string[];
+        provider: LLMProvider;
+        model?: string;
+        fileType?: string;
+        details?: any;
+        sessionId: string;
+    };
+    /** Fired when agent runtime state changes */
+    'dexto:stateChanged': {
+        field: string;
+        oldValue: any;
+        newValue: any;
+        sessionId?: string;
+    };
+    /** Fired when agent state is exported as config */
+    'dexto:stateExported': {
+        config: ValidatedAgentConfig;
+    };
+    /** Fired when agent state is reset to baseline */
+    'dexto:stateReset': {
+        toConfig: any;
+    };
+    /** Fired when session override is set */
+    'dexto:sessionOverrideSet': {
+        sessionId: string;
+        override: any;
+    };
+    /** Fired when session override is cleared */
+    'dexto:sessionOverrideCleared': {
+        sessionId: string;
+    };
+    /** Fired when MCP server is added to runtime state */
+    'dexto:mcpServerAdded': {
+        serverName: string;
+        config: any;
+    };
+    /** Fired when MCP server is removed from runtime state */
+    'dexto:mcpServerRemoved': {
+        serverName: string;
+    };
+    /** Fired when MCP server is updated in runtime state */
+    'dexto:mcpServerUpdated': {
+        serverName: string;
+        config: any;
+    };
+    /** Fired when tool confirmation is requested */
+    'dexto:toolConfirmationRequest': {
+        toolName: string;
+        args: Record<string, any>;
+        description?: string;
+        executionId: string;
+        timestamp: Date;
+        sessionId?: string;
+    };
+    /** Fired when tool confirmation response is received */
+    'dexto:toolConfirmationResponse': {
+        executionId: string;
+        approved: boolean;
+        rememberChoice?: boolean;
+        sessionId?: string;
+    };
+}
+/**
+ * Session-level events - these occur within individual sessions without session context
+ * (since they're already scoped to a session)
+ */
+interface SessionEventMap {
+    /** LLM service started thinking */
+    'llmservice:thinking': void;
+    /** LLM service sent a streaming chunk */
+    'llmservice:chunk': {
+        type: 'text' | 'reasoning';
+        content: string;
+        isComplete?: boolean;
+    };
+    /** LLM service final response */
+    'llmservice:response': {
+        content: string;
+        reasoning?: string;
+        provider?: LLMProvider;
+        model?: string;
+        router?: LLMRouter;
+        tokenUsage?: {
+            inputTokens?: number;
+            outputTokens?: number;
+            reasoningTokens?: number;
+            totalTokens?: number;
+        };
+    };
+    /** LLM service requested a tool call */
+    'llmservice:toolCall': {
+        toolName: string;
+        args: Record<string, any>;
+        callId?: string;
+    };
+    /** LLM service returned a tool result */
+    'llmservice:toolResult': {
+        toolName: string;
+        result: any;
+        callId?: string;
+        success: boolean;
+    };
+    /** LLM service error */
+    'llmservice:error': {
+        error: Error;
+        context?: string;
+        recoverable?: boolean;
+    };
+    /** LLM service switched */
+    'llmservice:switched': {
+        newConfig: any;
+        router?: string;
+        historyRetained?: boolean;
+    };
+    /** LLM service unsupported input */
+    'llmservice:unsupportedInput': {
+        errors: string[];
+        provider: LLMProvider;
+        model?: string;
+        fileType?: string;
+        details?: any;
+    };
+}
+type AgentEventName = keyof AgentEventMap;
+type SessionEventName = keyof SessionEventMap;
+type EventName = keyof AgentEventMap;
+/**
+ * Runtime arrays of event names for iteration, validation, etc.
+ */
+declare const AgentEventNames: readonly AgentEventName[];
+declare const SessionEventNames: readonly SessionEventName[];
+declare const EventNames: readonly EventName[];
+/**
+ * Generic typed EventEmitter base class
+ */
+declare class BaseTypedEventEmitter<TEventMap extends Record<string, any>> extends EventEmitter {
+    private _abortListeners;
+    emit<K extends keyof TEventMap>(event: K, ...args: TEventMap[K] extends void ? [] : [TEventMap[K]]): boolean;
+    emit(event: string, ...args: never[]): boolean;
+    on<K extends keyof TEventMap>(event: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void, options?: {
+        signal?: AbortSignal;
+    }): this;
+    on(event: string | symbol, listener: (...args: any[]) => void): this;
+    once<K extends keyof TEventMap>(event: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void, options?: {
+        signal?: AbortSignal;
+    }): this;
+    once(event: string | symbol, listener: (...args: any[]) => void): this;
+    off<K extends keyof TEventMap>(event: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void): this;
+    off(event: string | symbol, listener: (...args: any[]) => void): this;
+}
+/**
+ * Agent-level typed event emitter for global agent events
+ */
+declare class AgentEventBus extends BaseTypedEventEmitter<AgentEventMap> {
+}
+/**
+ * Session-level typed event emitter for session-scoped events
+ */
+declare class SessionEventBus extends BaseTypedEventEmitter<SessionEventMap> {
+}
+/**
+ * Combined typed event emitter for backward compatibility
+ */
+declare class TypedEventEmitter extends BaseTypedEventEmitter<AgentEventMap> {
+}
+/**
+ * Global shared event bus (backward compatibility)
+ */
+declare const eventBus: TypedEventEmitter;
+
+export { AGENT_EVENT_NAMES, AgentEventBus, type AgentEventMap, type AgentEventName, AgentEventNames, EVENT_NAMES, type EventName, EventNames, SESSION_EVENT_NAMES, SessionEventBus, type SessionEventMap, type SessionEventName, SessionEventNames, TypedEventEmitter, eventBus };