@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/zed-integration/zed-terminal-setup.ts

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as acp from '@agentclientprotocol/sdk';
+import {
+  type Config,
+  type DebugLogger,
+  type MessageBus,
+  CoreMessageBusAdapter,
+  CoreShellToolHostAdapter,
+  CoreToolRegistryHostAdapter,
+} from '@vybestack/llxprt-code-core';
+import { ShellTool, ToolRegistry } from '@vybestack/llxprt-code-tools';
+import { AcpTerminalShellHost } from './acp-terminal-shell-host.js';
+import { TerminalManager } from './zed-terminal-manager.js';
+
+export interface ZedTerminalSetup {
+  readonly registry: ToolRegistry;
+  readonly terminals: TerminalManager;
+}
+
+export function buildZedTerminalSetup(
+  sessionId: string,
+  config: Config,
+  baseRegistry: ToolRegistry,
+  connection: acp.AgentSideConnection,
+  logger: DebugLogger,
+  messageBus: MessageBus,
+): ZedTerminalSetup {
+  const outputLimit = config.getEphemeralSetting('tool-output-max-tokens');
+  const terminals = new TerminalManager(
+    sessionId,
+    connection,
+    config.getTargetDir(),
+    (update) => connection.sessionUpdate({ sessionId, update }),
+    logger,
+    typeof outputLimit === 'number' &&
+    Number.isFinite(outputLimit) &&
+    outputLimit > 0
+      ? outputLimit
+      : undefined,
+  );
+  const messageBusAdapter = new CoreMessageBusAdapter(messageBus);
+  const registry = new ToolRegistry(
+    new CoreToolRegistryHostAdapter(config),
+    messageBusAdapter,
+  );
+  const baseTools = baseRegistry.getAllTools();
+  let hasShellTool = false;
+  for (const tool of baseTools) {
+    if (tool.name === ShellTool.Name) {
+      hasShellTool = true;
+      continue;
+    }
+    registry.registerTool(tool);
+  }
+  if (hasShellTool) {
+    registry.registerTool(
+      new ShellTool(
+        new AcpTerminalShellHost(
+          new CoreShellToolHostAdapter(config),
+          terminals,
+        ),
+        messageBusAdapter,
+      ),
+    );
+  }
+  return { registry, terminals };
+}

package/src/zed-integration/zed-test-helpers.ts

@@ -22,7 +22,10 @@ export type ConfirmationCapture = {
   requiresUserConfirmation?: boolean;
 };
 
