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

package/src/zed-integration/acp-types.ts

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as acp from '@agentclientprotocol/sdk';
+
+/**
+ * The pinned ACP SDK (0.14.1) does not yet export `CloseSessionRequest`,
+ * `DeleteSessionRequest`, or their responses, nor does its
+ * `ClientCapabilities` type include the `session` field used for
+ * config-option gating.  These local type aliases keep the integration
+ * strongly-typed without resorting to `any`.
+ */
+
+export interface CloseSessionRequest {
+  readonly sessionId: acp.SessionId;
+}
+
+export type CloseSessionResponse = Record<string, never>;
+
+export interface DeleteSessionRequest {
+  readonly sessionId: acp.SessionId;
+}
+
+export type DeleteSessionResponse = Record<string, never>;
+
+export type ClientCapabilitiesWithSession = NonNullable<
+  acp.InitializeRequest['clientCapabilities']
+> & {
+  readonly session?: {
+    readonly configOptions?: boolean;
+  };
+};

package/src/zed-integration/fileSystemService.ts

@@ -14,7 +14,7 @@ export class AcpFileSystemService implements FileSystemService {
   constructor(
     private readonly connection: acp.AgentSideConnection,
     private readonly sessionId: string,
-    private readonly capabilities: acp.FileSystemCapability,
+    private readonly capabilities: acp.FileSystemCapabilities,
     private readonly fallback: FileSystemService,
   ) {}
 

package/src/zed-integration/runZedIntegration.ts

@@ -0,0 +1,142 @@
+/**
+ * @license
+ * Copyright 2025 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { type Config, createInkStdio } from '@vybestack/llxprt-code-core';
+import { DebugLogger } from '@vybestack/llxprt-code-telemetry';
+import * as acp from '@agentclientprotocol/sdk';
+import { Readable, Writable } from 'node:stream';
+import * as process from 'node:process';
+import { setCliRuntimeContext } from '@vybestack/llxprt-code-providers/runtime.js';
+import type { LoadedSettings } from '../config/settings.js';
+import { runExitCleanup } from '../utils/cleanup.js';
+import { ZedAgent } from './zedIntegration.js';
+
+const DISPOSAL_SIGNALS: readonly NodeJS.Signals[] = ['SIGINT', 'SIGTERM'];
+
+/**
+ * Listener target for process-signal-driven disposal. Injectable so tests can
+ * drive the disposal path without sending real OS signals.
+ */
+export type SignalListenerTarget = {
+  on(signal: NodeJS.Signals, listener: () => void): unknown;
+  off(signal: NodeJS.Signals, listener: () => void): unknown;
+};
+
+/**
+ * Builds the disposal action performed when a disposal signal fires.
+ *
+ * The transport-ownership rule: {@link ndJsonStream} calls
+ * `input.getReader()` on the web stream, which **locks** it. Calling
+ * `.cancel()` on a locked `ReadableStream` rejects with `TypeError: Cannot
+ * cancel a readable stream that is locked`, so disposal silently no-ops and
+ * `connection.closed` never resolves — the process hangs.
+ *
+ * Instead, we destroy the **owned** Node.js `Readable` source that
+ * `Readable.toWeb` wraps. Destroying the source propagates an abort/EOF into
+ * the web stream's active reader, which the SDK's `ndJsonStream` read loop
+ * detects (either a stream-end `{ done: true }` chunk or an underlying error).
+ * That causes the SDK to call `controller.close()` / `controller.error()`,
+ * resolving `connection.closed` naturally so the `finally` cleanup runs.
+ */
+export function buildSignalDisposalHandler(
+  source: Readable,
+  logger: Pick<DebugLogger, 'debug'>,
+): () => void {
+  return () => {
+    try {
+      // destroy() is idempotent and safe to call on an already-ended stream.
+      // It propagates to the web stream via Readable.toWeb's adapter, causing
+      // the SDK's locked reader to observe the end/error.
+      source.destroy();
+    } catch (error) {
+      logger.debug(
+        () => `Signal-driven transport destroy failed: ${String(error)}`,
+      );
+    }
+  };
+}
+
+/**
+ * Installs process-signal listeners that trigger graceful disposal. Returns a
+ * disposer that removes the listeners.
+ *
+ * Registers listeners so Node's default SIGINT/SIGTERM behavior (immediate
+ * process termination) is suppressed long enough for the `finally` cleanup in
+ * {@link runZedIntegration} to run.
+ */
+export function installDisposalSignalHandlers(
+  onSignal: () => void,
+  signals: readonly NodeJS.Signals[] = DISPOSAL_SIGNALS,
+  target: SignalListenerTarget = process,
+): () => void {
+  for (const signal of signals) {
+    target.on(signal, onSignal);
+  }
+  return () => {
+    for (const signal of signals) {
+      target.off(signal, onSignal);
+    }
+  };
+}
+
+async function cleanupAgents(
+  agents: readonly ZedAgent[],
+  logger: DebugLogger,
+): Promise<void> {
+  const disposalResults = await Promise.allSettled(
+    agents.map((agent) => agent.disposeAll()),
+  );
+  const rejected = disposalResults.filter(
+    (result): result is PromiseRejectedResult => result.status === 'rejected',
+  );
+  for (const result of rejected) {
+    logger.warn(() => `Zed agent cleanup failed: ${String(result.reason)}`);
+  }
+  try {
+    await runExitCleanup();
+  } catch (cleanupError) {
+    logger.debug(() => `Exit cleanup failed: ${String(cleanupError)}`);
+  }
+}
+
+export async function runZedIntegration(
+  config: Config,
+  settings: LoadedSettings,
+): Promise<void> {
+  const logger = new DebugLogger('llxprt:zed-integration');
+  logger.debug(() => 'Starting Zed integration');
+  const { stdout: workingStdout } = createInkStdio();
+  const stdout = Writable.toWeb(workingStdout) as WritableStream;
+  // Keep the owned Node.js Readable reference. Destroying this source (not the
+  // locked web stream) is the only way to make the ACP ndJsonStream reader
+  // observe EOF/abort so connection.closed settles.
+  const stdinSource = process.stdin;
+  const stdin = Readable.toWeb(stdinSource) as ReadableStream<Uint8Array>;
+  setCliRuntimeContext(config.getSettingsService(), config, {
+    runtimeId: 'cli.runtime.zed',
+    metadata: { source: 'zed-integration', stage: 'bootstrap' },
+    allowDefaultHandoff: true,
+  });
+  const agents: ZedAgent[] = [];
+  const removeSignalHandlers = installDisposalSignalHandlers(
+    buildSignalDisposalHandler(stdinSource, logger),
+  );
+  try {
+    const stream = acp.ndJsonStream(stdout, stdin);
+    const connection = new acp.AgentSideConnection((conn) => {
+      const agent = new ZedAgent(config, settings, conn);
+      agents.push(agent);
+      return agent;
+    }, stream);
+    await connection.closed;
+  } catch (error) {
+    logger.warn(() => `Zed agent connection error: ${error}`);
+    throw error;
+  } finally {
+    removeSignalHandlers();
+    await cleanupAgents(agents, logger);
+  }
+}

package/src/zed-integration/zed-agent-event-handler.ts

@@ -0,0 +1,179 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as acp from '@agentclientprotocol/sdk';
+import type { AgentEvent } from '@vybestack/llxprt-code-agents';
+import { DebugLogger } from '@vybestack/llxprt-code-core';
+import {
+  extractThoughtText,
+  mapDoneReasonToStopReason,
+  translateErrorEvent,
+  translateIdleTimeout,
+} from './zed-helpers.js';
+import type { StreamBatcher } from './zed-stream-batcher.js';
+import {
+  emitToolCallStart,
+  emitToolResult,
+  emitToolStatus,
+} from './zed-tool-handler.js';
+
+const logger = new DebugLogger('llxprt:zed-integration:agent-events');
+
+/**
+ * Flushes pending batched chunks without letting a flush failure replace the
+ * original event context, so an 'error' event is not swallowed and a 'done'
+ * stop reason is not dropped by a flush exception.
+ */
+async function safeFlush(batcher: StreamBatcher): Promise<void> {
+  try {
+    await batcher.flush();
+  } catch (error) {
+    logger.debug(() => `Stream flush failed: ${String(error)}`);
+  }
+}
+
+interface AgentEventHandlers {
+  sendUpdate(update: acp.SessionUpdate): Promise<void>;
+  sendUsage(
+    usage: Extract<AgentEvent, { type: 'usage' }>['usage'],
+  ): Promise<void>;
+  handleConfirmation(
+    event: Extract<AgentEvent, { type: 'tool-confirmation' }>,
+  ): Promise<void>;
+  resolveToolKind(toolName: string): string | undefined;
+}
+
+export async function handleZedAgentEvent(
+  event: AgentEvent,
+  batcher: StreamBatcher,
+  handlers: AgentEventHandlers,
+): Promise<acp.StopReason | null> {
+  switch (event.type) {
+    case 'text':
+      batcher.append(event.text, false);
+      return null;
+    case 'thinking':
+      return handleThinking(event, batcher);
+    case 'tool-call':
+      return handleToolEvent(event, batcher, handlers);
+    case 'tool-status':
+      return handleToolUpdate(event, batcher, handlers);
+    case 'tool-result':
+      return handleToolResultEvent(event, batcher, handlers);
+    case 'tool-confirmation':
+      await safeFlush(batcher);
+      await handlers.handleConfirmation(event);
+      return null;
+    case 'done':
+      await safeFlush(batcher);
+      return mapDoneReasonToStopReason(event.reason);
+    case 'error':
+      await safeFlush(batcher);
+      throw translateErrorEvent(event);
+    case 'idle-timeout':
+      await safeFlush(batcher);
+      throw translateIdleTimeout(event);
+    case 'invalid-stream':
+      await safeFlush(batcher);
+      throw new Error(
+        'Agent produced an invalid stream that could not be recovered.',
+      );
+    case 'hook-blocked':
+      await safeFlush(batcher);
+      if (event.info.systemMessage !== undefined) {
+        await handlers.sendUpdate({
+          sessionUpdate: 'agent_message_chunk',
+          content: { type: 'text', text: event.info.systemMessage },
+        });
+      }
+      return null;
+    case 'loop-detected':
+      await safeFlush(batcher);
+      return 'end_turn';
+    case 'notice':
+      return handleNotice(event, batcher, handlers);
+    case 'usage':
+      await safeFlush(batcher);
+      await handlers.sendUsage(event.usage);
+      return null;
+    case 'context-warning':
+    case 'compression':
+    case 'model-info':
+    case 'retry':
+    case 'citation':
+      return null;
+    default:
+      return assertNever(event);
+  }
+}
+
+function handleThinking(
+  event: Extract<AgentEvent, { type: 'thinking' }>,
+  batcher: StreamBatcher,
+): null {
+  const thoughtText = extractThoughtText(event.thought);
+  if (thoughtText.length > 0) batcher.append(thoughtText, true);
+  return null;
+}
+
+async function handleToolEvent(
+  event: Extract<AgentEvent, { type: 'tool-call' }>,
+  batcher: StreamBatcher,
+  handlers: AgentEventHandlers,
+): Promise<null> {
+  await safeFlush(batcher);
+  await emitToolCallStart(
+    event.call,
+    handlers.sendUpdate,
+    handlers.resolveToolKind(event.call.name),
+  );
+  return null;
+}
+
+async function handleToolUpdate(
+  event: Extract<AgentEvent, { type: 'tool-status' }>,
+  batcher: StreamBatcher,
+  handlers: AgentEventHandlers,
+): Promise<null> {
+  await safeFlush(batcher);
+  await emitToolStatus(
+    event.update,
+    handlers.sendUpdate,
+    handlers.resolveToolKind(event.update.name),
+  );
+  return null;
+}
+
+async function handleToolResultEvent(
+  event: Extract<AgentEvent, { type: 'tool-result' }>,
+  batcher: StreamBatcher,
+  handlers: AgentEventHandlers,
+): Promise<null> {
+  await safeFlush(batcher);
+  await emitToolResult(
+    event.result,
+    handlers.sendUpdate,
+    handlers.resolveToolKind(event.result.name),
+  );
+  return null;
+}
+
+async function handleNotice(
+  event: Extract<AgentEvent, { type: 'notice' }>,
+  batcher: StreamBatcher,
+  handlers: AgentEventHandlers,
+): Promise<null> {
+  await safeFlush(batcher);
+  await handlers.sendUpdate({
+    sessionUpdate: 'agent_message_chunk',
+    content: { type: 'text', text: event.message },
+  });
+  return null;
+}
+
+function assertNever(event: never): never {
+  throw new Error(`Unhandled agent event: ${JSON.stringify(event)}`);
+}

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

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Agent } from '@vybestack/llxprt-code-agents';
+
+export async function enableZedSessionRecording(
+  agent: Agent,
+  onFailure: (error: unknown) => void,
+): Promise<void> {
+  try {
+    await agent.session.setRecording({ enabled: true });
+  } catch (error) {
+    try {
+      onFailure(error);
+    } catch {
+      // Recording remains best-effort even when failure notification fails.
+    }
+  }
+}
+
+export async function buildZedSession<T>(
+  agent: Agent,
+  build: () => T | Promise<T>,
+  onDisposeFailure: (error: unknown) => void,
+): Promise<T> {
+  try {
+    return await build();
+  } catch (error) {
+    try {
+      await agent.dispose();
+    } catch (disposeError) {
+      try {
+        onDisposeFailure(disposeError);
+      } catch {
+        // Preserve the original session build failure.
+      }
+    }
+    throw error;
+  }
+}

