@dexto/core 1.7.1 → 1.8.0

package/dist/agent/DextoAgent.cjs

@@ -79,9 +79,9 @@ var import_crypto = require("crypto");
 var import_events = require("events");
 var import_zod = require("zod");
 var import_contributors = require("../systemPrompt/contributors.js");
+var import_skills = require("../skills/index.js");
 var import_resources = require("../resources/index.js");
 var import_utils = require("../context/utils.js");
-var import_storage = require("../storage/index.js");
 var import_prompts = require("../prompts/index.js");
 var import_session = require("../session/index.js");
 var import_decorators = require("../telemetry/decorators.js");
@@ -153,6 +153,7 @@ let _DextoAgent = class _DextoAgent {
   systemPromptManager;
   agentEventBus;
   promptManager;
+  skillManager;
   stateManager;
   sessionManager;
   workspaceManager;
@@ -171,7 +172,7 @@ let _DextoAgent = class _DextoAgent {
   eventSubscribers = /* @__PURE__ */ new Set();
   // Telemetry instance for distributed tracing
   telemetry;
-  // Approval handler for manual tool confirmation and elicitation
+  // Approval handler for manual tool approval and elicitation
   // Set via setApprovalHandler() before start() if needed
   approvalHandler;
   mcpAuthProviderFactory = null;
@@ -182,6 +183,7 @@ let _DextoAgent = class _DextoAgent {
   toolkitLoader;
   loadedToolkits = /* @__PURE__ */ new Set();
   loadingToolkits = /* @__PURE__ */ new Set();
+  skillSources;
   // DI-provided local tools.
   tools;
   compactionStrategy;
@@ -231,7 +233,7 @@ let _DextoAgent = class _DextoAgent {
   constructor(options) {
     const {
       logger,
-      storage,
+      stores,
       tools: toolsInput,
       hooks: hooksInput,
       compaction,
@@ -245,21 +247,15 @@ let _DextoAgent = class _DextoAgent {
     this.tools = tools;
     this.compactionStrategy = compaction ?? null;
     const overrides = { ...overridesInput ?? {} };
-    if (overrides.storageManager === void 0) {
-      overrides.storageManager = new import_storage.StorageManager(
-        {
-          cache: storage.cache,
-          database: storage.database,
-          blobStore: storage.blob
-        },
-        this.logger
-      );
+    if (overrides.stores === void 0) {
+      overrides.stores = stores;
     }
     if (overrides.hooks === void 0) {
       overrides.hooks = hooks;
     }
     this.overrides = overrides;
     this.toolkitLoader = options.toolkitLoader;
+    this.skillSources = options.skillSources ?? [];
     if (overrides.mcpAuthProviderFactory !== void 0) {
       this.mcpAuthProviderFactory = overrides.mcpAuthProviderFactory;
     }
@@ -309,7 +305,7 @@ let _DextoAgent = class _DextoAgent {
           `An approval handler is required but not configured (${reasons.join(" and ")}).
 Either:
   \u2022 Call agent.setApprovalHandler() before starting
-  \u2022 Set permissions: { mode: "auto-approve" } or { mode: "auto-deny" }
+  \u2022 Set permissions: { mode: "auto-approve" }
   \u2022 Disable elicitation: { enabled: false }`
         );
       }
@@ -332,23 +328,24 @@ Either:
         this.resourceManager,
         this.config,
         this.agentEventBus,
-        services.storageManager.getDatabase(),
+        services.stores,
         this.logger
       );
       await promptManager.initialize();
-      Object.assign(this, { promptManager });
-      const toolExecutionStorage = {
-        blob: services.storageManager.getBlobStore(),
-        database: services.storageManager.getDatabase(),
-        cache: services.storageManager.getCache()
-      };
+      const skillManager = new import_skills.CompositeSkillManager([
+        ...this.skillSources,
+        new import_skills.WorkspaceSkillSource(services.workspaceManager)
+      ]);
+      Object.assign(this, { promptManager, skillManager });
       const toolExecutionServices = {
         approval: services.approvalManager,
         search: services.searchService,
         resources: services.resourceManager,
         prompts: promptManager,
+        skills: skillManager,
         mcp: services.mcpManager,
-        taskForker: null
+        taskForker: null,
+        workspaceManager: services.workspaceManager
       };
       services.toolManager.setToolExecutionContextFactory((baseContext) => ({
         ...baseContext,
@@ -356,7 +353,7 @@ Either:
           hostRuntime: baseContext.runContext.hostRuntime
         },
         agent: this,
-        storage: toolExecutionStorage,
+        toolState: services.stores.getStore("toolState"),
         services: toolExecutionServices
       }));
       const agentTools = this.tools;
@@ -365,7 +362,7 @@ Either:
           "skills",
           50,
           // Priority after memories (40) but before most other content
-          promptManager,
+          skillManager,
           this.logger
         );
         services.systemPromptManager.addContributor(skillsContributor);
@@ -451,13 +448,13 @@ Either:
         shutdownErrors.push(new Error(`ResourceManager cleanup failed: ${err.message}`));
       }
       try {
-        if (this.services?.storageManager) {
-          await this.services.storageManager.disconnect();
-          this.logger.debug("Storage manager disconnected successfully");
+        if (this.services?.stores) {
+          await this.services.stores.disconnect();
+          this.logger.debug("Stores disconnected successfully");
         }
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        shutdownErrors.push(new Error(`Storage disconnect failed: ${err.message}`));
+        shutdownErrors.push(new Error(`Store disconnect failed: ${err.message}`));
       }
       this._isStopped = true;
       this._isStarted = false;
@@ -651,7 +648,7 @@ Either:
       return {
         toolName: tc.toolName,
         args: tc.args,
-        callId: tc.callId || `tool_${Date.now()}`,
+        callId: tc.callId,
         result: toolResult ? {
           success: toolResult.success,
           data: toolResult.sanitized
@@ -743,6 +740,7 @@ Either:
     let contentParts = typeof content === "string" ? [{ type: "text", text: content }] : [...content];
     const eventQueue = [];
     let completed = false;
+    let terminalError;
     let sawFatalErrorEvent = false;
     let sawRunCompleteEvent = false;
     const controller = new AbortController();
@@ -817,10 +815,16 @@ Either:
       eventQueue.push({ name: "llm:tool-result", ...data });
     };
     addStreamingListener("llm:tool-result", toolResultListener);
+    const retryingListener = (data) => {
+      if (data.sessionId !== sessionId) return;
+      eventQueue.push({ name: "llm:retrying", ...data });
+    };
+    addStreamingListener("llm:retrying", retryingListener);
     const errorListener = (data) => {
       if (data.sessionId !== sessionId) return;
       if (data.recoverable !== true) {
         sawFatalErrorEvent = true;
+        terminalError = data.error;
       }
       eventQueue.push({ name: "llm:error", ...data });
     };
@@ -878,6 +882,9 @@ Either:
     const runCompleteListener = (data) => {
       if (data.sessionId !== sessionId) return;
       sawRunCompleteEvent = true;
+      if (data.finishReason === "error" && data.error !== void 0) {
+        terminalError = data.error;
+      }
       eventQueue.push({ name: "run:complete", ...data });
       completed = true;
     };
@@ -1054,6 +1061,7 @@ Either:
             return;
           }
           completed = true;
+          terminalError = error;
           this.logger.error(`Error in DextoAgent.stream: ${error.message}`);
           const errorEvent = {
             name: "llm:error",
@@ -1083,6 +1091,9 @@ Either:
         if (completed) {
           cleanupListeners();
           controller.abort();
+          if (terminalError !== void 0) {
+            throw terminalError;
+          }
           return { done: true, value: void 0 };
         }
         cleanupListeners();
@@ -1110,61 +1121,129 @@ Either:
     return session?.isBusy?.() ?? false;
   }
   /**
-   * Queue a message for processing when a session is busy.
-   * The message will be injected into the conversation when the current turn completes.
+   * Queue a message as active-turn steer input for a session.
+   * The message is injected at the next executor boundary while the current turn is active.
    *
    * @param sessionId Session id
-   * @param message The user message to queue
+   * @param message The user message to use as steer input
    * @returns Queue position and message ID
-   * @throws Error if session doesn't support message queueing
    */
-  async queueMessage(sessionId, message) {
+  async steer(sessionId, message) {
+    this.ensureStarted();
+    const session = await this.sessionManager.getSession(sessionId, false);
+    if (!session) {
+      throw import_session.SessionError.notFound(sessionId);
+    }
+    return session.steer(message);
+  }
+  /**
+   * Queue a message as follow-up work for a session.
+   * The message is processed only after the active turn would otherwise stop.
+   *
+   * @param sessionId Session id
+   * @param message The user message to queue as follow-up work
+   * @returns Queue position and message ID
+   */
+  async followUp(sessionId, message) {
+    this.ensureStarted();
+    const session = await this.sessionManager.getSession(sessionId, false);
+    if (!session) {
+      throw import_session.SessionError.notFound(sessionId);
+    }
+    return session.followUp(message);
+  }
+  /**
+   * Get all steer messages for a session.
+   * @param sessionId Session id
+   * @returns Array of steer messages
+   */
+  async getSteerMessages(sessionId) {
+    this.ensureStarted();
+    const session = await this.sessionManager.getSession(sessionId, false);
+    if (!session) {
+      throw import_session.SessionError.notFound(sessionId);
+    }
+    return session.getSteerMessages();
+  }
+  /**
+   * Get all follow-up messages for a session.
+   * @param sessionId Session id
+   * @returns Array of follow-up messages
+   */
+  async getFollowUpMessages(sessionId) {
     this.ensureStarted();
     const session = await this.sessionManager.getSession(sessionId, false);
     if (!session) {
       throw import_session.SessionError.notFound(sessionId);
     }
-    return session.queueMessage(message);
+    return session.getFollowUpMessages();
   }
   /**
-   * Get all queued messages for a session.
+   * Remove a steer message.
    * @param sessionId Session id
-   * @returns Array of queued messages
+   * @param messageId The ID of the steer message to remove
+   * @returns true if message was found and removed, false otherwise
    */
-  async getQueuedMessages(sessionId) {
+  async removeSteerMessage(sessionId, messageId) {
     this.ensureStarted();
     const session = await this.sessionManager.getSession(sessionId, false);
     if (!session) {
       throw import_session.SessionError.notFound(sessionId);
     }
-    return session.getQueuedMessages();
+    return session.removeSteerMessage(messageId);
   }
   /**
-   * Remove a queued message.
+   * Remove a follow-up message.
    * @param sessionId Session id
-   * @param messageId The ID of the queued message to remove
+   * @param messageId The ID of the follow-up message to remove
    * @returns true if message was found and removed, false otherwise
    */
-  async removeQueuedMessage(sessionId, messageId) {
+  async removeFollowUpMessage(sessionId, messageId) {
+    this.ensureStarted();
+    const session = await this.sessionManager.getSession(sessionId, false);
+    if (!session) {
+      throw import_session.SessionError.notFound(sessionId);
+    }
+    return session.removeFollowUpMessage(messageId);
+  }
+  /**
+   * Clear all steer messages for a session.
+   * @param sessionId Session id
+   * @returns Number of messages that were cleared
+   */
+  async clearSteerQueue(sessionId) {
     this.ensureStarted();
     const session = await this.sessionManager.getSession(sessionId, false);
     if (!session) {
       throw import_session.SessionError.notFound(sessionId);
     }
-    return session.removeQueuedMessage(messageId);
+    return session.clearSteerQueue();
   }
   /**
-   * Clear all queued messages for a session.
+   * Clear all follow-up messages for a session.
    * @param sessionId Session id
    * @returns Number of messages that were cleared
    */
-  async clearMessageQueue(sessionId) {
+  async clearFollowUpQueue(sessionId) {
     this.ensureStarted();
     const session = await this.sessionManager.getSession(sessionId, false);
     if (!session) {
       throw import_session.SessionError.notFound(sessionId);
     }
-    return session.clearMessageQueue();
+    return session.clearFollowUpQueue();
+  }
+  /**
+   * Clear all pending steer and follow-up input for a session.
+   * @param sessionId Session id
+   * @returns Number of messages that were cleared
+   */
+  async clearPendingInput(sessionId) {
+    this.ensureStarted();
+    const session = await this.sessionManager.getSession(sessionId, false);
+    if (!session) {
+      throw import_session.SessionError.notFound(sessionId);
+    }
+    return session.clearPendingInput();
   }
   /**
    * Cancels the currently running turn for a session.
@@ -1328,6 +1407,16 @@ Either:
    * @returns Promise that resolves to the generated title, or null if generation failed
    */
   async generateSessionTitle(sessionId) {
+    const result = await this.generateSessionTitleDetails(sessionId);
+    return result?.title ?? null;
+  }
+  /**
+   * Generate a title for a session and report whether it came from the LLM or heuristic fallback.
+   *
+   * @param sessionId Session ID to generate title for
+   * @returns Promise that resolves to title details, or null if generation failed
+   */
+  async generateSessionTitleDetails(sessionId) {
     this.ensureStarted();
     const metadata = await this.sessionManager.getSessionMetadata(sessionId);
     if (!metadata) {
@@ -1337,7 +1426,10 @@ Either:
       this.logger.debug(
         `[SessionTitle] Session ${sessionId} already has title '${metadata.title}'`
       );
-      return metadata.title;
+      return {
+        source: "existing",
+        title: metadata.title
+      };
     }
     const session = await this.sessionManager.getSession(sessionId);
     if (!session) {
@@ -1355,24 +1447,25 @@ Either:
       return null;
     }
     const llmConfig = this.getEffectiveConfig(sessionId).llm;
-    const result = await (0, import_title_generator.generateSessionTitle)(
-      llmConfig,
-      this.toolManager,
-      this.systemPromptManager,
-      this.resourceManager,
-      userText,
-      this.logger,
-      {
-        ...this.overrides.languageModelFactory !== void 0 && {
-          languageModelFactory: this.overrides.languageModelFactory
-        }
+    const result = await (0, import_title_generator.generateSessionTitle)(llmConfig, userText, this.logger, {
+      providerContext: { sessionId },
+      ...this.overrides.languageModelFactory !== void 0 && {
+        languageModelFactory: this.overrides.languageModelFactory
       }
-    );
+    });
     let title = result.title;
     if (!title) {
       title = (0, import_title_generator.deriveHeuristicTitle)(userText);
       if (title) {
         this.logger.info(`[SessionTitle] Using heuristic title for ${sessionId}: ${title}`);
+        const details = {
+          ...result.error !== void 0 && { reason: result.error },
+          ...result.timedOut !== void 0 && { timedOut: result.timedOut },
+          source: "heuristic",
+          title
+        };
+        await this.sessionManager.setSessionTitle(sessionId, title, { ifUnsetOnly: true });
+        return details;
       } else {
         this.logger.debug(`[SessionTitle] No suitable title derived for ${sessionId}`);
         return null;
@@ -1381,7 +1474,10 @@ Either:
       this.logger.info(`[SessionTitle] Generated LLM title for ${sessionId}: ${title}`);
     }
     await this.sessionManager.setSessionTitle(sessionId, title, { ifUnsetOnly: true });
-    return title;
+    return {
+      source: "llm",
+      title
+    };
   }
   /**
    * Gets the conversation history for a specific session.
@@ -2639,11 +2735,10 @@ Either:
    * - Prompt key resolution (resolving aliases)
    * - Argument normalization (including special _context field)
    * - Prompt execution and flattening
-   * - Returning per-prompt overrides (allowedTools, model) for the invoker to apply
    *
    * @param name The prompt name or alias
    * @param options Optional configuration for prompt resolution
-   * @returns Promise resolving to the resolved text, resource URIs, and optional overrides
+   * @returns Promise resolving to the resolved text and resource URIs.
    */
   async resolvePrompt(name, options = {}) {
     this.ensureStarted();
@@ -2671,7 +2766,7 @@ Either:
    * Set a custom approval handler for manual approval mode.
    *
    * When `permissions.mode` is set to 'manual', an approval handler must be
-   * provided to process tool confirmation requests. The handler will be called
+   * provided to process tool approval requests. The handler will be called
    * whenever a tool execution requires user approval.
    *
    * The handler receives an approval request and must return a promise that resolves

package/dist/agent/DextoAgent.d.ts

@@ -1,13 +1,15 @@
 import { MCPManager } from '../mcp/manager.js';
 import { ToolManager } from '../tools/tool-manager.js';
 import { SystemPromptManager } from '../systemPrompt/manager.js';
+import { type SkillManager } from '../skills/index.js';
 import { ResourceManager } from '../resources/index.js';
 import type { InternalMessage } from '../context/types.js';
 import { PromptManager } from '../prompts/index.js';
 import type { PromptsConfig } from '../prompts/schemas.js';
 import { AgentStateManager } from './state-manager.js';
 import { SessionManager, ChatSession } from '../session/index.js';
-import type { SessionMetadata } from '../session/index.js';
+import type { QueuedMessage, SessionMetadata } from '../session/index.js';
+import type { UserMessageInput } from '../session/message-queue.js';
 import { AgentServices } from '../utils/service-initializer.js';
 import type { Logger, LogLevel } from '../logger/v2/types.js';
 import type { McpServerConfig, McpServerStatus, ValidatedMcpServerConfig } from '../mcp/schemas.js';
@@ -30,6 +32,13 @@ import type { SetWorkspaceInput, WorkspaceContext } from '../workspace/types.js'
 export interface AgentEventSubscriber {
     subscribe(eventBus: AgentEventBus): void;
 }
+export type SessionTitleSource = 'existing' | 'llm' | 'heuristic';
+export interface SessionTitleGenerationDetails {
+    title: string;
+    source: SessionTitleSource;
+    reason?: string;
+    timedOut?: boolean;
+}
 /**
  * The main entry point into Dexto's core functionality.
  *
@@ -97,6 +106,7 @@ export declare class DextoAgent {
     readonly systemPromptManager: SystemPromptManager;
     private readonly agentEventBus;
     readonly promptManager: PromptManager;
+    readonly skillManager: SkillManager;
     readonly stateManager: AgentStateManager;
     readonly sessionManager: SessionManager;
     readonly workspaceManager: WorkspaceManager;
@@ -117,6 +127,7 @@ export declare class DextoAgent {
     private readonly toolkitLoader;
     private readonly loadedToolkits;
     private readonly loadingToolkits;
+    private readonly skillSources;
     private tools;
     private readonly compactionStrategy;
     readonly logger: Logger;
@@ -282,38 +293,75 @@ export declare class DextoAgent {
      */
     isSessionBusy(sessionId: string): Promise<boolean>;
     /**
-     * Queue a message for processing when a session is busy.
-     * The message will be injected into the conversation when the current turn completes.
+     * Queue a message as active-turn steer input for a session.
+     * The message is injected at the next executor boundary while the current turn is active.
      *
      * @param sessionId Session id
-     * @param message The user message to queue
+     * @param message The user message to use as steer input
      * @returns Queue position and message ID
-     * @throws Error if session doesn't support message queueing
      */
-    queueMessage(sessionId: string, message: import('../session/message-queue.js').UserMessageInput): Promise<{
+    steer(sessionId: string, message: UserMessageInput): Promise<{
         queued: true;
         position: number;
         id: string;
     }>;
     /**
-     * Get all queued messages for a session.
+     * Queue a message as follow-up work for a session.
+     * The message is processed only after the active turn would otherwise stop.
+     *
      * @param sessionId Session id
-     * @returns Array of queued messages
+     * @param message The user message to queue as follow-up work
+     * @returns Queue position and message ID
      */
-    getQueuedMessages(sessionId: string): Promise<import('../session/types.js').QueuedMessage[]>;
+    followUp(sessionId: string, message: UserMessageInput): Promise<{
+        queued: true;
+        position: number;
+        id: string;
+    }>;
     /**
-     * Remove a queued message.
+     * Get all steer messages for a session.
      * @param sessionId Session id
-     * @param messageId The ID of the queued message to remove
+     * @returns Array of steer messages
+     */
+    getSteerMessages(sessionId: string): Promise<QueuedMessage[]>;
+    /**
+     * Get all follow-up messages for a session.
+     * @param sessionId Session id
+     * @returns Array of follow-up messages
+     */
+    getFollowUpMessages(sessionId: string): Promise<QueuedMessage[]>;
+    /**
+     * Remove a steer message.
+     * @param sessionId Session id
+     * @param messageId The ID of the steer message to remove
      * @returns true if message was found and removed, false otherwise
      */
-    removeQueuedMessage(sessionId: string, messageId: string): Promise<boolean>;
+    removeSteerMessage(sessionId: string, messageId: string): Promise<boolean>;
     /**
-     * Clear all queued messages for a session.
+     * Remove a follow-up message.
+     * @param sessionId Session id
+     * @param messageId The ID of the follow-up message to remove
+     * @returns true if message was found and removed, false otherwise
+     */
+    removeFollowUpMessage(sessionId: string, messageId: string): Promise<boolean>;
+    /**
+     * Clear all steer messages for a session.
+     * @param sessionId Session id
+     * @returns Number of messages that were cleared
+     */
+    clearSteerQueue(sessionId: string): Promise<number>;
+    /**
+     * Clear all follow-up messages for a session.
+     * @param sessionId Session id
+     * @returns Number of messages that were cleared
+     */
+    clearFollowUpQueue(sessionId: string): Promise<number>;
+    /**
+     * Clear all pending steer and follow-up input for a session.
      * @param sessionId Session id
      * @returns Number of messages that were cleared
      */
-    clearMessageQueue(sessionId: string): Promise<number>;
+    clearPendingInput(sessionId: string): Promise<number>;
     /**
      * Cancels the currently running turn for a session.
      * Safe to call even if no run is in progress.
@@ -405,6 +453,13 @@ export declare class DextoAgent {
      * @returns Promise that resolves to the generated title, or null if generation failed
      */
     generateSessionTitle(sessionId: string): Promise<string | null>;
+    /**
+     * Generate a title for a session and report whether it came from the LLM or heuristic fallback.
+     *
+     * @param sessionId Session ID to generate title for
+     * @returns Promise that resolves to title details, or null if generation failed
+     */
+    generateSessionTitleDetails(sessionId: string): Promise<SessionTitleGenerationDetails | null>;
     /**
      * Gets the conversation history for a specific session.
      * @param sessionId The session ID
@@ -921,11 +976,10 @@ export declare class DextoAgent {
      * - Prompt key resolution (resolving aliases)
      * - Argument normalization (including special _context field)
      * - Prompt execution and flattening
-     * - Returning per-prompt overrides (allowedTools, model) for the invoker to apply
      *
      * @param name The prompt name or alias
      * @param options Optional configuration for prompt resolution
-     * @returns Promise resolving to the resolved text, resource URIs, and optional overrides
+     * @returns Promise resolving to the resolved text and resource URIs.
      */
     resolvePrompt(name: string, options?: {
         context?: string;
@@ -943,7 +997,7 @@ export declare class DextoAgent {
      * Set a custom approval handler for manual approval mode.
      *
      * When `permissions.mode` is set to 'manual', an approval handler must be
-     * provided to process tool confirmation requests. The handler will be called
+     * provided to process tool approval requests. The handler will be called
      * whenever a tool execution requires user approval.
      *
      * The handler receives an approval request and must return a promise that resolves