@cursor/bdk 0.2.3 → 0.2.5

package/src/internal/chat-client.ts

@@ -1,594 +0,0 @@
-/**
- * `agent-sdk chat` — a minimal terminal client for a served agent. It
- * drives only the public HTTP API (create session, follow-up, NDJSON
- * stream), so it works against any agent-serve server and demonstrates the
- * same wire protocol the playground and curl use. Renders streamed
- * assistant text live, tool calls inline, and a per-turn usage footer.
- */
-
-import { createInterface } from "node:readline";
-import type { SessionEvent } from "../types.js";
-import { mergeRequestHeaders, type RequestAuth } from "./request-headers.js";
-import { fetchSessionEvents, listSessions } from "./sessions-client.js";
-
-export interface ChatClientOptions extends RequestAuth {
-  baseUrl: string;
-  /**
-   * Optional opening user message. On a TTY (without `oneShot`), this seeds
-   * the first turn and then the REPL stays open for follow-ups. With
-   * `oneShot` (or a non-TTY stdin), send it and exit.
-   */
-  message?: string;
-  /**
-   * Reattach to an existing session. Looks up the current continuation
-   * token via `GET /v1/sessions` when `--continuation-token` is omitted,
-   * replays the transcript, then accepts follow-ups.
-   */
-  sessionId?: string;
-  /** Optional; when omitted with `sessionId`, resolved from `/v1/sessions`. */
-  continuationToken?: string;
-  /**
-   * Exit after the opening `--message` instead of entering the REPL.
-   * Implied when stdin is not a TTY.
-   */
-  oneShot?: boolean;
-  /** Force plain output even on a TTY. */
-  noColor?: boolean;
-  logger?: (line: string) => void;
-}
-
-interface Palette {
-  dim: (s: string) => string;
-  bold: (s: string) => string;
-  cyan: (s: string) => string;
-  green: (s: string) => string;
-  red: (s: string) => string;
-  magenta: (s: string) => string;
-  yellow: (s: string) => string;
-}
-
-const IDENTITY = (s: string): string => s;
-
-function makePalette(enabled: boolean): Palette {
-  if (!enabled) {
-    return {
-      dim: IDENTITY,
-      bold: IDENTITY,
-      cyan: IDENTITY,
-      green: IDENTITY,
-      red: IDENTITY,
-      magenta: IDENTITY,
-      yellow: IDENTITY,
-    };
-  }
-  const wrap =
-    (code: string) =>
-    (s: string): string =>
-      `\u001b[${code}m${s}\u001b[0m`;
-  return {
-    dim: wrap("2"),
-    bold: wrap("1"),
-    cyan: wrap("36"),
-    green: wrap("32"),
-    red: wrap("31"),
-    magenta: wrap("35"),
-    yellow: wrap("33"),
-  };
-}
-
-/** Run the terminal chat client. Resolves when the session/REPL ends. */
-export async function runChat(options: ChatClientOptions): Promise<void> {
-  const baseUrl = options.baseUrl.replace(/\/$/, "");
-  const auth: RequestAuth = {
-    bearerToken: options.bearerToken,
-    headers: options.headers,
-  };
-  const colorEnabled = !options.noColor && process.stdout.isTTY === true && !process.env.NO_COLOR;
-  const c = makePalette(colorEnabled);
-  const write = (s: string): void => {
-    process.stdout.write(s);
-  };
-
-  const health = await getJson(baseUrl, "/v1/health", auth);
-  const agentName = typeof health?.name === "string" ? health.name : "agent-serve";
-  write(`${c.bold(agentName)} ${c.dim(`· ${baseUrl}`)}\n`);
-  const info = await getJson(baseUrl, "/v1/info", auth);
-  if (info && typeof info === "object") {
-    const model = (info as { model?: unknown }).model;
-    const tools = (info as { tools?: unknown[] }).tools ?? [];
-    const modelText = typeof model === "string" ? model : JSON.stringify(model ?? "");
-    write(c.dim(`model ${modelText} · ${tools.length} tool${tools.length === 1 ? "" : "s"}\n`));
-  }
-  write("\n");
-
-  let sessionId: string | undefined = options.sessionId;
-  let continuationToken: string | undefined = options.continuationToken;
-  // Highest event index rendered so far; a follow-up streams from here so it
-  // shows only the new turn, not the replayed transcript.
-  let nextEventIndex = 0;
-
-  if (options.sessionId !== undefined) {
-    const attached = await attachSession({
-      baseUrl,
-      auth,
-      sessionId: options.sessionId,
-      continuationToken: options.continuationToken,
-      agentName,
-      palette: c,
-      write,
-    });
-    sessionId = attached.sessionId;
-    continuationToken = attached.continuationToken;
-    nextEventIndex = attached.nextEventIndex;
-  } else if (options.continuationToken !== undefined) {
-    throw new Error("--continuation-token requires --session (session id to reattach to)");
-  }
-
-  const runTurn = async (message: string, opts: { echoUser?: boolean } = {}): Promise<void> => {
-    // REPL lines are already echoed by readline; only reprint for seeded
-    // `--message` / one-shot so the transcript still shows the user turn.
-    if (opts.echoUser !== false) {
-      write(`${c.cyan("› you")}  ${message}\n`);
-    }
-    const startIndex = sessionId === undefined ? 0 : nextEventIndex;
-    if (sessionId === undefined) {
-      const created = await postJson(baseUrl, "/v1/session", { message }, auth);
-      sessionId = str(created?.sessionId);
-      continuationToken = str(created?.continuationToken);
-    } else {
-      const resp = await postJson(
-        baseUrl,
-        `/v1/session/${sessionId}`,
-        { message, continuationToken },
-        auth,
-      );
-      if (resp?.ok === false) {
-        write(`${c.red("error")} ${str(resp.error)}: ${str(resp.message)}\n\n`);
-        return;
-      }
-      continuationToken = str(resp?.continuationToken) ?? continuationToken;
-    }
-    if (sessionId === undefined) {
-      write(`${c.red("error")} server did not return a session id\n\n`);
-      return;
-    }
-    nextEventIndex = await streamTurn({
-      baseUrl,
-      sessionId,
-      startIndex,
-      auth,
-      agentName,
-      palette: c,
-      write,
-    });
-    write("\n");
-  };
-
-  const oneShot = options.oneShot === true || process.stdin.isTTY !== true;
-
-  if (options.message !== undefined) {
-    await runTurn(options.message);
-    if (oneShot) {
-      return;
-    }
-  }
-
-  write(c.dim("Type a message and press Enter. Ctrl-D or /quit to exit.\n\n"));
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  await new Promise<void>(resolve => {
-    const prompt = (): void => {
-      rl.setPrompt(c.cyan("› "));
-      rl.prompt();
-    };
-    prompt();
-    rl.on("line", line => {
-      const text = line.trim();
-      if (text === "") {
-        prompt();
-        return;
-      }
-      if (text === "/quit" || text === "/exit") {
-        rl.close();
-        return;
-      }
-      rl.pause();
-      runTurn(text, { echoUser: false })
-        .catch(err => {
-          write(`${c.red("error")} ${describe(err)}\n\n`);
-        })
-        .finally(() => {
-          rl.resume();
-          prompt();
-        });
-    });
-    rl.on("close", () => {
-      write(c.dim("\nbye\n"));
-      resolve();
-    });
-  });
-}
-
-/**
- * Resolve the current continuation token for a session via `GET /v1/sessions`.
- * Throws when the session is missing or not followable.
- */
-export async function lookupSessionContinuation(args: {
-  baseUrl: string;
-  sessionId: string;
-  auth?: RequestAuth;
-}): Promise<string> {
-  const sessions = await listSessions({
-    baseUrl: args.baseUrl,
-    auth: args.auth,
-  });
-  const match = sessions.find(s => s.sessionId === args.sessionId);
-  if (match === undefined) {
-    throw new Error(
-      `Session ${args.sessionId} not found in /v1/sessions (wrong id, or not owned by this caller). ` +
-        `Pass --continuation-token if you have it.`,
-    );
-  }
-  const token = str(match.continuationToken);
-  if (token === undefined) {
-    throw new Error(
-      `Session ${args.sessionId} has no continuation token` +
-        (match.mode === "task" ? " (task sessions are not followable)." : "."),
-    );
-  }
-  return token;
-}
-
-async function attachSession(args: {
-  baseUrl: string;
-  auth: RequestAuth;
-  sessionId: string;
-  continuationToken?: string;
-  agentName: string;
-  palette: Palette;
-  write: (s: string) => void;
-}): Promise<{
-  sessionId: string;
-  continuationToken: string;
-  nextEventIndex: number;
-}> {
-  const { palette: c, write } = args;
-  let continuationToken = args.continuationToken;
-
-  if (continuationToken === undefined || continuationToken === "") {
-    continuationToken = await lookupSessionContinuation({
-      baseUrl: args.baseUrl,
-      sessionId: args.sessionId,
-      auth: args.auth,
-    });
-  }
-
-  const events = await fetchSessionEvents({
-    baseUrl: args.baseUrl,
-    sessionId: args.sessionId,
-    auth: args.auth,
-  });
-  if (events.length > 0) {
-    write(c.dim(`reattached ${args.sessionId} · replaying ${events.length} events\n\n`));
-    renderTranscript(events, args.agentName, c, write);
-    write("\n");
-  } else {
-    write(c.dim(`reattached ${args.sessionId}\n\n`));
-  }
-
-  const lastIndex =
-    events.length === 0
-      ? -1
-      : Math.max(...events.map(e => (typeof e.index === "number" ? e.index : -1)));
-
-  return {
-    sessionId: args.sessionId,
-    continuationToken,
-    nextEventIndex: lastIndex + 1,
-  };
-}
-
-/** Compact historical transcript for reattach (final messages + tool calls). */
-function renderTranscript(
-  events: SessionEvent[],
-  agentName: string,
-  c: Palette,
-  write: (s: string) => void,
-): void {
-  for (const event of events) {
-    if (event.type === "message.received") {
-      write(`${c.cyan("› you")}  ${event.data.text}\n`);
-      continue;
-    }
-    if (event.type === "message.completed") {
-      const text = event.data.text?.trim() ?? "";
-      if (text !== "" && event.data.finishReason !== "tool_call") {
-        write(`${c.green(`‹ ${agentName}`)}  ${text}\n`);
-      }
-      continue;
-    }
-    if (event.type === "actions.requested") {
-      for (const call of event.data.calls) {
-        write(`  ${c.magenta("⚙")} ${c.bold(call.toolName)}${c.dim(formatArgs(call.args))}\n`);
-      }
-      continue;
-    }
-    if (event.type === "action.result") {
-      const label = event.data.isError ? c.red("✗") : c.magenta("→");
-      write(`    ${label} ${c.dim(truncate(stringify(event.data.output), 100))}\n`);
-      continue;
-    }
-    if (event.type === "turn.completed") {
-      write(c.dim("  ─ turn done\n"));
-    }
-  }
-}
-
-interface StreamTurnArgs {
-  baseUrl: string;
-  sessionId: string;
-  startIndex: number;
-  auth: RequestAuth | undefined;
-  agentName: string;
-  palette: Palette;
-  write: (s: string) => void;
-}
-
-const TERMINAL_TYPES = new Set(["session.waiting", "session.completed", "session.failed"]);
-
-/** Streams a turn to the terminal; returns the next event index to resume at. */
-async function streamTurn(args: StreamTurnArgs): Promise<number> {
-  const { palette: c, write } = args;
-  const url = `${args.baseUrl}/v1/session/${args.sessionId}/stream?startIndex=${args.startIndex}`;
-  const resp = await fetch(url, { headers: mergeRequestHeaders(args.auth) });
-  if (!resp.ok || resp.body === null) {
-    write(`${c.red("error")} stream failed (${resp.status})\n`);
-    return args.startIndex;
-  }
-
-  const reader = resp.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let assistantOpen = false;
-  let thinkingShown = false;
-  let lastIndex = args.startIndex - 1;
-
-  const closeAssistant = (): void => {
-    if (assistantOpen) {
-      write("\n");
-      assistantOpen = false;
-    }
-  };
-
-  for (;;) {
-    const chunk = await reader.read();
-    if (chunk.done) {
-      break;
-    }
-    buffer += decoder.decode(chunk.value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() ?? "";
-    let stop = false;
-    for (const line of lines) {
-      if (line.trim() === "") {
-        continue;
-      }
-      let event: SessionEvent;
-      try {
-        event = JSON.parse(line) as SessionEvent;
-      } catch {
-        continue;
-      }
-      if (typeof event.index === "number") {
-        lastIndex = event.index;
-      }
-      if (event.type === "agent.bound") {
-        closeAssistant();
-        const { sdkAgentId, url } = event.data;
-        write(`  ${c.cyan("agent")} ${c.bold(sdkAgentId)}\n`);
-        if (url !== undefined) {
-          write(`  ${c.dim(url)}\n`);
-        }
-        continue;
-      }
-      if (
-        event.type === "reasoning.appended" &&
-        event.data.parentCallId === undefined &&
-        !thinkingShown
-      ) {
-        thinkingShown = true;
-        write(c.dim("  · thinking…\n"));
-        continue;
-      }
-      if (event.type === "message.appended") {
-        if (event.data.parentCallId !== undefined) {
-          continue;
-        }
-        if (!assistantOpen) {
-          write(`${c.green(`‹ ${args.agentName}`)}  `);
-          assistantOpen = true;
-        }
-        write(event.data.delta);
-        continue;
-      }
-      if (event.type === "message.completed") {
-        if (event.data.parentCallId !== undefined) {
-          continue;
-        }
-        closeAssistant();
-        continue;
-      }
-      if (event.type === "actions.requested") {
-        closeAssistant();
-        for (const call of event.data.calls) {
-          if (call.toolName === "task" && call.parentCallId === undefined) {
-            continue;
-          }
-          const indent =
-            call.parentCallId !== undefined || event.data.parentCallId !== undefined
-              ? "    "
-              : "  ";
-          write(
-            `${indent}${c.magenta("⚙")} ${c.bold(call.toolName)}${c.dim(formatArgs(call.args))}\n`,
-          );
-        }
-        continue;
-      }
-      if (event.type === "action.approval_requested") {
-        closeAssistant();
-        write(
-          `    ${c.yellow("⏸")} ${c.bold(event.data.toolName)} ${c.dim(
-            "awaiting human approval",
-          )}\n`,
-        );
-        continue;
-      }
-      if (event.type === "action.approval_resolved") {
-        const mark = event.data.decision === "approve" ? c.green("✓") : c.red("✗");
-        write(
-          `    ${mark} ${c.bold(event.data.toolName)} ${c.dim(
-            event.data.decision === "approve" ? "approved" : "denied",
-          )}\n`,
-        );
-        continue;
-      }
-      if (event.type === "action.auth_requested") {
-        closeAssistant();
-        write(
-          `    ${c.yellow("⏸")} ${c.bold(event.data.connection)} ${c.dim(
-            "awaiting MCP authorization",
-          )}\n`,
-        );
-        continue;
-      }
-      if (event.type === "action.auth_resolved") {
-        const mark = event.data.decision === "approve" ? c.green("✓") : c.red("✗");
-        write(
-          `    ${mark} ${c.bold(event.data.connection)} ${c.dim(
-            event.data.decision === "approve" ? "connected" : "denied",
-          )}\n`,
-        );
-        continue;
-      }
-      if (event.type === "action.result") {
-        if (event.data.toolName === "task" && event.data.parentCallId === undefined) {
-          continue;
-        }
-        const label = event.data.isError ? c.red("✗") : c.magenta("→");
-        const indent = event.data.parentCallId !== undefined ? "      " : "    ";
-        write(`${indent}${label} ${c.dim(truncate(stringify(event.data.output), 100))}\n`);
-        continue;
-      }
-      if (event.type === "subagent.called") {
-        closeAssistant();
-        const detail = event.data.description ? ` — ${truncate(event.data.description, 60)}` : "";
-        write(`  ${c.magenta("task")} ${c.bold(event.data.name ?? "subagent")}${c.dim(detail)}\n`);
-        continue;
-      }
-      if (event.type === "turn.completed") {
-        closeAssistant();
-        const usage = event.data.usage;
-        const tokens = usage ? ` · in ${usage.inputTokens} out ${usage.outputTokens} tok` : "";
-        write(c.dim(`  ─ turn done${tokens}\n`));
-        continue;
-      }
-      if (event.type === "turn.failed") {
-        closeAssistant();
-        write(`${c.red("  ✗ turn failed")} ${event.data.message}\n`);
-        continue;
-      }
-      if (TERMINAL_TYPES.has(event.type)) {
-        closeAssistant();
-        stop = true;
-        break;
-      }
-    }
-    if (stop) {
-      break;
-    }
-  }
-  await reader.cancel().catch(() => {});
-  return lastIndex + 1;
-}
-
-// ---------------------------------------------------------------------------
-// HTTP helpers (built-in fetch; node 22+)
-// ---------------------------------------------------------------------------
-
-async function getJson(
-  baseUrl: string,
-  path: string,
-  auth: RequestAuth | undefined,
-): Promise<Record<string, unknown> | undefined> {
-  try {
-    const resp = await fetch(`${baseUrl}${path}`, {
-      headers: mergeRequestHeaders(auth),
-    });
-    const text = await resp.text();
-    return text ? (JSON.parse(text) as Record<string, unknown>) : undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-async function postJson(
-  baseUrl: string,
-  path: string,
-  body: unknown,
-  auth: RequestAuth | undefined,
-): Promise<Record<string, unknown> | undefined> {
-  const resp = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      ...mergeRequestHeaders(auth),
-    },
-    body: JSON.stringify(body),
-  });
-  const text = await resp.text();
-  let parsed: Record<string, unknown> | undefined;
-  if (text) {
-    try {
-      parsed = JSON.parse(text) as Record<string, unknown>;
-    } catch {
-      parsed = { message: text };
-    }
-  }
-  if (!resp.ok) {
-    const anyrunReason = resp.headers.get("x-anyrun-failure-reason");
-    const message =
-      (typeof parsed?.message === "string" && parsed.message !== "" ? parsed.message : undefined) ??
-      (typeof parsed?.error === "string" ? parsed.error : undefined) ??
-      anyrunReason ??
-      `HTTP ${resp.status}`;
-    return { ok: false, error: "http_error", message, status: resp.status };
-  }
-  return parsed;
-}
-
-function str(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined;
-}
-
-function stringify(value: unknown): string {
-  if (value === undefined || value === null) {
-    return "(no output)";
-  }
-  return typeof value === "string" ? value : JSON.stringify(value);
-}
-
-function formatArgs(args: unknown): string {
-  if (args === undefined || args === null) {
-    return "";
-  }
-  const text = typeof args === "string" ? args : JSON.stringify(args);
-  return text === "{}" ? "" : `(${truncate(text, 80)})`;
-}
-
-function truncate(text: string, max: number): string {
-  const oneLine = text.replace(/\s+/g, " ").trim();
-  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
-}
-
-function describe(err: unknown): string {
-  return err instanceof Error ? err.message : String(err);
-}