@dexto/core 1.1.4 → 1.1.6

package/dist/events/index.d.ts

@@ -0,0 +1,272 @@
+import { EventEmitter } from 'events';
+import { LLMProvider, LLMRouter } from '../llm/types.js';
+import { ValidatedAgentConfig } from '../agent/schemas.js';
+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 };

package/dist/events/index.js

@@ -0,0 +1,136 @@
+import { EventEmitter } from "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 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();
+export {
+  AGENT_EVENT_NAMES,
+  AgentEventBus,
+  AgentEventNames,
+  EVENT_NAMES,
+  EventNames,
+  SESSION_EVENT_NAMES,
+  SessionEventBus,
+  SessionEventNames,
+  TypedEventEmitter,
+  eventBus
+};

package/dist/index.browser.cjs

@@ -16,235 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.browser.ts
 var index_browser_exports = {};
 __export(index_browser_exports, {
-  ErrorScope: () => ErrorScope,
-  ErrorType: () => ErrorType,
-  LLM_PROVIDERS: () => LLM_PROVIDERS,
-  LLM_ROUTERS: () => LLM_ROUTERS,
-  SUPPORTED_FILE_TYPES: () => SUPPORTED_FILE_TYPES,
-  toError: () => toError,
-  zodToIssues: () => zodToIssues
+  ErrorScope: () => import_types.ErrorScope,
+  ErrorType: () => import_types.ErrorType,
+  LLM_PROVIDERS: () => import_types2.LLM_PROVIDERS,
+  toError: () => import_error_conversion.toError,
+  zodToIssues: () => import_result.zodToIssues
 });
 module.exports = __toCommonJS(index_browser_exports);
