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

package/src/zed-integration/zed-config-options.ts

@@ -0,0 +1,280 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as acp from '@agentclientprotocol/sdk';
+import type { Agent } from '@vybestack/llxprt-code-agents';
+import {
+  coreEvents,
+  CoreEvent,
+  DebugLogger,
+  type Config,
+  type RuntimeModel,
+} from '@vybestack/llxprt-code-core';
+import { parseEphemeralSettingValue } from '@vybestack/llxprt-code-providers/runtime.js';
+import type { ClientCapabilitiesWithSession } from './acp-types.js';
+
+const REASONING_VALUES = ['minimal', 'low', 'medium', 'high', 'xhigh'];
+const EMOJI_VALUES = ['allowed', 'auto', 'warn', 'error'];
+const logger = new DebugLogger('llxprt:zed-integration:config-options');
+
+function selectOption(value: string): acp.SessionConfigSelectOption {
+  return { value, name: value };
+}
+
+function settingOption(
+  config: Config,
+  id: string,
+  name: string,
+  category: acp.SessionConfigOptionCategory,
+  values: readonly string[],
+  fallback: string,
+): acp.SessionConfigOption {
+  const current = config.getEphemeralSetting(id);
+  return {
+    type: 'select',
+    id,
+    name,
+    category,
+    currentValue: typeof current === 'string' ? current : fallback,
+    options: values.map(selectOption),
+  };
+}
+
+function modelOption(
+  currentModel: string,
+  models: readonly RuntimeModel[],
+): acp.SessionConfigOption {
+  const available = models.some(({ id }) => id === currentModel)
+    ? models
+    : [{ id: currentModel, name: currentModel, provider: '' }, ...models];
+  return {
+    type: 'select',
+    id: 'model',
+    name: 'Model',
+    category: 'model',
+    currentValue: currentModel,
+    options: available.map((model) => ({ value: model.id, name: model.name })),
+  };
+}
+
+async function availableModels(
+  agent: Pick<Agent, 'getProviderStatus'>,
+  config: Config,
+): Promise<RuntimeModel[] | undefined> {
+  try {
+    const provider = agent.getProviderStatus().provider;
+    return await config.getProviderManager()?.getAvailableModels(provider);
+  } catch (error) {
+    logger.debug(() => `Failed to load available models: ${String(error)}`);
+    return undefined;
+  }
+}
+
+export async function buildZedConfigOptions(
+  agent: Pick<Agent, 'getModel' | 'getProviderStatus'>,
+  config: Config,
+): Promise<acp.SessionConfigOption[]> {
+  const currentModel = agent.getModel();
+  const models = await availableModels(agent, config);
+  return [
+    ...(models === undefined || currentModel.length === 0
+      ? []
+      : [modelOption(currentModel, models)]),
+    settingOption(
+      config,
+      'reasoning.effort',
+      'Thinking level',
+      'thought_level',
+      REASONING_VALUES,
+      'medium',
+    ),
+    settingOption(
+      config,
+      'emojifilter',
+      'Emoji filter',
+      '_display',
+      EMOJI_VALUES,
+      'auto',
+    ),
+  ];
+}
+
+export async function applyZedConfigOption(
+  agent: Agent,
+  config: Config,
+  configId: string,
+  value: string,
+): Promise<acp.SessionConfigOption[]> {
+  if (configId === 'model') {
+    const models = await availableModels(agent, config);
+    if (models === undefined) {
+      throw acp.RequestError.internalError(
+        { configId },
+        'Unable to verify model availability.',
+      );
+    }
+    if (value !== agent.getModel() && !models.some(({ id }) => id === value)) {
+      throw acp.RequestError.invalidParams({ value }, 'Unavailable model.');
+    }
+    try {
+      await agent.setModel(value);
+    } catch (error) {
+      logger.debug(() => `Failed to set model: ${String(error)}`);
+      throw acp.RequestError.internalError(
+        { configId },
+        'Unable to set model.',
+      );
+    }
+    return buildZedConfigOptions(agent, config);
+  }
+  if (configId !== 'reasoning.effort' && configId !== 'emojifilter') {
+    throw acp.RequestError.invalidParams(
+      { configId },
+      'Unknown config option.',
+    );
+  }
+  const parsed = parseEphemeralSettingValue(configId, value);
+  if (!parsed.success) {
+    throw acp.RequestError.invalidParams({ configId }, parsed.message);
+  }
+  try {
+    config.setEphemeralSetting(configId, parsed.value);
+    coreEvents.emitSettingsChanged();
+  } catch (error) {
+    logger.debug(() => `Failed to apply config option: ${String(error)}`);
+    throw acp.RequestError.internalError(
+      { configId },
+      'Unable to apply config option.',
+    );
+  }
+  return buildZedConfigOptions(agent, config);
+}
+
+export async function zedConfigOptionsForClient(
+  capabilities: ClientCapabilitiesWithSession | undefined,
+  agent: Pick<Agent, 'getModel' | 'getProviderStatus'>,
+  config: Config,
+): Promise<Pick<acp.NewSessionResponse, 'configOptions'>> {
+  return capabilities?.session?.configOptions === true
+    ? { configOptions: await buildZedConfigOptions(agent, config) }
+    : {};
+}
+
+export async function setZedConfigOption(
+  agent: Agent,
+  config: Config,
+  configId: string,
+  value: string,
+): Promise<acp.SetSessionConfigOptionResponse> {
+  return {
+    configOptions: await applyZedConfigOption(agent, config, configId, value),
+  };
+}
+
+interface ConfigurableZedSession {
+  setConfigOption(
+    configId: string,
+    value: string,
+  ): Promise<acp.SetSessionConfigOptionResponse>;
+}
+
+export function dispatchZedConfigOption(
+  capabilities: ClientCapabilitiesWithSession | undefined,
+  sessions: ReadonlyMap<string, ConfigurableZedSession>,
+  params: acp.SetSessionConfigOptionRequest,
+): Promise<acp.SetSessionConfigOptionResponse> {
+  const session = sessions.get(params.sessionId);
+  if (session === undefined) {
+    throw acp.RequestError.resourceNotFound(params.sessionId);
+  }
+  if (capabilities?.session?.configOptions !== true) {
+    throw acp.RequestError.invalidParams(
+      { sessionId: params.sessionId },
+      'Config options not supported by client.',
+    );
+  }
+  if (typeof params.value !== 'string') {
+    throw acp.RequestError.invalidParams(
+      { configId: params.configId },
+      'Config value must be a string.',
+    );
+  }
+  return session.setConfigOption(params.configId, params.value);
+}
+
+export function observeZedConfigOptions(
+  agent: Pick<Agent, 'getModel' | 'getProviderStatus'>,
+  config: Config,
+  sendUpdate: (update: acp.SessionUpdate) => Promise<void>,
+  onError: (error: unknown) => void,
+): () => void {
+  let stopped = false;
+  let running = false;
+  let pending = false;
+  const isStopped = () => stopped;
+  const refresh = () => {
+    pending = true;
+    // One loop owns refresh work; events received while it runs coalesce into
+    // one additional pass instead of starting concurrent snapshots.
+    if (running) return;
+    running = true;
+    void runRefreshLoop();
+  };
+
+  async function runRefreshLoop(): Promise<void> {
+    try {
+      while (pending && !stopped) {
+        pending = false;
+        await sendConfigOptionUpdate(
+          agent,
+          config,
+          sendUpdate,
+          isStopped,
+          onError,
+        );
+      }
+    } finally {
+      running = false;
+    }
+  }
+  coreEvents.on(CoreEvent.ModelChanged, refresh);
+  coreEvents.on(CoreEvent.ModelProfileChanged, refresh);
+  coreEvents.on(CoreEvent.SettingsChanged, refresh);
+  return () => {
+    stopped = true;
+    coreEvents.off(CoreEvent.ModelChanged, refresh);
+    coreEvents.off(CoreEvent.ModelProfileChanged, refresh);
+    coreEvents.off(CoreEvent.SettingsChanged, refresh);
+  };
+}
+
+export function zedSessionConfigOptions(
+  capabilities: ClientCapabilitiesWithSession | undefined,
+  session: { getConfigOptions(): Promise<acp.SessionConfigOption[]> },
+): Promise<Pick<acp.LoadSessionResponse, 'configOptions'>> {
+  return capabilities?.session?.configOptions === true
+    ? session.getConfigOptions().then((configOptions) => ({ configOptions }))
+    : Promise.resolve({});
+}
+
+async function sendConfigOptionUpdate(
+  agent: Pick<Agent, 'getModel' | 'getProviderStatus'>,
+  config: Config,
+  sendUpdate: (update: acp.SessionUpdate) => Promise<void>,
+  isStopped: () => boolean,
+  onError: (error: unknown) => void,
+): Promise<void> {
+  try {
+    const configOptions = await buildZedConfigOptions(agent, config);
+    if (isStopped()) return;
+    await sendUpdate({
+      sessionUpdate: 'config_option_update',
+      configOptions,
+    });
+  } catch (error) {
+    onError(error);
+  }
+}