-export function buildScriptedAgent(nextEvents: () => readonly AgentEvent[]): {
+export function buildScriptedAgent(
+  nextEvents: () => readonly AgentEvent[],
+  toolKinds: Readonly<Record<string, string>> = {},
+): {
   agent: Agent;
   confirmations: ConfirmationCapture[];
 } {
@@ -37,6 +40,8 @@ export function buildScriptedAgent(nextEvents: () => readonly AgentEvent[]): {
     setApprovalMode: vi.fn(),
     dispose: vi.fn().mockResolvedValue(undefined),
     tools: {
+      get: (name: string) =>
+        Object.hasOwn(toolKinds, name) ? { kind: toolKinds[name] } : undefined,
       respondToConfirmation: (
         confirmationId: string,
         decision: ToolConfirmationOutcome,
@@ -63,13 +68,93 @@ export function buildScriptedAgent(nextEvents: () => readonly AgentEvent[]): {
   return { agent, confirmations };
 }
 
-export function buildFakeAgent(events: readonly AgentEvent[]): {
+/**
+ * Like {@link buildScriptedAgent} but the stream blocks after yielding all
+ * events until the abort signal fires.  Used to test cancel/dispose while a
+ * prompt turn is still in-flight.
+ */
+export function buildBlockingScriptedAgent(
+  nextEvents: () => readonly AgentEvent[],
+  toolKinds: Readonly<Record<string, string>> = {},
+): {
+  agent: Agent;
+  confirmations: ConfirmationCapture[];
+} {
+  const confirmations: ConfirmationCapture[] = [];
+  const agent = {
+    async *stream(_input: unknown, opts?: unknown): AsyncIterable<AgentEvent> {
+      for (const e of nextEvents()) {
+        yield e;
+      }
+      const signal = (opts as { signal?: AbortSignal } | undefined)?.signal;
+      if (signal === undefined) {
+        throw new Error(
+          'buildBlockingScriptedAgent requires an AbortSignal in stream opts',
+        );
+      }
+      if (!signal.aborted) {
+        await new Promise<void>((resolve) => {
+          signal.addEventListener('abort', () => resolve(), { once: true });
+        });
+      }
+    },
+    getApprovalMode: (): ApprovalMode => 'default' as ApprovalMode,
+    setApprovalMode: vi.fn(),
+    dispose: vi.fn().mockResolvedValue(undefined),
+    tools: {
+      get: (name: string) =>
+        Object.hasOwn(toolKinds, name) ? { kind: toolKinds[name] } : undefined,
+      respondToConfirmation: (
+        confirmationId: string,
+        decision: ToolConfirmationOutcome,
+        payload?: ToolConfirmationPayload,
+        requiresUserConfirmation?: boolean,
+      ) => {
+        confirmations.push({
+          confirmationId,
+          decision,
+          ...(payload === undefined ? {} : { payload }),
+          ...(requiresUserConfirmation === undefined
+            ? {}
+            : { requiresUserConfirmation }),
+        });
+      },
+      onConfirmationRequest: () => () => {},
+      onToolUpdate: () => () => {},
+      setEditorCallbacks: () => {},
+      setEnabled: vi.fn().mockResolvedValue(undefined),
+      list: () => [],
+      keys: {},
+    },
+  } as unknown as Agent;
+  return { agent, confirmations };
+}
+
+export function buildFakeAgent(
+  events: readonly AgentEvent[],
+  toolKinds: Readonly<Record<string, string>> = {},
+): {
+  agent: Agent;
+  confirmations: ConfirmationCapture[];
+} {
+  return buildScriptedAgent(() => events, toolKinds);
+}
+
+export function buildBlockingFakeAgent(
+  events: readonly AgentEvent[],
+  toolKinds: Readonly<Record<string, string>> = {},
+): {
   agent: Agent;
   confirmations: ConfirmationCapture[];
 } {
-  return buildScriptedAgent(() => events);
+  return buildBlockingScriptedAgent(() => events, toolKinds);
 }
 
+export type FakeTerminalHandle = Pick<
+  acp.TerminalHandle,
+  'id' | 'currentOutput' | 'waitForExit' | 'kill' | 'release'
+>;
+
 export class RecordingConnection {
   readonly messages: Array<
     | { kind: 'sessionUpdate'; update: acp.SessionUpdate }
@@ -84,6 +169,142 @@ export class RecordingConnection {
     optionId: ToolConfirmationOutcome.ProceedOnce,
   };
   private permissionRejection: Error | null = null;
+  private sessionUpdateFailAfter: number | null = null;
+  private sessionUpdateError: Error | null = null;
+  private sessionUpdateCalls = 0;
+
+  // --- Terminal test-double state ---
+
+  readonly createTerminalCalls: Array<{
+    command: string;
+    cwd?: string | null;
+    sessionId: string;
+    args?: string[];
+    env?: Array<{ name: string; value: string }>;
+    outputByteLimit?: number | null;
+  }> = [];
+
+  killCalls = 0;
+  releaseCalls = 0;
+
+  private terminalOutput = '';
+  private terminalExitDelayed = false;
+  private terminalExitResolvers = new Map<string, Array<() => void>>();
+  private terminalCreationWaiters = new Set<() => void>();
+  private terminalContentWaiters = new Set<() => void>();
+
+  setTerminalOutput(output: string): void {
+    this.terminalOutput = output;
+  }
+
+  delayTerminalExit(): void {
+    this.terminalExitDelayed = true;
+  }
+
+  resolveDelayedTerminalExit(terminalId?: string): void {
+    if (terminalId !== undefined) {
+      const resolvers = this.terminalExitResolvers.get(terminalId);
+      if (resolvers !== undefined) {
+        this.terminalExitResolvers.delete(terminalId);
+        for (const fn of resolvers) {
+          fn();
+        }
+      }
+      if (this.terminalExitResolvers.size === 0) {
+        this.terminalExitDelayed = false;
+      }
+      return;
+    }
+    for (const resolvers of this.terminalExitResolvers.values()) {
+      for (const fn of resolvers) {
+        fn();
+      }
+    }
+    this.terminalExitResolvers.clear();
+    this.terminalExitDelayed = false;
+  }
+
+  waitForTerminalProcessCreated(): Promise<void> {
+    if (this.createTerminalCalls.length > 0) return Promise.resolve();
+    return new Promise<void>((resolve) => {
+      const waiter = (): void => {
+        this.terminalCreationWaiters.delete(waiter);
+        resolve();
+      };
+      this.terminalCreationWaiters.add(waiter);
+    });
+  }
+
+  /**
+   * Resolves once at least one terminal content update (tool_call_update with
+   * a `terminal` content block) has been recorded — i.e., the Session has
+   * created and registered a terminal.
+   */
+  waitForTerminalCreated(timeoutMs = 5000): Promise<void> {
+    if (this.hasTerminalContentUpdate()) return Promise.resolve();
+    return new Promise<void>((resolve, reject) => {
+      const waiter = (): void => {
+        cleanup();
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error('waitForTerminalCreated timed out'));
+      }, timeoutMs);
+      const cleanup = (): void => {
+        clearTimeout(timer);
+        this.terminalContentWaiters.delete(waiter);
+      };
+      this.terminalContentWaiters.add(waiter);
+      if (this.hasTerminalContentUpdate()) {
+        waiter();
+      }
+    });
+  }
+
+  private hasTerminalContentUpdate(): boolean {
+    return this.messages.some(
+      (m) =>
+        m.kind === 'sessionUpdate' &&
+        m.update.sessionUpdate === 'tool_call_update' &&
+        (m.update.content ?? []).some((c) => c.type === 'terminal'),
+    );
+  }
+
+  /**
+   * Arms sessionUpdate to REJECT starting with the (0-based) `afterCount`-th
+   * call: the first `afterCount` notifications are still recorded/delivered
+   * normally, then every subsequent call throws `error`. Used to simulate a
+   * dead/failing transport mid history-replay (issue #1604 FINDING A) so strict
+   * streamHistory delivery and loadSession cleanup can be asserted. `afterCount:
+   * 0` fails the very first update.
+   */
+  failSessionUpdateAfter(afterCount: number, error: Error): void {
+    this.sessionUpdateFailAfter = afterCount;
+    this.sessionUpdateError = error;
+  }
+
+  /**
+   * Disarms {@link failSessionUpdateAfter} and resets the call counter so a
+   * SUBSEQUENT operation on the same connection delivers normally — used to
+   * simulate a transport that has recovered before a retry load (issue #1604
+   * FINDING A partial-failure test).
+   */
+  clearSessionUpdateFailure(): void {
+    this.sessionUpdateFailAfter = null;
+    this.sessionUpdateError = null;
+    this.sessionUpdateCalls = 0;
+  }
+
+  clearSessionInfoUpdates(): void {
+    const retained = this.messages.filter(
+      (message) =>
+        message.kind !== 'sessionUpdate' ||
+        message.update.sessionUpdate !== 'session_info_update',
+    );
+    this.messages.splice(0, this.messages.length, ...retained);
+  }
+
   private gatedDeferred: {
     resolve: (o: acp.RequestPermissionOutcome) => void;
     promise: Promise<acp.RequestPermissionOutcome>;
@@ -125,7 +346,24 @@ export class RecordingConnection {
 
   sessionUpdate: Mock = vi.fn(
     async (params: acp.SessionNotification): Promise<void> => {
+      const shouldFail =
+        this.sessionUpdateFailAfter !== null &&
+        this.sessionUpdateCalls >= this.sessionUpdateFailAfter;
+      this.sessionUpdateCalls++;
+      if (shouldFail) {
+        throw (
+          this.sessionUpdateError ??
+          new Error('sessionUpdate transport failure')
+        );
+      }
       this.messages.push({ kind: 'sessionUpdate', update: params.update });
+      if (this.hasTerminalContentUpdate()) {
+        const waiters = [...this.terminalContentWaiters];
+        this.terminalContentWaiters.clear();
+        for (const resolve of waiters) {
+          resolve();
+        }
+      }
     },
   );
 
@@ -161,10 +399,111 @@ export class RecordingConnection {
     },
   );
 
+  createTerminal: Mock = vi.fn(
+    async (params: acp.CreateTerminalRequest): Promise<FakeTerminalHandle> => {
+      const call = {
+        command: params.command,
+        cwd: params.cwd,
+        sessionId: params.sessionId,
+        ...(params.args !== undefined ? { args: params.args } : {}),
+        ...(params.env !== undefined ? { env: params.env } : {}),
+        ...(params.outputByteLimit !== undefined
+          ? { outputByteLimit: params.outputByteLimit }
+          : {}),
+      };
+      this.createTerminalCalls.push(call);
+      const waiters = [...this.terminalCreationWaiters];
+      this.terminalCreationWaiters.clear();
+      for (const resolve of waiters) {
+        resolve();
+      }
+      const terminalId = `terminal-${this.createTerminalCalls.length}`;
+      return this.buildFakeTerminalHandle(terminalId);
+    },
+  );
+
+  private buildFakeTerminalHandle(terminalId: string): FakeTerminalHandle {
+    const handle = {
+      id: terminalId,
+      currentOutput: vi.fn(async () => ({
+        output: this.terminalOutput,
+        exitStatus: null,
+        truncated: false,
+      })),
+      waitForExit: vi.fn(async () => {
+        if (this.terminalExitDelayed) {
+          await new Promise<void>((resolve) => {
+            const existing = this.terminalExitResolvers.get(terminalId);
+            if (existing !== undefined) {
+              existing.push(resolve);
+            } else {
+              this.terminalExitResolvers.set(terminalId, [resolve]);
+            }
+          });
+        }
+        return { exitCode: 0, signal: null };
+      }),
+      kill: vi.fn(async () => {
+        this.killCalls += 1;
+        this.resolveDelayedTerminalExit(terminalId);
+        return {};
+      }),
+      release: vi.fn(async () => {
+        this.releaseCalls += 1;
+        this.resolveDelayedTerminalExit(terminalId);
+        return {};
+      }),
+    };
+    return handle;
+  }
+
+  /**
+   * Returns content-focused session updates, excluding infrastructure
+   * notifications (`available_commands_update` and `session_info_update`).
+   * Use {@link sessionInfoUpdates} for title/updatedAt assertions and
+   * {@link availableCommandUpdates} for command-registry assertions.
+   */
   onlySessionUpdates(): acp.SessionUpdate[] {
     return this.messages
       .filter((m) => m.kind === 'sessionUpdate')
-      .map((m) => (m as { update: acp.SessionUpdate }).update);
+      .map((m) => (m as { update: acp.SessionUpdate }).update)
+      .filter(
+        (update) =>
+          update.sessionUpdate !== 'available_commands_update' &&
+          update.sessionUpdate !== 'session_info_update',
+      );
+  }
+
+  sessionInfoUpdates(): Array<
+    Extract<acp.SessionUpdate, { sessionUpdate: 'session_info_update' }>
+  > {
+    return this.messages
+      .filter((m) => m.kind === 'sessionUpdate')
+      .map((m) => (m as { update: acp.SessionUpdate }).update)
+      .filter(
+        (
+          update,
+        ): update is Extract<
+          acp.SessionUpdate,
+          { sessionUpdate: 'session_info_update' }
+        > => update.sessionUpdate === 'session_info_update',
+      );
+  }
+
+  availableCommandUpdates(): Array<
+    Extract<acp.SessionUpdate, { sessionUpdate: 'available_commands_update' }>
+  > {
+    return this.messages
+      .filter((m) => m.kind === 'sessionUpdate')
+      .map((m) => (m as { update: acp.SessionUpdate }).update)
+      .filter(
+        (
+          update,
+        ): update is Extract<
+          acp.SessionUpdate,
+          { sessionUpdate: 'available_commands_update' }
+        > => update.sessionUpdate === 'available_commands_update',
+      );
   }
 
   sessionUpdateKinds(): string[] {
@@ -179,6 +518,7 @@ export function buildMinimalConfig(): Config {
     getApprovalMode: () => 'default' as ApprovalMode,
     setApprovalMode: () => {},
     getTargetDir: () => '/project',
+    getProjectRoot: () => '/project',
     getFileService: () => ({ shouldIgnoreFile: () => false }),
     getFileFilteringOptions: () => ({
       respectGitIgnore: true,
@@ -187,6 +527,11 @@ export function buildMinimalConfig(): Config {
     getEnableRecursiveFileSearch: () => false,
     getFileSystemService: () => ({ readTextFile: async () => '' }),
     getMaxSessionTurns: () => 50,
+    // usage_update path (issue #1607): sendUsageUpdate resolves the context
+    // window via getTokenLimitForConfiguredContext(model, config).
+    getModel: () => 'test-model',
+    getContentGeneratorConfig: () => undefined,
+    getSessionRecordingService: () => undefined,
   } as unknown as Config;
 }
 

package/src/zed-integration/zed-tool-handler.ts

@@ -24,7 +24,11 @@ type Dict = Readonly<Record<string, unknown>>;
 export async function emitToolCallStart(
   call: AgentToolCall,
   sendUpdate: SendUpdateFn,
+  registeredKind?: string,
 ): Promise<void> {
+  // rawInput carries the tool arguments for parity with the replay start shape
+  // (zed-session-replay.ts buildToolCallStart) and because ACP recommends it on
+  // tool_call for client-side debugging (conformance tooling flags its absence).
   await sendUpdate({
     sessionUpdate: 'tool_call',
     toolCallId: call.id,
@@ -32,13 +36,15 @@ export async function emitToolCallStart(
     title: call.name,
     content: [],
     locations: buildToolLocations(call.args),
-    kind: inferToolKind(call.name),
+    kind: resolveToolKind(call.name, registeredKind),
+    rawInput: call.args,
   });
 }
 
 export async function emitToolStatus(
   update: ToolUpdate,
   sendUpdate: SendUpdateFn,
+  registeredKind?: string,
 ): Promise<void> {
   const status = mapToolUpdateStatus(update.status);
   if (status === null) {
@@ -50,12 +56,14 @@ export async function emitToolStatus(
     toolCallId: update.id,
     status,
     content: text ? textContent(text) : [],
+    kind: resolveToolKind(update.name, registeredKind),
   });
 }
 
 export async function emitToolResult(
   result: AgentToolResult,
   sendUpdate: SendUpdateFn,
+  registeredKind?: string,
 ): Promise<void> {
   const isError = result.isError === true;
   const content = isError
@@ -66,6 +74,7 @@ export async function emitToolResult(
     toolCallId: result.id,
     status: isError ? 'failed' : 'completed',
     content,
+    kind: resolveToolKind(result.name, registeredKind),
   });
 }
 
@@ -85,6 +94,7 @@ export async function requestToolConfirmation(
   name: string,
   details: unknown,
   connection: acp.AgentSideConnection,
+  registeredKind?: string,
 ): Promise<PermissionRoundTripResult> {
   const confirmationDetails = coerceConfirmationDetails(details);
   const params: acp.RequestPermissionRequest = {
@@ -99,7 +109,7 @@ export async function requestToolConfirmation(
       title: confirmationDetails?.title ?? name,
       content: buildConfirmationContent(confirmationDetails),
       locations: buildConfirmationLocations(confirmationDetails),
-      kind: inferToolKind(name),
+      kind: resolveToolKind(name, registeredKind),
     },
   };
   return parsePermissionOutcome(await connection.requestPermission(params));
@@ -231,7 +241,7 @@ function buildConfirmationLocations(
   return path === undefined ? [] : [buildLocation(path)];
 }
 
-function buildToolLocations(args: Dict): acp.ToolCallLocation[] {
+export function buildToolLocations(args: Dict): acp.ToolCallLocation[] {
   const paths = [
     firstString(args, [
       'absolute_path',
@@ -319,7 +329,7 @@ function mapToolUpdateStatus(
   }
 }
 
-const TOOL_KIND_BY_NAME = new Map<string, acp.ToolKind>([
+export const TOOL_KIND_BY_NAME: ReadonlyMap<string, acp.ToolKind> = new Map([
   ...[
     'read_file',
     'read_line_range',
@@ -348,12 +358,44 @@ const TOOL_KIND_BY_NAME = new Map<string, acp.ToolKind>([
   ...['run_shell_command', 'execute_command', 'exec'].map(
     (name) => [name, 'execute'] as const,
   ),
+  ...['direct_web_fetch', 'exa_web_search', 'web_fetch', 'web_search'].map(
+    (name) => [name, 'fetch'] as const,
+  ),
+  ...['todo_write', 'todo_read', 'todo_pause', 'save_memory'].map(
+    (name) => [name, 'think'] as const,
+  ),
 ]);
 
-function inferToolKind(name: string): acp.ToolKind | undefined {
+export function inferToolKind(name: string): acp.ToolKind | undefined {
   return TOOL_KIND_BY_NAME.get(name);
 }
 
+export const ACP_TOOL_KINDS: ReadonlySet<string> = new Set<acp.ToolKind>([
+  'read',
+  'edit',
+  'delete',
+  'move',
+  'search',
+  'execute',
+  'think',
+  'fetch',
+  'switch_mode',
+  'other',
+]);
+
+export function toAcpToolKind(kind: string | undefined): acp.ToolKind {
+  return kind !== undefined && ACP_TOOL_KINDS.has(kind)
+    ? (kind as acp.ToolKind)
+    : 'other';
+}
+
+function resolveToolKind(
+  name: string,
+  registeredKind: string | undefined,
+): acp.ToolKind {
+  return toAcpToolKind(registeredKind ?? inferToolKind(name));
+}
+
 function asRecord(value: unknown): Dict | null {
   return value !== null && typeof value === 'object' ? (value as Dict) : null;
 }