-
-// src/utils/redactor.ts
-var SENSITIVE_FIELDS = [
-  "apikey",
-  "api_key",
-  "token",
-  "access_token",
-  "refresh_token",
-  "password",
-  "secret"
-];
-var FILE_DATA_FIELDS = [
-  "base64",
-  "filedata",
-  "file_data",
-  "imagedata",
-  "image_data",
-  "audiodata",
-  "audio_data",
-  "data"
-];
-var SENSITIVE_PATTERNS = [
-  /\bsk-[A-Za-z0-9]{20,}\b/g,
-  // OpenAI API keys (at least 20 chars after sk-)
-  /\bBearer\s+[A-Za-z0-9\-_.=]+\b/gi,
-  // Bearer tokens
-  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
-  // Emails
-  /\beyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*/g
-  // JWT tokens
-];
-var REDACTED = "[REDACTED]";
-var REDACTED_CIRCULAR = "[REDACTED_CIRCULAR]";
-var FILE_DATA_TRUNCATED = "[FILE_DATA_TRUNCATED]";
-function isLargeBase64Data(value) {
-  return value.length > 1e3 && /^[A-Za-z0-9+/=]{1000,}$/.test(value.substring(0, 1e3));
-}
-function truncateFileData(value, key, parent) {
-  if (typeof value !== "string") return value;
-  const lowerKey = key.toLowerCase();
-  const hasFileContext = !!parent && ("mimeType" in parent || "filename" in parent || "fileName" in parent);
-  const looksLikeFileField = FILE_DATA_FIELDS.includes(lowerKey) || lowerKey === "data" && hasFileContext;
-  if (looksLikeFileField && isLargeBase64Data(value)) {
-    return `${FILE_DATA_TRUNCATED} (${value.length} chars)`;
-  }
-  return value;
-}
-function redactSensitiveData(input, seen = /* @__PURE__ */ new WeakSet()) {
-  if (typeof input === "string") {
-    let result = input;
-    for (const pattern of SENSITIVE_PATTERNS) {
-      result = result.replace(pattern, REDACTED);
-    }
-    return result;
-  }
-  if (Array.isArray(input)) {
-    if (seen.has(input)) return REDACTED_CIRCULAR;
-    seen.add(input);
-    return input.map((item) => redactSensitiveData(item, seen));
-  }
-  if (input && typeof input === "object") {
-    if (seen.has(input)) return REDACTED_CIRCULAR;
-    seen.add(input);
-    const result = {};
-    for (const [key, value] of Object.entries(input)) {
-      if (SENSITIVE_FIELDS.includes(key.toLowerCase())) {
-        result[key] = REDACTED;
-      } else {
-        const truncatedValue = truncateFileData(
-          value,
-          key,
-          input
-        );
-        result[key] = redactSensitiveData(truncatedValue, seen);
-      }
-    }
-    return result;
-  }
-  return input;
-}
-
-// src/utils/safe-stringify.ts
-function safeStringify(value, maxLen = 1e3) {
-  try {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    const redacted = redactSensitiveData(value);
-    const str = JSON.stringify(redacted, (_, v) => {
-      if (v instanceof Error) {
-        return { name: v.name, message: v.message, stack: v.stack };
-      }
-      if (typeof v === "bigint") return v.toString();
-      return v;
-    });
-    const indicator = "\u2026(truncated)";
-    const limit = Number.isFinite(maxLen) && maxLen > 0 ? Math.floor(maxLen) : 1e3;
-    if (typeof str === "string") {
-      if (str.length <= limit) return str;
-      const sliceLen = Math.max(0, limit - indicator.length);
-      return `${str.slice(0, sliceLen)}${indicator}`;
-    }
-    return String(value);
-  } catch {
-    try {
-      return String(value);
-    } catch {
-      return "[Unserializable value]";
-    }
-  }
-}
-
-// src/utils/error-conversion.ts
-function toError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  if (error && typeof error === "object") {
-    if ("message" in error && typeof error.message === "string") {
-      return new Error(error.message, { cause: error });
-    }
-    if ("error" in error && typeof error.error === "string") {
-      return new Error(error.error, { cause: error });
-    }
-    if ("details" in error && typeof error.details === "string") {
-      return new Error(error.details, { cause: error });
-    }
-    if ("description" in error && typeof error.description === "string") {
-      return new Error(error.description, { cause: error });
-    }
-    const serialized = safeStringify(error);
-    return new Error(serialized);
-  }
-  if (typeof error === "string") {
-    return new Error(error, { cause: error });
-  }
-  return new Error(String(error), { cause: error });
-}
-
-// src/utils/result.ts
-var import_zod = require("zod");
-
-// src/errors/types.ts
-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 || {});
-
-// src/utils/result.ts
-var NonEmptyTrimmed = import_zod.z.string().transform((s) => s.trim()).refine((s) => s.length > 0, { message: "Required" });
-function isValidUrl(s) {
-  try {
-    const u = new URL(s);
-    return u.protocol === "http:" || u.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-var OptionalURL = import_zod.z.string().transform((s) => s.trim()).refine((s) => s === "" || isValidUrl(s), { message: "Invalid URL" }).transform((s) => s === "" ? void 0 : s).optional();
-function zodToIssues(err, severity = "error") {
-  return err.errors.map((e) => {
-    const params = e.params || {};
-    return {
-      code: params.code ?? "schema_validation",
-      message: e.message,
-      scope: params.scope ?? "agent" /* AGENT */,
-      // Fallback for non-custom Zod errors
-      // Treat plain Zod schema failures as USER errors by default
-      type: params.type ?? "user" /* USER */,
-      path: e.path,
-      severity,
-      context: params
-    };
-  });
-}
-
-// src/llm/types.ts
-var LLM_PROVIDERS = [
-  "openai",
-  "openai-compatible",
-  "anthropic",
-  "google",
-  "groq",
-  "xai",
-  "cohere"
-];
-var LLM_ROUTERS = ["vercel", "in-built"];
-var SUPPORTED_FILE_TYPES = ["pdf", "image", "audio"];
+var import_error_conversion = require("./utils/error-conversion.js");
+var import_result = require("./utils/result.js");
+var import_types = require("./errors/types.js");
+var import_types2 = require("./llm/types.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ErrorScope,
   ErrorType,
   LLM_PROVIDERS,
-  LLM_ROUTERS,
-  SUPPORTED_FILE_TYPES,
   toError,
   zodToIssues
 });