package/src/zed-integration/zed-content-utils.ts

@@ -63,9 +63,9 @@ export function extractToolResultText(
 }
 
 export function extractTextFromPartList(
-  llmContent: string | ContentBlock[] | IContent | undefined,
+  llmContent: string | ContentBlock[] | IContent | null | undefined,
 ): string | null {
-  if (llmContent === undefined) {
+  if (llmContent === undefined || llmContent === null) {
     return null;
   }
 

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

@@ -9,6 +9,11 @@ import {
   ToolConfirmationOutcome,
   ApprovalMode,
 } from '@vybestack/llxprt-code-core';
+import type {
+  AgentEvent,
+  DoneReason,
+  ThoughtSummary,
+} from '@vybestack/llxprt-code-agents';
 import type * as acp from '@agentclientprotocol/sdk';
 import { z } from 'zod';
 
@@ -22,6 +27,36 @@ export function parseZedAuthMethodId(
   return z.enum(availableProfiles as [string, ...string[]]).parse(methodId);
 }
 
+/**
+ * Maps an Agent-API {@link DoneReason} to the ACP {@link acp.StopReason} the Zed
+ * client expects. Terminal failure reasons (`error`, `hook-stopped`) have no
+ * clean stop reason and throw so the prompt path surfaces them as errors. Kept
+ * here (a pure mapper alongside the other Zed mapping helpers) so zedIntegration.ts
+ * stays within its max-lines budget.
+ */
+export function mapDoneReasonToStopReason(reason: DoneReason): acp.StopReason {
+  switch (reason) {
+    case 'stop':
+    case 'loop-detected':
+      return 'end_turn';
+    case 'aborted':
+      return 'cancelled';
+    case 'max-turns':
+      return 'max_turn_requests';
+    case 'context-overflow':
+      return 'max_tokens';
+    case 'refusal':
+      return 'refusal';
+    case 'error':
+    case 'hook-stopped':
+      throw new Error(`Agent stopped with terminal reason: ${reason}`);
+    default: {
+      const exhaustive: never = reason;
+      return exhaustive;
+    }
+  }
+}
+
 /**
  * Structural input for {@link toToolCallContent}: the display/error fields of
  * a tool execution result. Both the core `ToolResult` and the public
@@ -190,3 +225,100 @@ export function buildAvailableModes(): acp.SessionMode[] {
     },
   ];
 }
+
+/**
+ * Builds the ACP session `modes` block (available modes + the session's current
+ * mode) shared by the newSession and loadSession (disk-resume AND #1604
+ * re-attach) responses. Typed via the response's `modes` field so it stays exact
+ * without importing a possibly-renamed acp type. Centralized here so the mode
+ * advertisement is identical across all three response paths.
+ */
+export function buildSessionModes(
+  currentModeId: ApprovalMode,
+): acp.LoadSessionResponse['modes'] {
+  return {
+    availableModes: buildAvailableModes(),
+    currentModeId,
+  };
+}
+
+/**
+ * Flattens an Agent-API {@link ThoughtSummary} into the display text the Zed
+ * thought-chunk carries: the non-empty subject/description joined by a space.
+ * Pure mapper kept alongside the other Zed event mappers so zedIntegration.ts
+ * stays within its max-lines budget.
+ */
+export function extractThoughtText(thought: ThoughtSummary): string {
+  const parts = [thought.subject, thought.description].filter(
+    (v) => v.length > 0,
+  );
+  return parts.join(' ');
+}
+
+/**
+ * Translates an Agent `error` event into an Error for the prompt path, carrying
+ * the upstream numeric `status` (when present) so downstream 429 handling can
+ * still detect a rate-limit. Pure; extracted here to keep zedIntegration.ts thin.
+ */
+export function translateErrorEvent(
+  event: Extract<AgentEvent, { type: 'error' }>,
+): Error {
+  const error = new Error(event.error.message);
+  if (event.error.status !== undefined) {
+    Object.assign(error, { status: event.error.status });
+  }
+  return error;
+}
+
+/**
+ * Translates an Agent `idle-timeout` event into an Error carrying its message.
+ * Pure; extracted here to keep zedIntegration.ts within its max-lines budget.
+ */
+export function translateIdleTimeout(
+  event: Extract<AgentEvent, { type: 'idle-timeout' }>,
+): Error {
+  return new Error(event.error.message);
+}
+
+/**
+ * Renders the pre-delivery debug line for a session/update notification: the
+ * update kind plus the text length when the update carries text content. Pure;
+ * extracted here to keep zedIntegration.ts within its max-lines budget.
+ */
+export function describeSessionUpdateForLog(update: acp.SessionUpdate): string {
+  const chars =
+    'content' in update && update.content && 'text' in update.content
+      ? `(${update.content.text.length} chars)`
+      : '';
+  return `sendUpdate: ${update.sessionUpdate} ${chars}`;
+}
+
+/**
+ * Builds the usage_update session notification for a turn's usage metadata
+ * (issue #1607): `used` is the total tokens now in context (the response's
+ * cumulative totalTokenCount) and `size` is the configured context-window
+ * limit, so the client can render consumption against the real window rather
+ * than against itself. When a provider omits cumulative `totalTokenCount`, the
+ * candidate count is retained as a lower-bound fallback rather than suppressing
+ * usage entirely; it represents only this completion, so it may under-report
+ * context consumption but never overstates it. Returns null when the metadata
+ * carries no usable count. `size` is clamped up to `used` so a mid-flight limit
+ * change can never report used > size on the wire.
+ */
+export function buildUsageUpdate(
+  usage: {
+    readonly totalTokenCount?: number;
+    readonly candidatesTokenCount?: number;
+  },
+  contextWindowSize: number,
+): acp.SessionUpdate | null {
+  const used = usage.totalTokenCount ?? usage.candidatesTokenCount ?? 0;
+  if (used === 0) {
+    return null;
+  }
+  return {
+    sessionUpdate: 'usage_update',
+    used,
+    size: Math.max(contextWindowSize, used),
+  };
+}

package/src/zed-integration/zed-initialize.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type { Config } from '@vybestack/llxprt-code-core';
+import * as acp from '@agentclientprotocol/sdk';
+import { loadProfileByName } from '@vybestack/llxprt-code-providers/runtime.js';
+import { parseZedAuthMethodId } from './zed-helpers.js';
+
+export async function initializeZedAgent(
+  config: Config,
+): Promise<acp.InitializeResponse> {
+  let profileNames: string[];
+  try {
+    profileNames = await getAvailableProfileNames(config);
+  } catch (error) {
+    throw new Error(
+      `Failed to initialize Zed agent: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    );
+  }
+  return {
+    protocolVersion: acp.PROTOCOL_VERSION,
+    authMethods: profileNames.map((name) => ({
+      id: name,
+      name,
+      description: null,
+    })),
+    agentCapabilities: {
+      loadSession: true,
+      sessionCapabilities: {
+        list: {},
+        resume: {},
+      },
+      promptCapabilities: {
+        image: true,
+        audio: true,
+        embeddedContext: true,
+      },
+    },
+  };
+}
+
+export async function authenticateZedAgent(
+  config: Config,
+  methodId: string,
+): Promise<void> {
+  try {
+    const profileNames = await getAvailableProfileNames(config);
+    const profileName = parseZedAuthMethodId(methodId, profileNames);
+    await loadProfileByName(profileName);
+  } catch (error) {
+    throw new Error(
+      `Failed to authenticate with profile "${methodId}": ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error },
+    );
+  }
+}
+
+async function getAvailableProfileNames(config: Config): Promise<string[]> {
+  return (await config.getProfileManager()?.listProfiles()) ?? [];
+}

package/src/zed-integration/zed-plan-update.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type * as acp from '@agentclientprotocol/sdk';
+import type { Todo } from '@vybestack/llxprt-code-core';
+
+export function buildZedPlanUpdate(todos: readonly Todo[]): acp.SessionUpdate {
+  return {
+    sessionUpdate: 'plan',
+    entries: todos.map((todo) => ({
+      content: todo.content,
+      status: todo.status,
+      // ACP plan entries only support a fixed 'medium' priority.
+      priority: 'medium',
+    })),
+  };
+}

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

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright 2026 Vybestack LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import * as acp from '@agentclientprotocol/sdk';
+import type { Agent } from '@vybestack/llxprt-code-agents';
+import { DebugLogger } from '@vybestack/llxprt-code-core';
+import {
+  executeZedCommand,
+  type ZedCommandResult,
+} from './zed-command-registry.js';
+
+const logger = new DebugLogger('llxprt:zed-integration:prompt-command');
+
+/**
+ * Extracts the first text content from an ACP prompt content-block array. A
+ * Zed slash command arrives as a single text block, so only the first text
+ * block's text is relevant for command detection.
+ *
+ * Returns `null` when the prompt has no text block (e.g. only image/audio),
+ * so the caller treats it as an ordinary (non-slash) prompt.
+ */
+export function extractPromptText(
+  prompt: readonly acp.ContentBlock[],
+): string | null {
+  if (prompt.length !== 1 || prompt[0].type !== 'text') {
+    return null;
+  }
+  return prompt[0].text;
+}
+
+/**
+ * Attempts to handle a prompt as a Zed slash command. When the prompt is a
+ * known Zed command (e.g. `/compact`, `/tools`), this executes the command,
+ * streams the result text as an `agent_message_chunk` via the provided
+ * `sendUpdate` callback, and returns the final {@link acp.PromptResponse}.
+ *
+ * Returns `null` when the prompt is NOT a slash command (or is an unknown
+ * command), so the caller continues with ordinary model-streaming.
+ *
+ * @param prompt The raw ACP content blocks from the prompt request.
+ * @param agent The session's real Agent.
+ * @param sendUpdate Callback to stream an `agent_message_chunk`.
+ */
+export async function tryHandleZedCommand(
+  prompt: readonly acp.ContentBlock[],
+  agent: Agent,
+  sendUpdate: (update: acp.SessionUpdate) => Promise<void>,
+): Promise<{ response: acp.PromptResponse } | null> {
+  const text = extractPromptText(prompt);
+  if (text === null) {
+    return null;
+  }
+  const result: ZedCommandResult | null = await executeZedCommand(text, {
+    agent,
+  });
+  if (result === null) {
+    return null;
+  }
+  try {
+    await sendUpdate({
+      sessionUpdate: 'agent_message_chunk',
+      content: { type: 'text', text: result.text },
+    });
+  } catch (error) {
+    logger.debug(() => `Command response delivery failed: ${String(error)}`);
+    throw acp.RequestError.internalError(
+      { cause: error },
+      'Command response delivery failed.',
+    );
+  }
+  return {
+    response: { stopReason: 'end_turn' },
+  };
+}