@link-assistant/agent 0.7.0 → 0.8.1

package/src/index.js

@@ -3,7 +3,7 @@
 import { Server } from './server/server.ts';
 import { Instance } from './project/instance.ts';
 import { Log } from './util/log.ts';
-import { Bus } from './bus/index.ts';
+// Bus is used via createBusEventSubscription in event-handler.js
 import { Session } from './session/index.ts';
 import { SessionPrompt } from './session/prompt.ts';
 // EOL is reserved for future use
@@ -21,7 +21,9 @@ import { UI } from './cli/ui.ts';
 import {
   runContinuousServerMode,
   runContinuousDirectMode,
+  resolveResumeSession,
 } from './cli/continuous-mode.js';
+import { createBusEventSubscription } from './cli/event-handler.js';
 import { createRequire } from 'module';
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
@@ -285,6 +287,7 @@ async function runAgentMode(argv, request) {
       if (argv.server) {
         // SERVER MODE: Start server and communicate via HTTP
         await runServerMode(
+          argv,
           request,
           providerID,
           modelID,
@@ -295,6 +298,7 @@ async function runAgentMode(argv, request) {
       } else {
         // DIRECT MODE: Run everything in single process
         await runDirectMode(
+          argv,
           request,
           providerID,
           modelID,
@@ -382,6 +386,7 @@ async function runContinuousAgentMode(argv) {
 }
 
 async function runServerMode(
+  argv,
   request,
   providerID,
   modelID,
@@ -389,102 +394,52 @@ async function runServerMode(
   appendSystemMessage,
   jsonStandard
 ) {
+  const compactJson = argv['compact-json'] === true;
+
   // Start server like OpenCode does
   const server = Server.listen({ port: 0, hostname: '127.0.0.1' });
   let unsub = null;
 
   try {
-    // Create a session
-    const createRes = await fetch(
-      `http://${server.hostname}:${server.port}/session`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({}),
-      }
-    );
-    const session = await createRes.json();
-    const sessionID = session.id;
+    // Check if we should resume an existing session
+    const resumeInfo = await resolveResumeSession(argv, compactJson);
+
+    let sessionID;
+
+    if (resumeInfo) {
+      // Use the resumed/forked session
+      sessionID = resumeInfo.sessionID;
+    } else {
+      // Create a new session
+      const createRes = await fetch(
+        `http://${server.hostname}:${server.port}/session`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({}),
+        }
+      );
+      const session = await createRes.json();
+      sessionID = session.id;
 
-    if (!sessionID) {
-      throw new Error('Failed to create session');
+      if (!sessionID) {
+        throw new Error('Failed to create session');
+      }
     }
 
     // Create event handler for the selected JSON standard
     const eventHandler = createEventHandler(jsonStandard, sessionID);
 
     // Subscribe to all bus events and output in selected format
-    const eventPromise = new Promise((resolve) => {
-      unsub = Bus.subscribeAll((event) => {
-        // Output events in selected JSON format
-        if (event.type === 'message.part.updated') {
-          const part = event.properties.part;
-          if (part.sessionID !== sessionID) {
-            return;
-          }
-
-          // Output different event types
-          if (part.type === 'step-start') {
-            eventHandler.output({
-              type: 'step_start',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'step-finish') {
-            eventHandler.output({
-              type: 'step_finish',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'text' && part.time?.end) {
-            eventHandler.output({
-              type: 'text',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'tool' && part.state.status === 'completed') {
-            eventHandler.output({
-              type: 'tool_use',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-        }
-
-        // Handle session idle to know when to stop
-        if (
-          event.type === 'session.idle' &&
-          event.properties.sessionID === sessionID
-        ) {
-          resolve();
-        }
-
-        // Handle errors
-        if (event.type === 'session.error') {
-          const props = event.properties;
-          if (props.sessionID !== sessionID || !props.error) {
-            return;
-          }
+    const { unsub: eventUnsub, idlePromise: eventPromise } =
+      createBusEventSubscription({
+        sessionID,
+        eventHandler,
+        onError: () => {
           hasError = true;
-          eventHandler.output({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: props.error,
-          });
-        }
+        },
       });
-    });
+    unsub = eventUnsub;
 
     // Send message to session with specified model (default: opencode/grok-code)
     const message = request.message || 'hi';
@@ -529,6 +484,7 @@ async function runServerMode(
 }
 
 async function runDirectMode(
+  argv,
   request,
   providerID,
   modelID,
@@ -536,91 +492,41 @@ async function runDirectMode(
   appendSystemMessage,
   jsonStandard
 ) {
+  const compactJson = argv['compact-json'] === true;
+
   // DIRECT MODE: Run in single process without server
   let unsub = null;
 
   try {
-    // Create a session directly
-    const session = await Session.createNext({
-      directory: process.cwd(),
-    });
-    const sessionID = session.id;
+    // Check if we should resume an existing session
+    const resumeInfo = await resolveResumeSession(argv, compactJson);
+
+    let sessionID;
+
+    if (resumeInfo) {
+      // Use the resumed/forked session
+      sessionID = resumeInfo.sessionID;
+    } else {
+      // Create a new session directly
+      const session = await Session.createNext({
+        directory: process.cwd(),
+      });
+      sessionID = session.id;
+    }
 
     // Create event handler for the selected JSON standard
     const eventHandler = createEventHandler(jsonStandard, sessionID);
 
     // Subscribe to all bus events and output in selected format
-    const eventPromise = new Promise((resolve) => {
-      unsub = Bus.subscribeAll((event) => {
-        // Output events in selected JSON format
-        if (event.type === 'message.part.updated') {
-          const part = event.properties.part;
-          if (part.sessionID !== sessionID) {
-            return;
-          }
-
-          // Output different event types
-          if (part.type === 'step-start') {
-            eventHandler.output({
-              type: 'step_start',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'step-finish') {
-            eventHandler.output({
-              type: 'step_finish',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'text' && part.time?.end) {
-            eventHandler.output({
-              type: 'text',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-
-          if (part.type === 'tool' && part.state.status === 'completed') {
-            eventHandler.output({
-              type: 'tool_use',
-              timestamp: Date.now(),
-              sessionID,
-              part,
-            });
-          }
-        }
-
-        // Handle session idle to know when to stop
-        if (
-          event.type === 'session.idle' &&
-          event.properties.sessionID === sessionID
-        ) {
-          resolve();
-        }
-
-        // Handle errors
-        if (event.type === 'session.error') {
-          const props = event.properties;
-          if (props.sessionID !== sessionID || !props.error) {
-            return;
-          }
+    const { unsub: eventUnsub, idlePromise: eventPromise } =
+      createBusEventSubscription({
+        sessionID,
+        eventHandler,
+        onError: () => {
           hasError = true;
-          eventHandler.output({
-            type: 'error',
-            timestamp: Date.now(),
-            sessionID,
-            error: props.error,
-          });
-        }
+        },
       });
-    });
+    unsub = eventUnsub;
 
     // Send message to session directly
     const message = request.message || 'hi';
@@ -765,6 +671,25 @@ async function main() {
               description:
                 'Output compact JSON (single line) instead of pretty-printed JSON (default: false). Useful for program-to-program communication.',
               default: false,
+            })
+            .option('resume', {
+              alias: 'r',
+              type: 'string',
+              description:
+                'Resume a specific session by ID. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+            })
+            .option('continue', {
+              alias: 'c',
+              type: 'boolean',
+              description:
+                'Continue the most recent session. By default, forks the session with a new UUID. Use --no-fork to continue in the same session.',
+              default: false,
+            })
+            .option('no-fork', {
+              type: 'boolean',
+              description:
+                'When used with --resume or --continue, continue in the same session without forking to a new UUID.',
+              default: false,
             }),
         handler: async (argv) => {
           const compactJson = argv['compact-json'] === true;

package/src/mcp/index.ts

@@ -13,6 +13,18 @@ import { withTimeout } from '../util/timeout';
 export namespace MCP {
   const log = Log.create({ service: 'mcp' });
 
+  /** Built-in default timeout for MCP tool execution (2 minutes) */
+  export const BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT = 120000;
+
+  /** Built-in maximum timeout for MCP tool execution (10 minutes) */
+  export const BUILTIN_MAX_TOOL_CALL_TIMEOUT = 600000;
+
+  /** @deprecated Use BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT instead */
+  export const DEFAULT_TOOL_CALL_TIMEOUT = BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT;
+
+  /** @deprecated Use BUILTIN_MAX_TOOL_CALL_TIMEOUT instead */
+  export const MAX_TOOL_CALL_TIMEOUT = BUILTIN_MAX_TOOL_CALL_TIMEOUT;
+
   export const Failed = NamedError.create(
     'MCPFailed',
     z.object({
@@ -22,6 +34,22 @@ export namespace MCP {
 
   type Client = Awaited<ReturnType<typeof experimental_createMCPClient>>;
 
+  /** Global timeout defaults from configuration */
+  export interface GlobalTimeoutDefaults {
+    /** Global default timeout for MCP tool calls */
+    defaultTimeout: number;
+    /** Global maximum timeout for MCP tool calls */
+    maxTimeout: number;
+  }
+
+  /** Timeout configuration for an MCP server */
+  export interface TimeoutConfig {
+    /** Default timeout for all tool calls from this server */
+    defaultTimeout: number;
+    /** Per-tool timeout overrides */
+    toolTimeouts: Record<string, number>;
+  }
+
   export const Status = z
     .discriminatedUnion('status', [
       z
@@ -59,6 +87,26 @@ export namespace MCP {
       const config = cfg.mcp ?? {};
       const clients: Record<string, Client> = {};
       const status: Record<string, Status> = {};
+      const timeoutConfigs: Record<string, TimeoutConfig> = {};
+
+      // Determine global timeout defaults from config and environment variables
+      const envDefaultTimeout = process.env.MCP_DEFAULT_TOOL_CALL_TIMEOUT
+        ? parseInt(process.env.MCP_DEFAULT_TOOL_CALL_TIMEOUT, 10)
+        : undefined;
+      const envMaxTimeout = process.env.MCP_MAX_TOOL_CALL_TIMEOUT
+        ? parseInt(process.env.MCP_MAX_TOOL_CALL_TIMEOUT, 10)
+        : undefined;
+
+      const globalDefaults: GlobalTimeoutDefaults = {
+        defaultTimeout:
+          cfg.mcp_defaults?.tool_call_timeout ??
+          envDefaultTimeout ??
+          BUILTIN_DEFAULT_TOOL_CALL_TIMEOUT,
+        maxTimeout:
+          cfg.mcp_defaults?.max_tool_call_timeout ??
+          envMaxTimeout ??
+          BUILTIN_MAX_TOOL_CALL_TIMEOUT,
+      };
 
       await Promise.all(
         Object.entries(config).map(async ([key, mcp]) => {
@@ -67,6 +115,17 @@ export namespace MCP {
 
           status[key] = result.status;
 
+          // Store timeout configuration for this MCP server
+          // Per-server timeout overrides global default, but is capped at global max
+          const defaultTimeout = Math.min(
+            mcp.tool_call_timeout ?? globalDefaults.defaultTimeout,
+            globalDefaults.maxTimeout
+          );
+          timeoutConfigs[key] = {
+            defaultTimeout,
+            toolTimeouts: mcp.tool_timeouts ?? {},
+          };
+
           if (result.mcpClient) {
             clients[key] = result.mcpClient;
           }
@@ -75,6 +134,8 @@ export namespace MCP {
       return {
         status,
         clients,
+        timeoutConfigs,
+        globalDefaults,
       };
     },
     async (state) => {
@@ -310,4 +371,68 @@ export namespace MCP {
     }
     return result;
   }
+
+  /**
+   * Get the timeout configuration for all MCP servers
+   */
+  export async function getTimeoutConfigs(): Promise<
+    Record<string, TimeoutConfig>
+  > {
+    const s = await state();
+    return s.timeoutConfigs;
+  }
+
+  /**
+   * Get the global timeout defaults from configuration
+   */
+  export async function getGlobalDefaults(): Promise<GlobalTimeoutDefaults> {
+    const s = await state();
+    return s.globalDefaults;
+  }
+
+  /**
+   * Get the timeout for a specific MCP tool
+   * @param fullToolName The full tool name in format "serverName_toolName"
+   * @returns Timeout in milliseconds
+   */
+  export async function getToolTimeout(fullToolName: string): Promise<number> {
+    const s = await state();
+    const maxTimeout = s.globalDefaults.maxTimeout;
+
+    // Parse the full tool name to extract server name and tool name
+    // Format: serverName_toolName (where both are sanitized)
+    const underscoreIndex = fullToolName.indexOf('_');
+    if (underscoreIndex === -1) {
+      return s.globalDefaults.defaultTimeout;
+    }
+
+    const serverName = fullToolName.substring(0, underscoreIndex);
+    const toolName = fullToolName.substring(underscoreIndex + 1);
+
+    // Find the server config (need to handle sanitization)
+    const config = s.timeoutConfigs[serverName];
+    if (!config) {
+      // Try to find by iterating (in case of sanitization differences)
+      for (const [key, cfg] of Object.entries(s.timeoutConfigs)) {
+        const sanitizedKey = key.replace(/[^a-zA-Z0-9_-]/g, '_');
+        if (sanitizedKey === serverName) {
+          // Check for per-tool timeout override
+          const perToolTimeout = cfg.toolTimeouts[toolName];
+          if (perToolTimeout !== undefined) {
+            return Math.min(perToolTimeout, maxTimeout);
+          }
+          return cfg.defaultTimeout;
+        }
+      }
+      return s.globalDefaults.defaultTimeout;
+    }
+
+    // Check for per-tool timeout override
+    const perToolTimeout = config.toolTimeouts[toolName];
+    if (perToolTimeout !== undefined) {
+      return Math.min(perToolTimeout, maxTimeout);
+    }
+
+    return config.defaultTimeout;
+  }
 }

package/src/session/message-v2.ts

@@ -42,6 +42,22 @@ export namespace MessageV2 {
   );
   export type APIError = z.infer<typeof APIError.Schema>;
 
+  /**
+   * Socket connection error - typically caused by Bun's 10-second idle timeout
+   * in Bun.serve() context. These errors are transient and should be retried.
+   * See: https://github.com/oven-sh/bun/issues/14439
+   */
+  export const SocketConnectionError = NamedError.create(
+    'SocketConnectionError',
+    z.object({
+      message: z.string(),
+      isRetryable: z.literal(true),
+    })
+  );
+  export type SocketConnectionError = z.infer<
+    typeof SocketConnectionError.Schema
+  >;
+
   const PartBase = z.object({
     id: z.string(),
     sessionID: z.string(),
@@ -787,11 +803,24 @@ export namespace MessageV2 {
           },
           { cause: e }
         ).toObject();
-      case e instanceof Error:
+      case e instanceof Error: {
+        const message = e.message || e.toString();
+        // Detect Bun socket connection errors (known Bun issue with 10s idle timeout)
+        // See: https://github.com/oven-sh/bun/issues/14439
+        const isSocketError =
+          message.includes('socket connection was closed') ||
+          message.includes('closed unexpectedly');
+        if (isSocketError) {
+          return new MessageV2.SocketConnectionError(
+            { message, isRetryable: true },
+            { cause: e }
+          ).toObject();
+        }
         return new NamedError.Unknown(
           { message: e.toString() },
           { cause: e }
         ).toObject();
+      }
       default:
         return new NamedError.Unknown(
           { message: JSON.stringify(e) },

package/src/session/processor.ts

@@ -314,9 +314,28 @@ export namespace SessionProcessor {
             const error = MessageV2.fromError(e, {
               providerID: input.providerID,
             });
-            if (error?.name === 'APIError' && error.data.isRetryable) {
+
+            // Check if error is retryable (APIError or SocketConnectionError)
+            const isRetryableAPIError =
+              error?.name === 'APIError' && error.data.isRetryable;
+            const isRetryableSocketError =
+              error?.name === 'SocketConnectionError' &&
+              error.data.isRetryable &&
+              attempt < SessionRetry.SOCKET_ERROR_MAX_RETRIES;
+
+            if (isRetryableAPIError || isRetryableSocketError) {
               attempt++;
-              const delay = SessionRetry.delay(error, attempt);
+              // Use socket-specific delay for socket errors
+              const delay =
+                error?.name === 'SocketConnectionError'
+                  ? SessionRetry.socketErrorDelay(attempt)
+                  : SessionRetry.delay(error, attempt);
+              log.info(() => ({
+                message: 'retrying',
+                errorType: error?.name,
+                attempt,
+                delay,
+              }));
               SessionStatus.set(input.sessionID, {
                 type: 'retry',
                 attempt,

package/src/session/prompt.ts

@@ -34,6 +34,7 @@ import { mergeDeep, pipe } from 'remeda';
 import { ToolRegistry } from '../tool/registry';
 import { Wildcard } from '../util/wildcard';
 import { MCP } from '../mcp';
+import { withTimeout } from '../util/timeout';
 import { ReadTool } from '../tool/read';
 import { ListTool } from '../tool/ls';
 import { FileTime } from '../file/time';
@@ -877,7 +878,28 @@ export namespace SessionPrompt {
       const execute = item.execute;
       if (!execute) continue;
       item.execute = async (args, opts) => {
-        const result = await execute(args, opts);
+        // Get timeout for this specific tool
+        const timeout = await MCP.getToolTimeout(key);
+
+        // Wrap the execute call with timeout to prevent indefinite hangs
+        let result;
+        try {
+          result = await withTimeout(execute(args, opts), timeout);
+        } catch (error) {
+          // Check if it's a timeout error
+          if (
+            error instanceof Error &&
+            error.message.includes('timed out after')
+          ) {
+            const timeoutSec = Math.round(timeout / 1000);
+            throw new Error(
+              `MCP tool "${key}" timed out after ${timeoutSec} seconds. ` +
+                `The operation did not complete within the configured timeout. ` +
+                `You can increase the timeout in the MCP server configuration using tool_call_timeout or tool_timeouts.`
+            );
+          }
+          throw error;
+        }
 
         const textParts: string[] = [];
         const attachments: MessageV2.FilePart[] = [];

package/src/session/retry.ts

@@ -6,6 +6,13 @@ export namespace SessionRetry {
   export const RETRY_BACKOFF_FACTOR = 2;
   export const RETRY_MAX_DELAY_NO_HEADERS = 30_000; // 30 seconds
 
+  // Socket connection error retry configuration
+  // Bun's fetch() has a known 10-second idle timeout issue
+  // See: https://github.com/oven-sh/bun/issues/14439
+  export const SOCKET_ERROR_MAX_RETRIES = 3;
+  export const SOCKET_ERROR_INITIAL_DELAY = 1000; // 1 second
+  export const SOCKET_ERROR_BACKOFF_FACTOR = 2;
+
   export async function sleep(ms: number, signal: AbortSignal): Promise<void> {
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(resolve, ms);
@@ -53,4 +60,15 @@ export namespace SessionRetry {
       RETRY_MAX_DELAY_NO_HEADERS
     );
   }
+
+  /**
+   * Calculate delay for socket connection error retries.
+   * Uses exponential backoff: 1s, 2s, 4s, etc.
+   */
+  export function socketErrorDelay(attempt: number): number {
+    return (
+      SOCKET_ERROR_INITIAL_DELAY *
+      Math.pow(SOCKET_ERROR_BACKOFF_FACTOR, attempt - 1)
+    );
+  }
 }