@cuylabs/agent-server 0.10.0

package/dist/index.js

@@ -0,0 +1,2288 @@
+// src/protocol/capabilities.ts
+function createDefaultAgentServerCapabilities() {
+  return {
+    protocol: {
+      version: 1,
+      transport: "in-process",
+      reconnectable: false,
+      multiClient: true
+    },
+    sessions: {
+      persistent: true,
+      list: true,
+      create: true,
+      read: true,
+      delete: true,
+      branch: true
+    },
+    turns: {
+      start: true,
+      wait: true,
+      interrupt: true,
+      steer: true,
+      followUp: true,
+      followUpManagement: true,
+      eventStreaming: true,
+      concurrentTurnsPerSession: false
+    },
+    interactive: {
+      approvalRequests: true,
+      humanRequests: true
+    },
+    runtime: {
+      execution: "local",
+      orchestration: "direct",
+      durability: "process",
+      dapr: {
+        available: false,
+        delegatedTurns: false,
+        workflowBacked: false
+      }
+    },
+    agent: {
+      workspaceSummary: true,
+      toolInventory: false,
+      skillInspection: false,
+      subAgentInspection: false,
+      modelInspection: false,
+      modelSwitch: false,
+      runtimeStatus: false,
+      contextCompaction: false,
+      turnUndo: false,
+      turnDiff: false
+    },
+    plugins: {
+      headlessOnly: true,
+      commandMetadata: true,
+      commandDiscovery: false,
+      commandExecution: false,
+      clientExtensions: false
+    },
+    events: {
+      eventBus: false,
+      pubSubBridge: false,
+      sseStreaming: false,
+      eventReplay: false
+    }
+  };
+}
+function mergeAgentServerCapabilities(base, override) {
+  if (!override) {
+    return base;
+  }
+  const runtime = override.runtime ? {
+    ...base.runtime,
+    ...override.runtime,
+    dapr: {
+      ...base.runtime.dapr,
+      ...override.runtime.dapr ?? {}
+    }
+  } : base.runtime;
+  return {
+    ...base,
+    ...override.protocol ? { protocol: { ...base.protocol, ...override.protocol } } : {},
+    ...override.sessions ? { sessions: { ...base.sessions, ...override.sessions } } : {},
+    ...override.turns ? { turns: { ...base.turns, ...override.turns } } : {},
+    ...override.interactive ? { interactive: { ...base.interactive, ...override.interactive } } : {},
+    runtime,
+    ...override.agent ? { agent: { ...base.agent, ...override.agent } } : {},
+    ...override.plugins ? { plugins: { ...base.plugins, ...override.plugins } } : {},
+    ...override.events ? { events: { ...base.events, ...override.events } } : {}
+  };
+}
+
+// src/protocol/notifications.ts
+function matchesNotificationSubscription(notification, options) {
+  if (!options) {
+    return true;
+  }
+  if (options.turnId) {
+    const notificationTurnId = notification.type === "turn/started" || notification.type === "turn/completed" ? notification.turn.id : notification.type === "turn/event" ? notification.turnId : notification.type === "input/request" ? notification.request.turnId : notification.type === "input/resolved" ? notification.turnId : void 0;
+    if (notificationTurnId !== options.turnId) {
+      return false;
+    }
+  }
+  if (options.teamId) {
+    const notificationTeamId = notification.type === "team/notification" ? notification.teamId : void 0;
+    if (notificationTeamId !== options.teamId) {
+      return false;
+    }
+  }
+  if (options.sessionId) {
+    const notificationSessionId = notification.type === "turn/started" || notification.type === "turn/completed" ? notification.turn.sessionId : notification.type === "turn/event" ? notification.sessionId : notification.type === "input/request" ? notification.request.sessionId : notification.type === "input/resolved" ? notification.sessionId : notification.type === "team/notification" ? void 0 : notification.type === "session/deleted" ? notification.sessionId : notification.type === "session/created" ? notification.session.id : notification.sessionId;
+    if (notificationSessionId !== options.sessionId) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/protocol/adapter.ts
+import { extractModelId, extractProvider, ensureSessionLoaded } from "@cuylabs/agent-core";
+function createAgentServerAdapter(agent, options = {}) {
+  const interactiveAgent = agent;
+  const pluginCommands = options.pluginCommands ?? [];
+  const pluginCommandInfos = pluginCommands.map((command) => ({
+    pluginId: command.pluginId,
+    name: command.name,
+    alias: [...command.alias],
+    summary: command.summary,
+    ...command.metadata ? { metadata: command.metadata } : {}
+  }));
+  const pluginCommandTokens = /* @__PURE__ */ new Map();
+  for (const command of pluginCommands) {
+    pluginCommandTokens.set(normalizePluginCommandToken(command.name), command);
+    for (const alias of command.alias) {
+      pluginCommandTokens.set(normalizePluginCommandToken(alias), command);
+    }
+  }
+  let currentModelLabel = options.currentModelLabel?.trim() || null;
+  let lastTrackedTurnSessionId = null;
+  const humanInputController = interactiveAgent.getHumanInputController();
+  const hasHumanInput = Boolean(
+    humanInputController && interactiveAgent.hasHumanInputTools()
+  );
+  const getModelState = currentModelLabel !== null ? async () => ({
+    label: currentModelLabel ?? "server-managed",
+    switchable: Boolean(options.switchModel)
+  }) : void 0;
+  const switchModel = options.switchModel ? async (spec) => {
+    const result = await options.switchModel(spec);
+    if (result.ok) {
+      currentModelLabel = result.label;
+    }
+    return result;
+  } : void 0;
+  const listTools = async () => agent.getToolIds().map((id) => ({ id })).sort((left, right) => left.id.localeCompare(right.id));
+  const listSkills = options.listSkills ? async () => [...await options.listSkills()].sort(
+    (left, right) => left.name.localeCompare(right.name)
+  ) : void 0;
+  const listSubAgents = options.listSubAgents ? async () => [...await options.listSubAgents()].sort(
+    (left, right) => left.name.localeCompare(right.name)
+  ) : void 0;
+  async function ensureActionSessionLoaded(sessionId) {
+    await ensureSessionLoaded({
+      sessionId,
+      sessions: agent.getSessionManager(),
+      cwd: agent.cwd
+    });
+  }
+  const compactSessionContext = async (sessionId) => {
+    await ensureActionSessionLoaded(sessionId);
+    return await agent.compactContext();
+  };
+  const undoSessionTurn = async (sessionId) => {
+    if (lastTrackedTurnSessionId !== sessionId) {
+      return { restored: [], failed: [] };
+    }
+    return await agent.undoTurn();
+  };
+  const getSessionTurnDiff = async (sessionId) => {
+    if (lastTrackedTurnSessionId !== sessionId) {
+      return null;
+    }
+    return await agent.getTurnDiff();
+  };
+  return {
+    cwd: agent.cwd,
+    getCapabilities: () => mergeAgentServerCapabilities(
+      mergeAgentServerCapabilities(createDefaultAgentServerCapabilities(), {
+        protocol: { transport: "in-process", reconnectable: false, multiClient: true },
+        turns: { steer: true, followUp: true, followUpManagement: true },
+        interactive: { approvalRequests: true, humanRequests: hasHumanInput },
+        runtime: {
+          execution: "local",
+          orchestration: "direct",
+          durability: "process",
+          dapr: {
+            available: false,
+            delegatedTurns: false,
+            workflowBacked: false
+          }
+        },
+        agent: {
+          workspaceSummary: true,
+          toolInventory: true,
+          skillInspection: Boolean(listSkills),
+          subAgentInspection: Boolean(listSubAgents),
+          modelInspection: Boolean(getModelState),
+          modelSwitch: Boolean(switchModel),
+          runtimeStatus: true,
+          contextCompaction: true,
+          turnUndo: true,
+          turnDiff: true
+        },
+        plugins: {
+          headlessOnly: true,
+          commandMetadata: true,
+          commandDiscovery: true,
+          commandExecution: true,
+          clientExtensions: false
+        }
+      }),
+      options.capabilities
+    ),
+    getModelState,
+    switchModel,
+    async getSessionRuntimeStatus(sessionId) {
+      await ensureActionSessionLoaded(sessionId);
+      const manager = agent.getSessionManager();
+      const loadedId = manager.getSessionId() ?? void 0;
+      const leafId = manager.getLeafId() ?? void 0;
+      const header = manager.getHeader();
+      const modelId = extractModelId(agent.model);
+      const provider = extractProvider(agent.model);
+      return {
+        session: {
+          selectedId: sessionId,
+          ...loadedId ? { loadedId } : {},
+          messageCount: agent.getMessages().length,
+          ...leafId ? { leafId } : {},
+          ...header?.cwd ? { cwd: header.cwd } : {},
+          ...header?.title ? { title: header.title } : {}
+        },
+        model: {
+          id: modelId,
+          ...provider ? { provider } : {}
+        },
+        context: agent.getContextStats()
+      };
+    },
+    listTools,
+    listSkills,
+    listSubAgents,
+    ...humanInputController ? {
+      async respondToInputRequest(requestId, payload) {
+        if (payload.kind !== "human") {
+          return;
+        }
+        await humanInputController.respondToRequest(
+          requestId,
+          payload.response
+        );
+      }
+    } : {},
+    ...options.listTeamNotifications ? {
+      listTeamNotifications(optionsArg) {
+        return options.listTeamNotifications(optionsArg);
+      }
+    } : {},
+    ...options.subscribeTeamNotifications ? {
+      subscribeTeamNotifications(listener) {
+        return options.subscribeTeamNotifications(listener);
+      }
+    } : {},
+    compactSessionContext,
+    undoSessionTurn,
+    getSessionTurnDiff,
+    async *chat(sessionId, message, chatOptions) {
+      lastTrackedTurnSessionId = sessionId;
+      for await (const event of agent.chat(sessionId, message, {
+        ...chatOptions?.abort ? { abort: chatOptions.abort } : {},
+        ...chatOptions?.system ? { system: chatOptions.system } : {}
+      })) {
+        yield event;
+      }
+    },
+    steer: ({ message }) => {
+      const id = agent.intervene(message);
+      return { id, accepted: true };
+    },
+    followUp: ({ message }) => {
+      const id = agent.queueNext(message);
+      return { id, accepted: true };
+    },
+    drainQueuedFollowUps: () => agent.drainQueuedNext(),
+    listSessions: () => agent.listSessions(),
+    deleteSession: (sessionId) => agent.deleteSession(sessionId),
+    getSessionStorage: () => agent.getSessionManager().getStorage(),
+    listPluginCommands: () => pluginCommandInfos,
+    executePluginCommand: async (name, args) => {
+      const command = pluginCommandTokens.get(normalizePluginCommandToken(name));
+      if (!command) {
+        throw new Error(`Plugin command not found: ${name}`);
+      }
+      return await command.execute(args);
+    }
+  };
+}
+function normalizePluginCommandToken(token) {
+  return token.trim().replace(/^\//, "").toLowerCase();
+}
+
+// src/protocol/wire.ts
+function isAgentServerWireEnvelope(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  return record.kind === "request" || record.kind === "response" || record.kind === "notification";
+}
+
+// src/runtime/in-process-server.ts
+import {
+  SessionManager,
+  canSeedQueuedFollowUp,
+  createQueuedFollowUpRecord,
+  markQueuedFollowUpApplied,
+  resolveQueuedFollowUp,
+  shouldCascadeApprovalDecision
+} from "@cuylabs/agent-core";
+
+// src/runtime/helpers.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isTerminalTurnStatus(status) {
+  return status === "completed" || status === "failed" || status === "interrupted";
+}
+function isAbortError(error, signal) {
+  if (signal.aborted) {
+    return true;
+  }
+  if (error instanceof DOMException) {
+    return error.name === "AbortError";
+  }
+  if (error instanceof Error) {
+    return error.name === "AbortError" || /aborted/i.test(error.message);
+  }
+  return false;
+}
+function getDerivedParentSessionId(sessionId) {
+  const marker = ":sub:";
+  const index = sessionId.lastIndexOf(marker);
+  if (index <= 0) {
+    return void 0;
+  }
+  return sessionId.slice(0, index);
+}
+function toSessionSummary(info, runtime) {
+  return {
+    id: info.id,
+    cwd: info.cwd,
+    createdAt: info.createdAt.toISOString(),
+    updatedAt: info.updatedAt.toISOString(),
+    messageCount: info.messageCount,
+    ...info.title ? { title: info.title } : {},
+    ...info.name ? { name: info.name } : {},
+    ...info.parentSessionId ? { parentSessionId: info.parentSessionId } : {},
+    ...info.firstMessage ? { preview: info.firstMessage } : {},
+    runtime
+  };
+}
+function toSessionSummaryFromDetail(detail) {
+  return {
+    id: detail.id,
+    cwd: detail.cwd,
+    createdAt: detail.createdAt,
+    updatedAt: detail.updatedAt,
+    messageCount: detail.messageCount,
+    ...detail.title ? { title: detail.title } : {},
+    ...detail.name ? { name: detail.name } : {},
+    ...detail.parentSessionId ? { parentSessionId: detail.parentSessionId } : {},
+    ...detail.preview ? { preview: detail.preview } : {},
+    runtime: detail.runtime
+  };
+}
+function getNotificationChannel(notification) {
+  switch (notification.type) {
+    case "session/created":
+      return `session:${notification.session.id}`;
+    case "session/deleted":
+      return `session:${notification.sessionId}`;
+    case "session/branched":
+    case "session/runtime":
+      return `session:${notification.sessionId}`;
+    case "turn/started":
+    case "turn/completed":
+      return `session:${notification.turn.sessionId}`;
+    case "turn/event":
+      return `session:${notification.sessionId}`;
+    case "input/request":
+      return `session:${notification.request.sessionId}`;
+    case "input/resolved":
+      return `session:${notification.sessionId}`;
+    case "team/notification":
+      return `team:${notification.teamId}`;
+    default:
+      return null;
+  }
+}
+
+// src/runtime/in-process-server.ts
+var InProcessAgentServer = class {
+  adapter;
+  capabilities;
+  followUpPolicy;
+  eventBus;
+  turns = /* @__PURE__ */ new Map();
+  followUps = /* @__PURE__ */ new Map();
+  sessionRuntime = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  pendingInputs = /* @__PURE__ */ new Map();
+  teamNotificationUnsubscribe = null;
+  constructor(adapter, options = {}) {
+    this.adapter = adapter;
+    this.followUpPolicy = options.followUpPolicy ?? adapter.followUpPolicy ?? {};
+    this.eventBus = options.eventBus ?? null;
+    let capabilities = mergeAgentServerCapabilities(
+      createDefaultAgentServerCapabilities(),
+      adapter.getCapabilities?.()
+    );
+    if (this.eventBus) {
+      capabilities = mergeAgentServerCapabilities(capabilities, {
+        events: { eventBus: true, eventReplay: true }
+      });
+    }
+    this.capabilities = capabilities;
+    if (this.adapter.subscribeTeamNotifications) {
+      this.teamNotificationUnsubscribe = this.adapter.subscribeTeamNotifications(
+        (notification) => {
+          this.emit({
+            type: "team/notification",
+            teamId: notification.teamId,
+            notification
+          });
+        }
+      );
+    }
+  }
+  getCapabilities() {
+    return this.capabilities;
+  }
+  async getWorkspaceSummary() {
+    const [sessions, modelState, tools, skills, subAgents] = await Promise.all([
+      this.listSessions(),
+      this.getModelState().catch(() => null),
+      this.listTools(),
+      this.listSkills(),
+      this.listSubAgents()
+    ]);
+    return {
+      workspace: {
+        cwd: this.adapter.cwd,
+        sessionCount: sessions.length
+      },
+      agent: {
+        modelLabel: modelState?.label ?? "server-managed",
+        switchable: modelState?.switchable ?? false,
+        toolCount: tools.length,
+        skillCount: skills.length,
+        subAgentCount: subAgents.length
+      }
+    };
+  }
+  async getSessionRuntimeStatus(sessionId) {
+    if (!this.adapter.getSessionRuntimeStatus) {
+      throw new Error("Runtime status is not available on this agent-server.");
+    }
+    return await this.adapter.getSessionRuntimeStatus(sessionId);
+  }
+  async getModelState() {
+    if (!this.adapter.getModelState) {
+      throw new Error("Model inspection is not available on this agent-server.");
+    }
+    return await this.adapter.getModelState();
+  }
+  async switchModel(spec) {
+    if (!this.adapter.switchModel) {
+      throw new Error("Model switching is not available on this agent-server.");
+    }
+    return await this.adapter.switchModel(spec);
+  }
+  async listTools() {
+    return [...await this.adapter.listTools?.() ?? []].sort(
+      (left, right) => left.id.localeCompare(right.id)
+    );
+  }
+  async listSkills() {
+    return [...await this.adapter.listSkills?.() ?? []].sort(
+      (left, right) => left.name.localeCompare(right.name)
+    );
+  }
+  async listSubAgents() {
+    return [...await this.adapter.listSubAgents?.() ?? []].sort(
+      (left, right) => left.name.localeCompare(right.name)
+    );
+  }
+  async listPluginCommands() {
+    return [...await this.adapter.listPluginCommands?.() ?? []].sort(
+      (left, right) => left.name.localeCompare(right.name)
+    );
+  }
+  async executePluginCommand(name, args) {
+    if (!this.adapter.executePluginCommand) {
+      throw new Error("Plugin command execution is not available on this agent-server.");
+    }
+    return await this.adapter.executePluginCommand(name, args);
+  }
+  async compactSessionContext(sessionId) {
+    if (!this.adapter.compactSessionContext) {
+      throw new Error("Context compaction is not available on this agent-server.");
+    }
+    return await this.adapter.compactSessionContext(sessionId);
+  }
+  async undoSessionTurn(sessionId) {
+    if (!this.adapter.undoSessionTurn) {
+      throw new Error("Turn undo is not available on this agent-server.");
+    }
+    return await this.adapter.undoSessionTurn(sessionId);
+  }
+  async getSessionTurnDiff(sessionId) {
+    if (!this.adapter.getSessionTurnDiff) {
+      throw new Error("Turn diff is not available on this agent-server.");
+    }
+    return await this.adapter.getSessionTurnDiff(sessionId);
+  }
+  async listSessions() {
+    const infos = await this.adapter.listSessions();
+    return infos.map((info) => toSessionSummary(info, this.getRuntimeSnapshot(info.id))).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+  }
+  async createSession(options = {}) {
+    const manager = new SessionManager(this.adapter.getSessionStorage());
+    const id = await manager.create({
+      ...options.id ? { id: options.id } : {},
+      cwd: options.cwd ?? this.adapter.cwd,
+      ...options.title ? { title: options.title } : {}
+    });
+    const detail = await this.readSessionOrThrow(id);
+    this.emit({ type: "session/created", session: toSessionSummaryFromDetail(detail) });
+    return detail;
+  }
+  async readSession(sessionId) {
+    const manager = new SessionManager(this.adapter.getSessionStorage());
+    if (!await manager.sessionExists(sessionId)) {
+      return null;
+    }
+    await manager.load(sessionId);
+    const info = await this.findSessionInfo(sessionId);
+    const context = manager.getContext();
+    return {
+      id: sessionId,
+      cwd: context.metadata.cwd,
+      createdAt: info?.createdAt.toISOString() ?? nowIso(),
+      updatedAt: info?.updatedAt.toISOString() ?? nowIso(),
+      messageCount: info?.messageCount ?? context.messages.length,
+      ...context.metadata.title ? { title: context.metadata.title } : {},
+      ...context.metadata.name ? { name: context.metadata.name } : {},
+      ...info?.parentSessionId ? { parentSessionId: info.parentSessionId } : {},
+      ...info?.firstMessage ? { preview: info.firstMessage } : {},
+      ...context.leafId ? { leafId: context.leafId } : {},
+      entries: manager.getEntries(),
+      messages: context.messages,
+      runtime: this.getRuntimeSnapshot(sessionId)
+    };
+  }
+  async deleteSession(sessionId) {
+    const runtime = this.sessionRuntime.get(sessionId);
+    if (runtime && runtime.activeTurnIds.size > 0) {
+      throw new Error(`Cannot delete session "${sessionId}" while turns are running.`);
+    }
+    const deleted = await this.adapter.deleteSession(sessionId);
+    if (deleted) {
+      this.sessionRuntime.delete(sessionId);
+      this.emit({ type: "session/deleted", sessionId });
+    }
+    return deleted;
+  }
+  async branchSession(sessionId, options = {}) {
+    const manager = new SessionManager(this.adapter.getSessionStorage());
+    if (!await manager.sessionExists(sessionId)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    await manager.load(sessionId);
+    if (options.leafId) {
+      manager.switchToLeaf(options.leafId);
+    }
+    const branchFrom = manager.getLeafId();
+    if (!branchFrom) {
+      throw new Error(`Session "${sessionId}" has no leaf to branch from.`);
+    }
+    const leafId = await manager.branch(branchFrom, options.summary);
+    this.emit({
+      type: "session/branched",
+      sessionId,
+      leafId,
+      ...options.summary ? { summary: options.summary } : {}
+    });
+    return { sessionId, leafId };
+  }
+  async startTurn(sessionId, message, options = {}) {
+    if (this.hasRunningTurnForSession(sessionId)) {
+      throw new Error(`Session "${sessionId}" already has a running turn.`);
+    }
+    await this.ensureSessionExists(sessionId);
+    const turn = {
+      id: globalThis.crypto.randomUUID(),
+      sessionId,
+      message,
+      startedAt: nowIso(),
+      status: "running",
+      events: [],
+      queuedFollowUpIds: [],
+      abortController: new AbortController()
+    };
+    await this.seedQueuedFollowUps(sessionId, turn.id);
+    this.turns.set(turn.id, turn);
+    const runtime = this.getOrCreateRuntimeRecord(sessionId);
+    runtime.activeTurnIds.add(turn.id);
+    runtime.lastTurnId = turn.id;
+    this.emit({
+      type: "session/runtime",
+      sessionId,
+      runtime: this.getRuntimeSnapshot(sessionId)
+    });
+    this.emit({ type: "turn/started", turn: this.toTurnSnapshot(turn) });
+    void this.runTurn(turn, options);
+    return this.toTurnSnapshot(turn);
+  }
+  getTurn(turnId) {
+    const turn = this.turns.get(turnId);
+    return turn ? this.toTurnDetail(turn) : null;
+  }
+  async waitForTurn(turnId, options = {}) {
+    const turn = this.turns.get(turnId);
+    if (!turn) {
+      throw new Error(`Turn not found: ${turnId}`);
+    }
+    if (isTerminalTurnStatus(turn.status)) {
+      return this.toTurnSnapshot(turn);
+    }
+    return await new Promise((resolve, reject) => {
+      const off = this.subscribe(
+        (notification) => {
+          if (notification.type === "turn/completed" && notification.turn.id === turnId) {
+            cleanup();
+            resolve(notification.turn);
+          }
+        },
+        { turnId }
+      );
+      const timeoutMs = options.timeoutMs ?? 0;
+      const timer = timeoutMs > 0 ? setTimeout(() => {
+        cleanup();
+        reject(new Error(`Timed out waiting for turn "${turnId}"`));
+      }, timeoutMs) : null;
+      const cleanup = () => {
+        off();
+        if (timer) {
+          clearTimeout(timer);
+        }
+      };
+    });
+  }
+  steerTurn(turnId, message) {
+    const turn = this.turns.get(turnId);
+    if (!turn || isTerminalTurnStatus(turn.status) || !this.adapter.steer) {
+      return { id: "", accepted: false };
+    }
+    return this.adapter.steer({
+      turnId,
+      sessionId: turn.sessionId,
+      message
+    });
+  }
+  followUpTurn(turnId, message) {
+    const turn = this.turns.get(turnId);
+    if (!turn || isTerminalTurnStatus(turn.status) || !this.adapter.followUp) {
+      return { id: "", accepted: false };
+    }
+    const response = this.adapter.followUp({
+      turnId,
+      sessionId: turn.sessionId,
+      message
+    });
+    if (!response.accepted) {
+      return response;
+    }
+    const record = createQueuedFollowUpRecord(
+      {
+        id: response.id,
+        sessionId: turn.sessionId,
+        message,
+        timestamp: Date.now()
+      },
+      {
+        mode: this.followUpPolicy.mode,
+        sourceTurnId: turn.id,
+        createdAt: nowIso(),
+        updatedAt: nowIso()
+      }
+    );
+    this.followUps.set(record.id, record);
+    if (!turn.queuedFollowUpIds.includes(record.id)) {
+      turn.queuedFollowUpIds.push(record.id);
+    }
+    return response;
+  }
+  async listFollowUps(options = {}) {
+    if (this.adapter.listFollowUps) {
+      return await this.adapter.listFollowUps(options);
+    }
+    const statuses = options.status ? new Set(Array.isArray(options.status) ? options.status : [options.status]) : void 0;
+    return [...this.followUps.values()].filter((record) => {
+      if (options.sessionId && record.sessionId !== options.sessionId) {
+        return false;
+      }
+      if (options.sourceTurnId && record.sourceTurnId !== options.sourceTurnId) {
+        return false;
+      }
+      if (statuses && !statuses.has(record.status)) {
+        return false;
+      }
+      return true;
+    }).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map((record) => structuredClone(record));
+  }
+  async getFollowUp(followUpId) {
+    if (this.adapter.getFollowUp) {
+      return await this.adapter.getFollowUp(followUpId);
+    }
+    const record = this.followUps.get(followUpId);
+    return record ? structuredClone(record) : null;
+  }
+  async resolveFollowUp(followUpId, action) {
+    if (this.adapter.resolveFollowUp) {
+      const resolved = await this.adapter.resolveFollowUp(followUpId, action);
+      if (resolved) {
+        this.followUps.set(followUpId, structuredClone(resolved));
+      }
+      return resolved;
+    }
+    const existing = this.followUps.get(followUpId);
+    if (!existing || existing.status === "discarded" || existing.status === "applied") {
+      return existing ? structuredClone(existing) : null;
+    }
+    const updated = resolveQueuedFollowUp(existing, action, nowIso());
+    this.followUps.set(followUpId, updated);
+    return structuredClone(updated);
+  }
+  async listTeamNotifications(options = {}) {
+    if (!this.adapter.listTeamNotifications) {
+      return [];
+    }
+    const kinds = options.kind ? new Set(Array.isArray(options.kind) ? options.kind : [options.kind]) : void 0;
+    return [...await this.adapter.listTeamNotifications(options)].filter((notification) => {
+      if (options.teamId && notification.teamId !== options.teamId) {
+        return false;
+      }
+      if (options.memberId && notification.memberId !== options.memberId) {
+        return false;
+      }
+      if (kinds && !kinds.has(notification.kind)) {
+        return false;
+      }
+      return true;
+    }).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map((notification) => structuredClone(notification));
+  }
+  interruptTurn(turnId) {
+    const turn = this.turns.get(turnId);
+    if (!turn || isTerminalTurnStatus(turn.status)) {
+      return false;
+    }
+    this.resolvePendingInputsForTurn(turnId, "deny");
+    void this.adapter.interruptTurn?.({
+      turnId,
+      sessionId: turn.sessionId
+    });
+    turn.abortController.abort();
+    return true;
+  }
+  respondToInputRequest(requestId, payload) {
+    const pending = this.pendingInputs.get(requestId);
+    if (!pending || pending.resolved) {
+      return false;
+    }
+    if (pending.resolve) {
+      this.resolvePendingInput(requestId, pending, payload);
+    } else {
+      pending.resolved = true;
+      this.pendingInputs.delete(requestId);
+      void this.adapter.respondToInputRequest?.(requestId, payload);
+      this.emit({
+        type: "input/resolved",
+        requestId,
+        sessionId: pending.request.sessionId,
+        ...pending.request.turnId ? { turnId: pending.request.turnId } : {}
+      });
+    }
+    if (payload.kind === "approval" && pending.request.kind === "approval") {
+      this.resolveMatchingApprovalRequests(
+        pending.request.request,
+        {
+          action: payload.action,
+          ...payload.feedback ? { feedback: payload.feedback } : {},
+          ...payload.rememberScope ? { rememberScope: payload.rememberScope } : {}
+        }
+      );
+    }
+    return true;
+  }
+  subscribe(listener, options) {
+    const record = { listener, options };
+    this.listeners.add(record);
+    return () => {
+      this.listeners.delete(record);
+    };
+  }
+  async close() {
+    this.teamNotificationUnsubscribe?.();
+    this.resolveAllPendingInputs("deny");
+    const running = [...this.turns.values()].filter(
+      (turn) => !isTerminalTurnStatus(turn.status)
+    );
+    for (const turn of running) {
+      turn.abortController.abort();
+    }
+    await Promise.allSettled(
+      running.map((turn) => this.waitForTurn(turn.id, { timeoutMs: 2e3 }))
+    );
+    this.listeners.clear();
+  }
+  requestApproval(request) {
+    const route = this.resolveInteractiveRequestRoute(request.sessionId);
+    const inputRequest = {
+      id: request.id,
+      kind: "approval",
+      sessionId: route.sessionId,
+      ...route.turnId ? { turnId: route.turnId } : {},
+      createdAt: nowIso(),
+      request
+    };
+    return new Promise((resolve) => {
+      this.pendingInputs.set(request.id, {
+        request: inputRequest,
+        resolve,
+        resolved: false
+      });
+      this.emit({ type: "input/request", request: inputRequest });
+    });
+  }
+  requestHumanInput(request) {
+    const route = this.resolveInteractiveRequestRoute(request.sessionId);
+    const inputRequest = {
+      id: request.id,
+      kind: "human",
+      sessionId: route.sessionId,
+      ...route.turnId ? { turnId: route.turnId } : {},
+      createdAt: nowIso(),
+      request
+    };
+    return new Promise((resolve) => {
+      this.pendingInputs.set(request.id, {
+        request: inputRequest,
+        resolve,
+        resolved: false
+      });
+      this.emit({ type: "input/request", request: inputRequest });
+    });
+  }
+  async runTurn(turn, options) {
+    try {
+      let sequence = 0;
+      for await (const event of this.adapter.chat(turn.sessionId, turn.message, {
+        abort: turn.abortController.signal,
+        ...options.system ? { system: options.system } : {}
+      })) {
+        const record = {
+          sequence: ++sequence,
+          timestamp: nowIso(),
+          event
+        };
+        turn.events.push(record);
+        switch (event.type) {
+          case "approval-request":
+            this.registerEventInputRequest(turn, event);
+            break;
+          case "human-input-request":
+            this.registerEventInputRequest(turn, event);
+            break;
+          case "approval-resolved":
+            this.resolveEventInputRequest(turn, event.id);
+            break;
+          case "human-input-resolved":
+            this.resolveEventInputRequest(turn, event.id);
+            break;
+          case "complete":
+            turn.output = event.output;
+            turn.usage = event.usage;
+            break;
+          case "error":
+            turn.error = event.error.message;
+            break;
+        }
+        this.emit({
+          type: "turn/event",
+          sessionId: turn.sessionId,
+          turnId: turn.id,
+          sequence: record.sequence,
+          timestamp: record.timestamp,
+          event
+        });
+      }
+      if (turn.status === "running") {
+        turn.status = turn.abortController.signal.aborted ? "interrupted" : turn.error ? "failed" : "completed";
+      }
+    } catch (error) {
+      if (isAbortError(error, turn.abortController.signal)) {
+        turn.status = "interrupted";
+      } else {
+        turn.status = "failed";
+        turn.error = error instanceof Error ? error.message : String(error);
+      }
+    } finally {
+      this.captureDeferredFollowUps(turn);
+      this.resolvePendingInputsForTurn(turn.id, "deny");
+      turn.completedAt = nowIso();
+      const runtime = this.getOrCreateRuntimeRecord(turn.sessionId);
+      runtime.activeTurnIds.delete(turn.id);
+      runtime.lastTurnId = turn.id;
+      this.emit({
+        type: "session/runtime",
+        sessionId: turn.sessionId,
+        runtime: this.getRuntimeSnapshot(turn.sessionId)
+      });
+      this.emit({ type: "turn/completed", turn: this.toTurnSnapshot(turn) });
+    }
+  }
+  async ensureSessionExists(sessionId) {
+    const manager = new SessionManager(this.adapter.getSessionStorage());
+    if (await manager.sessionExists(sessionId)) {
+      return;
+    }
+    await manager.create({ id: sessionId, cwd: this.adapter.cwd });
+    const detail = await this.readSessionOrThrow(sessionId);
+    this.emit({ type: "session/created", session: toSessionSummaryFromDetail(detail) });
+  }
+  getOrCreateRuntimeRecord(sessionId) {
+    let record = this.sessionRuntime.get(sessionId);
+    if (!record) {
+      record = { activeTurnIds: /* @__PURE__ */ new Set() };
+      this.sessionRuntime.set(sessionId, record);
+    }
+    return record;
+  }
+  getRuntimeSnapshot(sessionId) {
+    const runtime = this.sessionRuntime.get(sessionId);
+    const activeTurnIds = runtime ? [...runtime.activeTurnIds] : [];
+    return {
+      status: activeTurnIds.length > 0 ? "running" : "idle",
+      activeTurnCount: activeTurnIds.length,
+      activeTurnIds,
+      ...runtime?.lastTurnId ? { lastTurnId: runtime.lastTurnId } : {}
+    };
+  }
+  hasRunningTurnForSession(sessionId) {
+    const runtime = this.sessionRuntime.get(sessionId);
+    return Boolean(runtime && runtime.activeTurnIds.size > 0);
+  }
+  findRunningTurnIdForSession(sessionId) {
+    const runtime = this.sessionRuntime.get(sessionId);
+    if (!runtime) {
+      return void 0;
+    }
+    const [turnId] = runtime.activeTurnIds;
+    return turnId;
+  }
+  resolveInteractiveRequestRoute(sessionId) {
+    let currentSessionId = sessionId;
+    const visited = /* @__PURE__ */ new Set();
+    while (!visited.has(currentSessionId)) {
+      visited.add(currentSessionId);
+      const turnId = this.findRunningTurnIdForSession(currentSessionId);
+      if (turnId) {
+        return { sessionId: currentSessionId, turnId };
+      }
+      const parentSessionId = getDerivedParentSessionId(currentSessionId);
+      if (!parentSessionId) {
+        break;
+      }
+      currentSessionId = parentSessionId;
+    }
+    return { sessionId };
+  }
+  async findSessionInfo(sessionId) {
+    const sessions = await this.adapter.listSessions();
+    return sessions.find((session) => session.id === sessionId) ?? null;
+  }
+  async readSessionOrThrow(sessionId) {
+    const detail = await this.readSession(sessionId);
+    if (!detail) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return detail;
+  }
+  emit(notification) {
+    for (const record of this.listeners) {
+      if (!matchesNotificationSubscription(notification, record.options)) {
+        continue;
+      }
+      record.listener(notification);
+    }
+    if (this.eventBus) {
+      const channel = getNotificationChannel(notification);
+      if (channel) {
+        this.eventBus.publish(channel, notification.type, notification);
+      }
+    }
+  }
+  captureDeferredFollowUps(turn) {
+    if (this.adapter.listFollowUps) {
+      return;
+    }
+    const queued = this.adapter.drainQueuedFollowUps?.() ?? [];
+    if (queued.length === 0) {
+      return;
+    }
+    for (const item of queued) {
+      if (!this.followUps.has(item.id)) {
+        this.followUps.set(
+          item.id,
+          createQueuedFollowUpRecord(
+            {
+              id: item.id,
+              sessionId: turn.sessionId,
+              message: item.message,
+              timestamp: item.createdAt.getTime()
+            },
+            {
+              mode: this.followUpPolicy.mode,
+              sourceTurnId: turn.id,
+              createdAt: item.createdAt.toISOString(),
+              updatedAt: nowIso()
+            }
+          )
+        );
+      }
+      if (!turn.queuedFollowUpIds.includes(item.id)) {
+        turn.queuedFollowUpIds.push(item.id);
+      }
+    }
+  }
+  async seedQueuedFollowUps(sessionId, seededTurnId) {
+    if (this.adapter.listFollowUps) {
+      return;
+    }
+    const ready = [...this.followUps.values()].filter(
+      (record) => record.sessionId === sessionId && canSeedQueuedFollowUp(record)
+    );
+    if (ready.length === 0) {
+      return;
+    }
+    const manager = new SessionManager(this.adapter.getSessionStorage());
+    if (!await manager.sessionExists(sessionId)) {
+      await manager.create({ id: sessionId, cwd: this.adapter.cwd });
+    } else {
+      await manager.load(sessionId);
+    }
+    for (const record of ready) {
+      await manager.addMessage({
+        id: globalThis.crypto.randomUUID(),
+        role: "user",
+        content: record.message,
+        createdAt: new Date(record.createdAt)
+      });
+      this.followUps.set(
+        record.id,
+        markQueuedFollowUpApplied(record, nowIso(), seededTurnId)
+      );
+    }
+  }
+  toTurnSnapshot(turn) {
+    return {
+      id: turn.id,
+      sessionId: turn.sessionId,
+      message: turn.message,
+      startedAt: turn.startedAt,
+      status: turn.status,
+      ...turn.completedAt ? { completedAt: turn.completedAt } : {},
+      ...turn.output !== void 0 ? { output: turn.output } : {},
+      ...turn.usage ? { usage: turn.usage } : {},
+      ...turn.error ? { error: turn.error } : {},
+      ...turn.queuedFollowUpIds.length > 0 ? {
+        queuedFollowUps: turn.queuedFollowUpIds.map((id) => this.followUps.get(id)).filter((record) => Boolean(record)).map((record) => structuredClone(record))
+      } : {}
+    };
+  }
+  toTurnDetail(turn) {
+    return {
+      ...this.toTurnSnapshot(turn),
+      events: [...turn.events]
+    };
+  }
+  resolvePendingInputsForTurn(turnId, action) {
+    for (const [requestId, pending] of this.pendingInputs) {
+      if (pending.resolved || pending.request.turnId !== turnId) {
+        continue;
+      }
+      if (pending.request.kind === "approval") {
+        this.respondToInputRequest(requestId, {
+          kind: "approval",
+          action
+        });
+        continue;
+      }
+      this.respondToInputRequest(requestId, {
+        kind: "human",
+        response: {
+          kind: "text",
+          text: "Human input request cancelled."
+        }
+      });
+    }
+  }
+  resolveAllPendingInputs(action) {
+    for (const requestId of [...this.pendingInputs.keys()]) {
+      const pending = this.pendingInputs.get(requestId);
+      if (!pending) continue;
+      if (pending.request.kind === "approval") {
+        this.respondToInputRequest(requestId, {
+          kind: "approval",
+          action
+        });
+        continue;
+      }
+      this.respondToInputRequest(requestId, {
+        kind: "human",
+        response: {
+          kind: "text",
+          text: "Human input request cancelled."
+        }
+      });
+    }
+  }
+  resolveMatchingApprovalRequests(resolvedRequest, decision) {
+    const payload = {
+      kind: "approval",
+      action: decision.action,
+      ...decision.feedback ? { feedback: decision.feedback } : {},
+      ...decision.rememberScope ? { rememberScope: decision.rememberScope } : {}
+    };
+    for (const [requestId, pending] of [...this.pendingInputs.entries()]) {
+      if (pending.resolved || pending.request.kind !== "approval") {
+        continue;
+      }
+      if (!shouldCascadeApprovalDecision(
+        resolvedRequest,
+        pending.request.request,
+        decision
+      )) {
+        continue;
+      }
+      this.resolvePendingInput(requestId, pending, payload);
+    }
+  }
+  resolvePendingInput(requestId, pending, payload) {
+    pending.resolved = true;
+    this.pendingInputs.delete(requestId);
+    switch (payload.kind) {
+      case "approval":
+        pending.resolve?.({
+          action: payload.action,
+          ...payload.feedback ? { feedback: payload.feedback } : {},
+          ...payload.rememberScope ? { rememberScope: payload.rememberScope } : {}
+        });
+        break;
+      case "human":
+        pending.resolve?.(payload.response);
+        break;
+    }
+    this.emit({
+      type: "input/resolved",
+      requestId,
+      sessionId: pending.request.sessionId,
+      ...pending.request.turnId ? { turnId: pending.request.turnId } : {}
+    });
+  }
+  registerEventInputRequest(turn, event) {
+    const request = event.type === "approval-request" ? {
+      id: event.request.id,
+      kind: "approval",
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      createdAt: nowIso(),
+      request: {
+        id: event.request.id,
+        sessionId: turn.sessionId,
+        tool: event.request.tool,
+        args: event.request.args,
+        description: event.request.description,
+        risk: event.request.risk,
+        patterns: [],
+        timestamp: Date.now(),
+        ...event.request.rememberScopes ? { rememberScopes: event.request.rememberScopes } : {},
+        ...event.request.defaultRememberScope ? { defaultRememberScope: event.request.defaultRememberScope } : {}
+      }
+    } : {
+      id: event.request.id,
+      kind: "human",
+      sessionId: turn.sessionId,
+      turnId: turn.id,
+      createdAt: nowIso(),
+      request: {
+        id: event.request.id,
+        sessionId: turn.sessionId,
+        kind: event.request.kind,
+        title: event.request.title,
+        question: event.request.question,
+        timestamp: Date.now(),
+        ...event.request.options ? { options: event.request.options } : {},
+        ...event.request.allowMultiple !== void 0 ? { allowMultiple: event.request.allowMultiple } : {},
+        ...event.request.placeholder ? { placeholder: event.request.placeholder } : {},
+        ...event.request.confirmLabel ? { confirmLabel: event.request.confirmLabel } : {},
+        ...event.request.denyLabel ? { denyLabel: event.request.denyLabel } : {}
+      }
+    };
+    const existing = this.pendingInputs.get(request.id);
+    if (existing && !existing.resolved) {
+      return;
+    }
+    this.pendingInputs.set(request.id, {
+      request,
+      resolved: false
+    });
+    this.emit({ type: "input/request", request });
+  }
+  resolveEventInputRequest(turn, requestId) {
+    const pending = this.pendingInputs.get(requestId);
+    if (pending && !pending.resolved) {
+      pending.resolved = true;
+      this.pendingInputs.delete(requestId);
+      this.emit({
+        type: "input/resolved",
+        requestId,
+        sessionId: turn.sessionId,
+        turnId: turn.id
+      });
+      return;
+    }
+    this.emit({
+      type: "input/resolved",
+      requestId,
+      sessionId: turn.sessionId,
+      turnId: turn.id
+    });
+  }
+};
+
+// src/runtime/interactive-handlers.ts
+function createServerApprovalRequestHandler(bridge) {
+  if (!bridge.requestApproval) {
+    throw new Error("Interactive request bridge does not support approvals.");
+  }
+  return async (request) => await bridge.requestApproval(request);
+}
+function createServerHumanInputRequestHandler(bridge) {
+  if (!bridge.requestHumanInput) {
+    throw new Error("Interactive request bridge does not support human input.");
+  }
+  return async (request) => await bridge.requestHumanInput(request);
+}
+function createServerInteractiveHandlers(bridge) {
+  return {
+    approval: createServerApprovalRequestHandler(bridge),
+    humanInput: createServerHumanInputRequestHandler(bridge)
+  };
+}
+
+// src/transport/rpc-connection.ts
+var AgentServerRpcConnection = class {
+  server;
+  capabilities;
+  sendEnvelope;
+  unsubscribe = null;
+  constructor(options) {
+    this.server = options.server;
+    this.capabilities = mergeAgentServerCapabilities(
+      this.server.getCapabilities(),
+      options.capabilityOverride
+    );
+    this.sendEnvelope = options.send;
+    this.unsubscribe = this.server.subscribe((notification) => {
+      void this.sendEnvelope({
+        kind: "notification",
+        notification
+      });
+    });
+  }
+  async close() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+  async handleRequest(envelope) {
+    try {
+      const result = await this.dispatchRequest({
+        method: envelope.method,
+        params: envelope.params
+      });
+      await this.sendEnvelope({
+        kind: "response",
+        id: envelope.id,
+        ok: true,
+        result
+      });
+    } catch (error) {
+      await this.sendEnvelope(toErrorResponse(envelope.id, error));
+    }
+  }
+  async dispatchRequest(request) {
+    switch (request.method) {
+      case "initialize":
+        return {
+          protocolVersion: 1,
+          capabilities: this.capabilities
+        };
+      case "capabilities/get":
+        return this.capabilities;
+      case "workspace/summary":
+        return await this.server.getWorkspaceSummary();
+      case "agent/model/get":
+        return await this.server.getModelState();
+      case "agent/model/switch":
+        return await this.server.switchModel(request.params.spec);
+      case "session/status":
+        return await this.server.getSessionRuntimeStatus(request.params.sessionId);
+      case "agent/tools":
+        return await this.server.listTools();
+      case "agent/skills":
+        return await this.server.listSkills();
+      case "agent/sub-agents":
+        return await this.server.listSubAgents();
+      case "plugin-command/list":
+        return await this.server.listPluginCommands();
+      case "plugin-command/execute":
+        return await this.server.executePluginCommand(
+          request.params.name,
+          request.params.args ?? ""
+        );
+      case "session/compact":
+        return await this.server.compactSessionContext(request.params.sessionId);
+      case "session/undo":
+        return await this.server.undoSessionTurn(request.params.sessionId);
+      case "session/diff":
+        return await this.server.getSessionTurnDiff(request.params.sessionId);
+      case "session/list":
+        return await this.server.listSessions();
+      case "session/create":
+        return await this.server.createSession(request.params);
+      case "session/read":
+        return await this.server.readSession(request.params.sessionId);
+      case "session/delete":
+        return await this.server.deleteSession(request.params.sessionId);
+      case "session/branch":
+        return await this.server.branchSession(
+          request.params.sessionId,
+          request.params.options
+        );
+      case "turn/start":
+        return await this.server.startTurn(
+          request.params.sessionId,
+          request.params.message,
+          request.params.options
+        );
+      case "turn/get":
+        return this.server.getTurn(request.params.turnId);
+      case "turn/wait":
+        return await this.server.waitForTurn(
+          request.params.turnId,
+          request.params.options
+        );
+      case "turn/interrupt":
+        return this.server.interruptTurn(request.params.turnId);
+      case "turn/steer":
+        return this.server.steerTurn(request.params.turnId, request.params.message);
+      case "turn/follow-up":
+        return this.server.followUpTurn(
+          request.params.turnId,
+          request.params.message
+        );
+      case "follow-up/list":
+        return await this.server.listFollowUps(request.params?.options);
+      case "follow-up/get":
+        return await this.server.getFollowUp(request.params.followUpId);
+      case "follow-up/resolve":
+        return await this.server.resolveFollowUp(
+          request.params.followUpId,
+          request.params.action
+        );
+      case "team/notification/list":
+        return await this.server.listTeamNotifications(request.params?.options);
+      case "input/respond":
+        return this.server.respondToInputRequest(
+          request.params.requestId,
+          request.params.payload
+        );
+    }
+  }
+};
+function toErrorResponse(id, error) {
+  return {
+    kind: "response",
+    id,
+    ok: false,
+    error: {
+      message: error instanceof Error ? error.message : String(error)
+    }
+  };
+}
+
+// src/transport/stdio.ts
+import { spawn } from "child_process";
+import readline from "readline";
+
+// src/client/remote-client.ts
+var RemoteAgentServerClient = class {
+  transport;
+  requestTimeoutMs;
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  turns = /* @__PURE__ */ new Map();
+  capabilities = null;
+  counter = 0;
+  connected = false;
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+    this.transport.setMessageHandler((envelope) => {
+      void this.handleEnvelope(envelope);
+    });
+    this.transport.setCloseHandler((error) => {
+      this.failPending(error ?? new Error("agent-server transport closed"));
+      this.connected = false;
+    });
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    await this.transport.connect();
+    const result = await this.request(
+      "initialize",
+      {}
+    );
+    this.capabilities = result.capabilities;
+    this.connected = true;
+  }
+  getCapabilities() {
+    if (!this.capabilities) {
+      throw new Error("Agent server client is not connected.");
+    }
+    return this.capabilities;
+  }
+  async getWorkspaceSummary() {
+    return await this.request("workspace/summary", {});
+  }
+  async getSessionRuntimeStatus(sessionId) {
+    return await this.request("session/status", {
+      sessionId
+    });
+  }
+  async getModelState() {
+    return await this.request("agent/model/get", {});
+  }
+  async switchModel(spec) {
+    return await this.request("agent/model/switch", { spec });
+  }
+  async listTools() {
+    return await this.request("agent/tools", {});
+  }
+  async listSkills() {
+    return await this.request("agent/skills", {});
+  }
+  async listSubAgents() {
+    return await this.request("agent/sub-agents", {});
+  }
+  async listPluginCommands() {
+    return await this.request("plugin-command/list", {});
+  }
+  async executePluginCommand(name, args) {
+    return await this.request("plugin-command/execute", { name, args });
+  }
+  async compactSessionContext(sessionId) {
+    return await this.request("session/compact", {
+      sessionId
+    });
+  }
+  async undoSessionTurn(sessionId) {
+    return await this.request("session/undo", { sessionId });
+  }
+  async getSessionTurnDiff(sessionId) {
+    return await this.request("session/diff", { sessionId });
+  }
+  async listSessions() {
+    return await this.request("session/list", {});
+  }
+  async createSession(options) {
+    return await this.request("session/create", options ?? {});
+  }
+  async readSession(sessionId) {
+    return await this.request("session/read", { sessionId });
+  }
+  async deleteSession(sessionId) {
+    return await this.request("session/delete", { sessionId });
+  }
+  async branchSession(sessionId, options) {
+    return await this.request("session/branch", {
+      sessionId,
+      ...options ? { options } : {}
+    });
+  }
+  async startTurn(sessionId, message, options) {
+    return await this.request("turn/start", {
+      sessionId,
+      message,
+      ...options ? { options } : {}
+    });
+  }
+  steerTurn(turnId, message) {
+    void this.request("turn/steer", { turnId, message }).catch((error) => {
+      logFireAndForgetError("turn/steer", error);
+    });
+    return { id: "", accepted: true };
+  }
+  followUpTurn(turnId, message) {
+    void this.request("turn/follow-up", { turnId, message }).catch((error) => {
+      logFireAndForgetError("turn/follow-up", error);
+    });
+    return { id: "", accepted: true };
+  }
+  async listFollowUps(options) {
+    return await this.request("follow-up/list", {
+      ...options ? { options } : {}
+    });
+  }
+  async getFollowUp(followUpId) {
+    return await this.request("follow-up/get", {
+      followUpId
+    });
+  }
+  async resolveFollowUp(followUpId, action) {
+    return await this.request("follow-up/resolve", {
+      followUpId,
+      action
+    });
+  }
+  async listTeamNotifications(options) {
+    return await this.request("team/notification/list", {
+      ...options ? { options } : {}
+    });
+  }
+  getTurn(turnId) {
+    return this.turns.get(turnId) ?? null;
+  }
+  async waitForTurn(turnId, options) {
+    return await this.request("turn/wait", {
+      turnId,
+      ...options ? { options } : {}
+    });
+  }
+  interruptTurn(turnId) {
+    void this.request("turn/interrupt", { turnId }).catch((error) => {
+      logFireAndForgetError("turn/interrupt", error);
+    });
+    return true;
+  }
+  respondToInputRequest(requestId, payload) {
+    void this.request("input/respond", { requestId, payload }).catch((error) => {
+      logFireAndForgetError("input/respond", error);
+    });
+    return true;
+  }
+  subscribe(listener, options) {
+    const record = { listener, options };
+    this.listeners.add(record);
+    return () => {
+      this.listeners.delete(record);
+    };
+  }
+  async close() {
+    this.failPending(new Error("agent-server client closed"));
+    await this.transport.close();
+    this.connected = false;
+  }
+  async disconnect() {
+    await this.close();
+  }
+  async request(method, params) {
+    if (!this.connected && method !== "initialize") {
+      await this.connect();
+    }
+    const id = `req-${++this.counter}`;
+    const result = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`agent-server timeout: ${method}`));
+      }, this.requestTimeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+    });
+    await this.transport.send({
+      kind: "request",
+      id,
+      method,
+      params
+    });
+    return await result;
+  }
+  async handleEnvelope(envelope) {
+    if (envelope.kind === "notification") {
+      this.trackNotification(envelope.notification);
+      for (const record of this.listeners) {
+        if (!matchesNotificationSubscription(envelope.notification, record.options)) {
+          continue;
+        }
+        record.listener(envelope.notification);
+      }
+      return;
+    }
+    if (envelope.kind !== "response") {
+      return;
+    }
+    const pending = this.pending.get(envelope.id);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(envelope.id);
+    if (envelope.ok) {
+      pending.resolve(envelope.result);
+      return;
+    }
+    pending.reject(new Error(envelope.error?.message ?? "agent-server request failed"));
+  }
+  failPending(error) {
+    for (const [id, pending] of this.pending) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+      this.pending.delete(id);
+    }
+  }
+  trackNotification(notification) {
+    switch (notification.type) {
+      case "turn/started":
+      case "turn/completed": {
+        const existing = this.turns.get(notification.turn.id);
+        this.turns.set(notification.turn.id, {
+          ...notification.turn,
+          events: existing?.events ?? []
+        });
+        break;
+      }
+      case "turn/event": {
+        const existing = this.turns.get(notification.turnId);
+        if (!existing) {
+          this.turns.set(notification.turnId, {
+            id: notification.turnId,
+            sessionId: notification.sessionId,
+            message: "",
+            startedAt: notification.timestamp,
+            status: "running",
+            events: [
+              {
+                sequence: notification.sequence,
+                timestamp: notification.timestamp,
+                event: notification.event
+              }
+            ]
+          });
+          return;
+        }
+        existing.events = [
+          ...existing.events,
+          {
+            sequence: notification.sequence,
+            timestamp: notification.timestamp,
+            event: notification.event
+          }
+        ];
+        this.turns.set(notification.turnId, existing);
+        break;
+      }
+    }
+  }
+};
+function logFireAndForgetError(method, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`[agent-server] ${method} fire-and-forget error: ${message}`);
+}
+
+// src/transport/stdio.ts
+function attachAgentServerStdio(server, options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const onError = options.onError ?? defaultTransportErrorHandler;
+  const connection = new AgentServerRpcConnection({
+    server,
+    capabilityOverride: {
+      protocol: {
+        transport: "stdio",
+        reconnectable: false,
+        multiClient: false
+      }
+    },
+    send: async (envelope) => {
+      output.write(`${JSON.stringify(envelope)}
+`);
+    }
+  });
+  const reader = readline.createInterface({ input });
+  reader.on("line", (line) => {
+    void handleStdioLine(line, connection, onError);
+  });
+  reader.on("close", () => {
+    void connection.close();
+  });
+  return {
+    close: async () => {
+      reader.close();
+      await connection.close();
+    }
+  };
+}
+async function connectStdioAgentServerClient(options) {
+  const child = spawn(options.command, options.args ?? [], {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: ["pipe", "pipe", "inherit"]
+  });
+  if (!child.stdout || !child.stdin) {
+    throw new Error("stdio agent-server child process did not expose pipes");
+  }
+  const transport = new StdioAgentServerTransport(child);
+  const client = new RemoteAgentServerClient(transport, {
+    requestTimeoutMs: options.requestTimeoutMs
+  });
+  await client.connect();
+  return client;
+}
+var StdioAgentServerTransport = class {
+  child;
+  reader;
+  onMessage = () => {
+  };
+  onClose = () => {
+  };
+  connected = false;
+  constructor(child) {
+    this.child = child;
+    this.reader = readline.createInterface({ input: child.stdout });
+  }
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    this.reader.on("line", (line) => {
+      const parsed = parseWireEnvelope(line);
+      if (parsed) {
+        this.onMessage(parsed);
+      }
+    });
+    this.child.once("error", (error) => {
+      this.onClose(toError(error));
+    });
+    this.child.once("close", () => {
+      this.onClose(new Error("agent-server stdio process closed"));
+    });
+    this.connected = true;
+  }
+  async send(envelope) {
+    if (!this.connected || this.child.stdin.destroyed) {
+      throw new Error("agent-server stdio transport is not connected");
+    }
+    this.child.stdin.write(`${JSON.stringify(envelope)}
+`);
+  }
+  async close() {
+    this.reader.close();
+    if (!this.child.killed) {
+      this.child.kill();
+    }
+  }
+  setMessageHandler(handler) {
+    this.onMessage = handler;
+  }
+  setCloseHandler(handler) {
+    this.onClose = handler;
+  }
+};
+async function handleStdioLine(line, connection, onError) {
+  const envelope = parseWireEnvelope(line);
+  if (!envelope) {
+    return;
+  }
+  if (envelope.kind !== "request") {
+    return;
+  }
+  try {
+    await connection.handleRequest(envelope);
+  } catch (error) {
+    onError(toError(error));
+  }
+}
+function parseWireEnvelope(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  return isAgentServerWireEnvelope(parsed) ? parsed : null;
+}
+function defaultTransportErrorHandler(error) {
+  process.stderr.write(`agent-server stdio transport error: ${error.message}
+`);
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/transport/websocket.ts
+import WebSocket, { WebSocketServer } from "ws";
+function startAgentServerWebSocketServer(server, options) {
+  const attached = Boolean(options.httpServer);
+  const wss = options.httpServer ? new WebSocketServer({ server: options.httpServer }) : new WebSocketServer({ port: options.port, host: options.host });
+  const ready = attached ? Promise.resolve() : waitForWebSocketServerReady(wss);
+  const connections = /* @__PURE__ */ new Set();
+  wss.on("connection", (socket) => {
+    const connection = new AgentServerRpcConnection({
+      server,
+      capabilityOverride: {
+        protocol: {
+          transport: "websocket",
+          reconnectable: true,
+          multiClient: true
+        }
+      },
+      send: async (envelope) => {
+        if (socket.readyState === WebSocket.OPEN) {
+          socket.send(JSON.stringify(envelope));
+        }
+      }
+    });
+    connections.add(connection);
+    socket.on("message", (data) => {
+      const envelope = parseWireEnvelope2(data);
+      if (!envelope || envelope.kind !== "request") {
+        return;
+      }
+      void connection.handleRequest(envelope);
+    });
+    socket.on("close", () => {
+      connections.delete(connection);
+      void connection.close();
+    });
+  });
+  return {
+    ready,
+    close: async () => {
+      for (const connection of connections) {
+        await connection.close();
+      }
+      await new Promise((resolve, reject) => {
+        wss.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    },
+    address: () => {
+      const bound = attached ? options.httpServer.address() : wss.address();
+      if (bound && typeof bound === "object") {
+        return `ws://${formatConnectableHost(bound.address, options.host)}:${bound.port}`;
+      }
+      const host = formatConnectableHost(options.host ?? "127.0.0.1");
+      return `ws://${host}:${options.port ?? 0}`;
+    }
+  };
+}
+async function connectWebSocketAgentServerClient(options) {
+  const transport = new WebSocketAgentServerTransport(options.url, options.headers);
+  const client = new RemoteAgentServerClient(transport, {
+    requestTimeoutMs: options.requestTimeoutMs
+  });
+  await client.connect();
+  return client;
+}
+var WebSocketAgentServerTransport = class {
+  url;
+  headers;
+  socket = null;
+  onMessage = () => {
+  };
+  onClose = () => {
+  };
+  constructor(url, headers) {
+    this.url = url;
+    this.headers = headers;
+  }
+  async connect() {
+    if (this.socket?.readyState === WebSocket.OPEN) {
+      return;
+    }
+    this.socket = await new Promise((resolve, reject) => {
+      const socket = new WebSocket(this.url, {
+        headers: this.headers
+      });
+      socket.once("open", () => resolve(socket));
+      socket.once("error", (error) => reject(error));
+    });
+    this.socket.on("message", (data) => {
+      const envelope = parseWireEnvelope2(data);
+      if (envelope) {
+        this.onMessage(envelope);
+      }
+    });
+    this.socket.on("close", () => {
+      this.onClose(new Error("agent-server websocket closed"));
+      this.socket = null;
+    });
+    this.socket.on("error", (error) => {
+      this.onClose(error instanceof Error ? error : new Error(String(error)));
+    });
+  }
+  async send(envelope) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+      throw new Error("agent-server websocket is not connected");
+    }
+    this.socket.send(JSON.stringify(envelope));
+  }
+  async close() {
+    const socket = this.socket;
+    this.socket = null;
+    if (!socket) {
+      return;
+    }
+    await new Promise((resolve) => {
+      socket.once("close", () => resolve());
+      socket.close();
+      setTimeout(resolve, 250);
+    });
+  }
+  setMessageHandler(handler) {
+    this.onMessage = handler;
+  }
+  setCloseHandler(handler) {
+    this.onClose = handler;
+  }
+};
+function parseWireEnvelope2(data) {
+  const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : Buffer.from(data).toString("utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return isAgentServerWireEnvelope(parsed) ? parsed : null;
+}
+function formatConnectableHost(address, fallback = "127.0.0.1") {
+  const host = address === "::" || address === "0.0.0.0" ? fallback : address;
+  return host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+}
+function waitForWebSocketServerReady(wss) {
+  if (wss.address()) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const onListening = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const cleanup = () => {
+      wss.off("listening", onListening);
+      wss.off("error", onError);
+    };
+    wss.once("listening", onListening);
+    wss.once("error", onError);
+  });
+}
+
+// src/transport/sse.ts
+function createAgentServerSSEStream(server, sessionId, options) {
+  const encoder = new TextEncoder();
+  let idCounter = 0;
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(":ok\n\n"));
+      const unsubscribe = server.subscribe(
+        (notification) => {
+          const id = String(++idCounter);
+          const event = notification.type;
+          const data = JSON.stringify(notification);
+          controller.enqueue(
+            encoder.encode(`id: ${id}
+event: ${event}
+data: ${data}
+
+`)
+          );
+        },
+        { sessionId }
+      );
+      const cleanup = () => {
+        unsubscribe();
+        try {
+          controller.close();
+        } catch {
+        }
+      };
+      options?.signal?.addEventListener("abort", cleanup, { once: true });
+    }
+  });
+}
+function createEventBusSSEStream(eventBus, channel, options) {
+  const encoder = new TextEncoder();
+  const afterSeq = options?.lastEventId ? parseInt(options.lastEventId, 10) : void 0;
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(":ok\n\n"));
+      const subscription = eventBus.subscribe(channel, {
+        ...afterSeq !== void 0 ? { afterSeq } : {}
+      });
+      const pump = async () => {
+        try {
+          for await (const message of subscription) {
+            const data = JSON.stringify(message.data);
+            controller.enqueue(
+              encoder.encode(
+                `id: ${message.seq}
+event: ${message.type}
+data: ${data}
+
+`
+              )
+            );
+          }
+        } catch {
+        } finally {
+          try {
+            controller.close();
+          } catch {
+          }
+        }
+      };
+      void pump();
+      options?.signal?.addEventListener(
+        "abort",
+        () => {
+          subscription.unsubscribe();
+        },
+        { once: true }
+      );
+    }
+  });
+}
+function createAgentServerSSEResponse(server, sessionId, options) {
+  const body = createAgentServerSSEStream(server, sessionId, options);
+  return new Response(body, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      ...options?.headers
+    }
+  });
+}
+
+// src/client/stream-turn.ts
+async function* streamTurn(client, sessionId, message, options = {}) {
+  const queue = [];
+  let waiter = null;
+  let targetTurnId = null;
+  const unsubscribe = client.subscribe(
+    (notification) => {
+      if (waiter) {
+        const resolve = waiter;
+        waiter = null;
+        resolve(notification);
+        return;
+      }
+      queue.push(notification);
+    },
+    { sessionId }
+  );
+  try {
+    const turn = await client.startTurn(sessionId, message, options);
+    targetTurnId = turn.id;
+    while (true) {
+      const notification = queue.shift() ?? await new Promise((resolve) => {
+        waiter = resolve;
+      });
+      if (!matchesTurnStreamNotification(notification, sessionId, targetTurnId)) {
+        continue;
+      }
+      yield notification;
+      if (notification.type === "turn/completed" && notification.turn.id === targetTurnId) {
+        break;
+      }
+    }
+  } finally {
+    unsubscribe();
+  }
+}
+function matchesTurnStreamNotification(notification, sessionId, turnId) {
+  switch (notification.type) {
+    case "session/created":
+      return notification.session.id === sessionId;
+    case "session/deleted":
+      return notification.sessionId === sessionId;
+    case "session/branched":
+    case "session/runtime":
+      return notification.sessionId === sessionId;
+    case "team/notification":
+      return false;
+    case "turn/started":
+    case "input/request":
+    case "input/resolved":
+    case "turn/completed":
+      if (notification.type === "turn/started" || notification.type === "turn/completed") {
+        return turnId !== null && notification.turn.id === turnId;
+      }
+      return turnId !== null && (notification.type === "input/request" ? notification.request.turnId === turnId : notification.turnId === turnId);
+    case "turn/event":
+      return turnId !== null && notification.turnId === turnId;
+  }
+}
+
+// src/client/in-process-client.ts
+var InProcessAgentServerClient = class {
+  server;
+  constructor(server) {
+    this.server = server;
+  }
+  getCapabilities() {
+    return this.server.getCapabilities();
+  }
+  getWorkspaceSummary() {
+    return this.server.getWorkspaceSummary();
+  }
+  getSessionRuntimeStatus(sessionId) {
+    return this.server.getSessionRuntimeStatus(sessionId);
+  }
+  getModelState() {
+    return this.server.getModelState();
+  }
+  switchModel(spec) {
+    return this.server.switchModel(spec);
+  }
+  listTools() {
+    return this.server.listTools();
+  }
+  listSkills() {
+    return this.server.listSkills();
+  }
+  listSubAgents() {
+    return this.server.listSubAgents();
+  }
+  listPluginCommands() {
+    return this.server.listPluginCommands();
+  }
+  executePluginCommand(name, args) {
+    return this.server.executePluginCommand(name, args);
+  }
+  compactSessionContext(sessionId) {
+    return this.server.compactSessionContext(sessionId);
+  }
+  undoSessionTurn(sessionId) {
+    return this.server.undoSessionTurn(sessionId);
+  }
+  getSessionTurnDiff(sessionId) {
+    return this.server.getSessionTurnDiff(sessionId);
+  }
+  listSessions() {
+    return this.server.listSessions();
+  }
+  createSession(options) {
+    return this.server.createSession(options);
+  }
+  readSession(sessionId) {
+    return this.server.readSession(sessionId);
+  }
+  deleteSession(sessionId) {
+    return this.server.deleteSession(sessionId);
+  }
+  branchSession(sessionId, options) {
+    return this.server.branchSession(sessionId, options);
+  }
+  startTurn(sessionId, message, options) {
+    return this.server.startTurn(sessionId, message, options);
+  }
+  steerTurn(turnId, message) {
+    return this.server.steerTurn(turnId, message);
+  }
+  followUpTurn(turnId, message) {
+    return this.server.followUpTurn(turnId, message);
+  }
+  listFollowUps(options) {
+    return this.server.listFollowUps(options);
+  }
+  getFollowUp(followUpId) {
+    return this.server.getFollowUp(followUpId);
+  }
+  resolveFollowUp(followUpId, action) {
+    return this.server.resolveFollowUp(followUpId, action);
+  }
+  listTeamNotifications(options) {
+    return this.server.listTeamNotifications(options);
+  }
+  getTurn(turnId) {
+    return this.server.getTurn(turnId);
+  }
+  waitForTurn(turnId, options) {
+    return this.server.waitForTurn(turnId, options);
+  }
+  interruptTurn(turnId) {
+    return this.server.interruptTurn(turnId);
+  }
+  respondToInputRequest(requestId, payload) {
+    return this.server.respondToInputRequest(requestId, payload);
+  }
+  subscribe(listener, options) {
+    return this.server.subscribe(listener, options);
+  }
+  async close() {
+    await this.server.close();
+  }
+  async disconnect() {
+    await this.close();
+  }
+};
+function createInProcessAgentServer(agent) {
+  return new InProcessAgentServer(createAgentServerAdapter(agent));
+}
+function createInProcessAgentServerClient(agent) {
+  return new InProcessAgentServerClient(createInProcessAgentServer(agent));
+}
+export {
+  AgentServerRpcConnection,
+  InProcessAgentServer,
+  InProcessAgentServerClient,
+  RemoteAgentServerClient,
+  attachAgentServerStdio,
+  connectStdioAgentServerClient,
+  connectWebSocketAgentServerClient,
+  createAgentServerAdapter,
+  createAgentServerSSEResponse,
+  createAgentServerSSEStream,
+  createDefaultAgentServerCapabilities,
+  createEventBusSSEStream,
+  createInProcessAgentServer,
+  createInProcessAgentServerClient,
+  createServerApprovalRequestHandler,
+  createServerHumanInputRequestHandler,
+  createServerInteractiveHandlers,
+  isAgentServerWireEnvelope,
+  matchesNotificationSubscription,
+  mergeAgentServerCapabilities,
+  startAgentServerWebSocketServer,
+  streamTurn
+};