@cursor/bdk 0.2.1

package/dist/internal/chat-client.js

@@ -0,0 +1,478 @@
+/**
+ * `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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createInterface } from "node:readline";
+import { mergeRequestHeaders } from "./request-headers.js";
+import { fetchSessionEvents, listSessions } from "./sessions-client.js";
+const IDENTITY = (s) => s;
+function makePalette(enabled) {
+    if (!enabled) {
+        return {
+            dim: IDENTITY,
+            bold: IDENTITY,
+            cyan: IDENTITY,
+            green: IDENTITY,
+            red: IDENTITY,
+            magenta: IDENTITY,
+            yellow: IDENTITY,
+        };
+    }
+    const wrap = (code) => (s) => `\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 function runChat(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const baseUrl = options.baseUrl.replace(/\/$/, "");
+        const auth = {
+            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) => {
+            process.stdout.write(s);
+        };
+        const health = yield getJson(baseUrl, "/v1/health", auth);
+        const agentName = typeof (health === null || health === void 0 ? void 0 : health.name) === "string" ? health.name : "agent-serve";
+        write(`${c.bold(agentName)} ${c.dim(`· ${baseUrl}`)}\n`);
+        const info = yield getJson(baseUrl, "/v1/info", auth);
+        if (info && typeof info === "object") {
+            const model = info.model;
+            const tools = (_a = info.tools) !== null && _a !== void 0 ? _a : [];
+            const modelText = typeof model === "string" ? model : JSON.stringify(model !== null && model !== void 0 ? model : "");
+            write(c.dim(`model ${modelText} · ${tools.length} tool${tools.length === 1 ? "" : "s"}\n`));
+        }
+        write("\n");
+        let sessionId = options.sessionId;
+        let continuationToken = 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 = yield 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 = (message_1, ...args_1) => __awaiter(this, [message_1, ...args_1], void 0, function* (message, opts = {}) {
+            var _a;
+            // 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 = yield postJson(baseUrl, "/v1/session", { message }, auth);
+                sessionId = str(created === null || created === void 0 ? void 0 : created.sessionId);
+                continuationToken = str(created === null || created === void 0 ? void 0 : created.continuationToken);
+            }
+            else {
+                const resp = yield postJson(baseUrl, `/v1/session/${sessionId}`, { message, continuationToken }, auth);
+                if ((resp === null || resp === void 0 ? void 0 : resp.ok) === false) {
+                    write(`${c.red("error")} ${str(resp.error)}: ${str(resp.message)}\n\n`);
+                    return;
+                }
+                continuationToken = (_a = str(resp === null || resp === void 0 ? void 0 : resp.continuationToken)) !== null && _a !== void 0 ? _a : continuationToken;
+            }
+            if (sessionId === undefined) {
+                write(`${c.red("error")} server did not return a session id\n\n`);
+                return;
+            }
+            nextEventIndex = yield streamTurn({
+                baseUrl,
+                sessionId,
+                startIndex,
+                auth,
+                agentName,
+                palette: c,
+                write,
+            });
+            write("\n");
+        });
+        const oneShot = options.oneShot === true || process.stdin.isTTY !== true;
+        if (options.message !== undefined) {
+            yield 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 });
+        yield new Promise(resolve => {
+            const prompt = () => {
+                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 function lookupSessionContinuation(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessions = yield 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;
+    });
+}
+function attachSession(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { palette: c, write } = args;
+        let continuationToken = args.continuationToken;
+        if (continuationToken === undefined || continuationToken === "") {
+            continuationToken = yield lookupSessionContinuation({
+                baseUrl: args.baseUrl,
+                sessionId: args.sessionId,
+                auth: args.auth,
+            });
+        }
+        const events = yield 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, agentName, c, write) {
+    var _a;
+    var _b;
+    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 = (_b = (_a = event.data.text) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : "";
+            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"));
+        }
+    }
+}
+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. */
+function streamTurn(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { palette: c, write } = args;
+        const url = `${args.baseUrl}/v1/session/${args.sessionId}/stream?startIndex=${args.startIndex}`;
+        const resp = yield 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 = () => {
+            if (assistantOpen) {
+                write("\n");
+                assistantOpen = false;
+            }
+        };
+        for (;;) {
+            const chunk = yield reader.read();
+            if (chunk.done) {
+                break;
+            }
+            buffer += decoder.decode(chunk.value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = (_a = lines.pop()) !== null && _a !== void 0 ? _a : "";
+            let stop = false;
+            for (const line of lines) {
+                if (line.trim() === "") {
+                    continue;
+                }
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch (_c) {
+                    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((_b = event.data.name) !== null && _b !== void 0 ? _b : "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;
+            }
+        }
+        yield reader.cancel().catch(() => { });
+        return lastIndex + 1;
+    });
+}
+// ---------------------------------------------------------------------------
+// HTTP helpers (built-in fetch; node 22+)
+// ---------------------------------------------------------------------------
+function getJson(baseUrl, path, auth) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const resp = yield fetch(`${baseUrl}${path}`, {
+                headers: mergeRequestHeaders(auth),
+            });
+            const text = yield resp.text();
+            return text ? JSON.parse(text) : undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    });
+}
+function postJson(baseUrl, path, body, auth) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const resp = yield fetch(`${baseUrl}${path}`, {
+            method: "POST",
+            headers: Object.assign({ "content-type": "application/json" }, mergeRequestHeaders(auth)),
+            body: JSON.stringify(body),
+        });
+        const text = yield resp.text();
+        let parsed;
+        if (text) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch (_d) {
+                parsed = { message: text };
+            }
+        }
+        if (!resp.ok) {
+            const anyrunReason = resp.headers.get("x-anyrun-failure-reason");
+            const message = (_c = (_b = (_a = (typeof (parsed === null || parsed === void 0 ? void 0 : parsed.message) === "string" && parsed.message !== "" ? parsed.message : undefined)) !== null && _a !== void 0 ? _a : (typeof (parsed === null || parsed === void 0 ? void 0 : parsed.error) === "string" ? parsed.error : undefined)) !== null && _b !== void 0 ? _b : anyrunReason) !== null && _c !== void 0 ? _c : `HTTP ${resp.status}`;
+            return { ok: false, error: "http_error", message, status: resp.status };
+        }
+        return parsed;
+    });
+}
+function str(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function stringify(value) {
+    if (value === undefined || value === null) {
+        return "(no output)";
+    }
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+function formatArgs(args) {
+    if (args === undefined || args === null) {
+        return "";
+    }
+    const text = typeof args === "string" ? args : JSON.stringify(args);
+    return text === "{}" ? "" : `(${truncate(text, 80)})`;
+}
+function truncate(text, max) {
+    const oneLine = text.replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? `${oneLine.slice(0, max - 1)}…` : oneLine;
+}
+function describe(err) {
+    return err instanceof Error ? err.message : String(err);
+}