package/src/zed-integration/zed-command-registry.ts

@@ -0,0 +1,167 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as acp from '@agentclientprotocol/sdk';
+import type { Agent } from '@vybestack/llxprt-code-agents';
+import { DebugLogger } from '@vybestack/llxprt-code-core';
+
+const logger = new DebugLogger('llxprt:zed-integration:commands');
+
+export interface ZedCommandContext {
+  readonly agent: Agent;
+}
+
+export interface ZedCommandResult {
+  readonly text: string;
+}
+
+interface ZedCommandDefinition {
+  readonly name: string;
+  readonly description: string;
+  readonly inputHint?: string;
+  readonly handler: (
+    context: ZedCommandContext,
+    args: string,
+  ) => Promise<ZedCommandResult>;
+}
+
+export function parseZedCommandPrompt(
+  prompt: string,
+): { readonly name: string; readonly args: string } | null {
+  if (!prompt.startsWith('/')) return null;
+  const value = prompt.slice(1).trimStart();
+  if (value.length === 0) return null;
+  const boundary = value.search(/\s/);
+  return boundary === -1
+    ? { name: value.toLowerCase(), args: '' }
+    : {
+        name: value.slice(0, boundary).toLowerCase(),
+        args: value.slice(boundary + 1).trim(),
+      };
+}
+
+function formatCompression(
+  result: Awaited<ReturnType<Agent['compress']>>,
+): string {
+  const counts =
+    result.originalTokenCount === undefined ||
+    result.newTokenCount === undefined
+      ? ''
+      : ` (${result.originalTokenCount} → ${result.newTokenCount} tokens)`;
+  return `Context compression ${result.status}${counts}.`;
+}
+
+const COMMANDS: readonly ZedCommandDefinition[] = [
+  {
+    name: 'compact',
+    description: 'Compress conversation history to free context space',
+    handler: async ({ agent }) => ({
+      text: formatCompression(await agent.compress()),
+    }),
+  },
+  {
+    name: 'tools',
+    description: 'List available tools and their enabled status',
+    handler: async ({ agent }) => {
+      const tools = agent.tools.list();
+      return {
+        text:
+          tools.length === 0
+            ? 'No tools available.'
+            : `Available tools:\n${tools
+                .map((tool) => `  ${tool.enabled ? '[x]' : '[ ]'} ${tool.name}`)
+                .join('\n')}`,
+      };
+    },
+  },
+  {
+    name: 'memory',
+    description: 'Show memory files currently in use',
+    handler: async ({ agent }) => {
+      const paths = agent.memory.getFilePaths();
+      return {
+        text:
+          paths.length === 0
+            ? 'No memory files in use.'
+            : `Memory files:\n${paths.map((path) => `  ${path}`).join('\n')}`,
+      };
+    },
+  },
+  {
+    name: 'profile',
+    description: 'List saved profiles and identify the startup default',
+    handler: async ({ agent }) => {
+      const profiles = agent.profiles.list();
+      return {
+        text:
+          profiles.length === 0
+            ? 'No profiles available.'
+            : `Profiles:\n${profiles
+                .map(
+                  (profile) =>
+                    `  ${profile.name}${profile.isDefault ? ' (default)' : ''}`,
+                )
+                .join('\n')}`,
+      };
+    },
+  },
+  {
+    name: 'model',
+    description: 'Show the current model',
+    handler: async ({ agent }) => ({
+      text: `Current model: ${agent.getModel()}`,
+    }),
+  },
+  {
+    name: 'task',
+    description: 'Show active subagent tasks',
+    handler: async ({ agent }) => {
+      const tasks = agent.tasks.list();
+      return {
+        text:
+          tasks.length === 0
+            ? 'No active subagent tasks.'
+            : `Subagent tasks:\n${tasks
+                .map((task) => `  [${task.status}] ${task.goalPrompt}`)
+                .join('\n')}`,
+      };
+    },
+  },
+];
+
+const COMMAND_MAP = new Map(COMMANDS.map((command) => [command.name, command]));
+
+export function getZedAvailableCommands(): acp.AvailableCommand[] {
+  return COMMANDS.map(({ name, description, inputHint }) => ({
+    name,
+    description,
+    ...(inputHint === undefined ? {} : { input: { hint: inputHint } }),
+  }));
+}
+
+export function buildAvailableCommandsUpdate(): acp.SessionUpdate {
+  return {
+    sessionUpdate: 'available_commands_update',
+    availableCommands: getZedAvailableCommands(),
+  };
+}
+
+export async function executeZedCommand(
+  prompt: string,
+  context: ZedCommandContext,
+): Promise<ZedCommandResult | null> {
+  const parsed = parseZedCommandPrompt(prompt);
+  if (parsed === null) return null;
+  const command = COMMAND_MAP.get(parsed.name);
+  if (command === undefined) return null;
+  try {
+    return await command.handler(context, parsed.args);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    logger.error(() => `Command /${command.name} failed: ${detail}`);
+    return { text: `Command /${command.name} failed. See logs for details.` };
+  }
+}