@mathew-macharia/black-mamba 1.0.3 → 1.0.4

package/docs/install.md

@@ -1,68 +0,0 @@
-# Install
-
-Requires Node.js 18 or newer.
-
-```
-npm install -g @mathew-macharia/black-mamba
-```
-
-The command is `bm`. Run it in the directory that holds your data. That working directory (`process.cwd()`) is where `bm` reads `accounts/` and `.env`. The proof-of-work file `sha3_wasm_bg.wasm` is installed with the package.
-
-```
-<data-directory>/
-  .env                  optional
-  accounts/
-    <name>/
-      api-key.txt
-      curl.txt
-```
-
-`<name>` is the account folder name. It is the name printed in the terminal lines below. One folder is one DeepSeek login. Every account folder must contain both files. See [accounts.md](accounts.md) for the other files the process creates, and [config.md](config.md) for `.env`.
-
-`accounts/<name>/api-key.txt` is one line: the bearer key your app sends as `Authorization: Bearer <key>`. The line is trimmed. An empty file, or the same key in two account folders, stops startup.
-
-`accounts/<name>/curl.txt` is a Chrome DevTools copy of a `chat.deepseek.com` request: "Copy as cURL", "Copy as PowerShell", or a `fetch()` snippet. It must contain an `Authorization: Bearer <deepseek-bearer>` header or a `Cookie` header (or both). A placeholder shape:
-
-```
-curl "<deepseek-url>" -H "authorization: Bearer <deepseek-bearer>" -H "cookie: <cookie>"
-```
-
-Do not commit `accounts/` or `.env`.
-
-From the data directory:
-
-```
-bm
-```
-
-When the server is up, stdout has:
-
-```
-[Server] 🚀 Black Mamba listening on http://localhost:3000
-```
-
-The port is `PORT` (default 3000). Each account then prints one line. Stdout on success:
-
-```
-[Server] <name> logged in successfully
-```
-
-Stderr when the DeepSeek check failed:
-
-```
-[Server] <name> log in failed
-```
-
-The failure reason is appended to `accounts/<name>/logs.txt`, not to that terminal line.
-
-If a login that had succeeded later fails (the 30-minute check, or a DeepSeek auth error on a request), stderr prints:
-
-```
-[Server] <name> logged out
-```
-
-The reason is written to that account's `logs.txt` before the terminal line.
-
-If `accounts/` is missing or has no account folders, stderr is `No accounts found!` and the process exits with status 1. A missing `api-key.txt` or `curl.txt`, or a `curl.txt` that has neither a bearer token nor a cookie, prints `[Startup] Fatal error:` and exits with status 1.
-
-`SIGINT` and `SIGTERM` stop the process. The terminal prints `Received <signal>. Shutting down gracefully...` and the process exits with status 0.

package/docs/mapping.md

@@ -1,11 +0,0 @@
-# Mapping
-
-`stateless_seed`: A request with no `x-session-id` sends the full history into a new DeepSeek chat and records nothing.
-
-`root_seed`: A sessioned request with no stored parent node (first turn, unknown session, or unknown parent entry) sends the full history into a new DeepSeek chat and records the node.
-
-`delta`: The parent node exists and this request's history is that node's context plus its reply plus new messages, so only those new messages are sent on the stored DeepSeek chat and parent message.
-
-`reseed_context_diverged`: The parent node exists, but the history no longer extends it (shorter context, a changed prefix, a missing or edited assistant reply, or a compaction summary), so the full history is sent into a new DeepSeek chat.
-
-`reseed_upstream_rejected`: DeepSeek rejected the chat or parent message a `delta` turn referenced, so the full history is sent into a new DeepSeek chat and that result is the one returned.

package/docs/overview.md

@@ -1,25 +0,0 @@
-# Overview
-
-Black Mamba is an HTTP server. It accepts OpenAI-style chat completion requests and sends each turn to DeepSeek web chat. A client chooses an account with `Authorization: Bearer <key>`, where `<key>` is the text in that account's `api-key.txt`.
-
-The process keeps a local map from Pi session entries to DeepSeek chat ids and message ids. A later turn on the same branch continues that DeepSeek chat and sends only the new messages. A request with no `x-session-id` is stateless: the full history goes to a new DeepSeek chat and nothing is stored.
-
-Credentials come from `accounts/<name>/curl.txt` (DeepSeek bearer token and cookies). They stay in memory. `Set-Cookie` on DeepSeek responses updates the cookie jar. The files are not rewritten.
-
-At startup each account is checked with `GET <DEEPSEEK_BASE_URL>/api/v0/users/current`. A verified account is checked again every 30 minutes.
-
-## Request path
-
-1. The app sends `POST /v1/chat/completions` with the account bearer key and a JSON body whose `messages` array is the conversation so far.
-2. The key selects the account. The body is validated. If `x-session-id` is set, `x-entry-id` is required, and the session graph under `accounts/<name>/.session/` is loaded.
-3. The planner chooses one strategy and renders a single text prompt. A seed strategy sends the full history. `delta` sends only the messages after the stored parent reply. See [mapping.md](mapping.md).
-4. The account waits, when a previous turn has just finished, until the gap since that finish is a random time between `MIN_TURN_DELAY_MS` and `MAX_TURN_DELAY_MS`. The first turn of a process does not wait.
-5. If the plan has no DeepSeek chat id, Black Mamba creates one with `POST <DEEPSEEK_BASE_URL>/api/v0/chat_session/create`.
-6. It requests a proof-of-work challenge from `POST <DEEPSEEK_BASE_URL>/api/v0/chat/create_pow_challenge`, solves it with `sha3_wasm_bg.wasm`, and posts the prompt to `POST <DEEPSEEK_BASE_URL>/api/v0/chat/completion`. The JSON body includes the chat id, the parent message id (`null` for a new chat), `thinking_enabled`, and `search_enabled`. The proof-of-work answer is the `x-ds-pow-response` header.
-7. DeepSeek replies with a server-sent event stream. Black Mamba reads the reply text, any thinking text, `response_message_id`, and the change in accumulated token usage. Citation markers of the form `[reference:N]` and `[citation:N]` are removed from the text.
-8. If the request included `tools`, DSML tool-call blocks in the reply are converted to OpenAI `tool_calls` and removed from the assistant text. Image parts in the request are not forwarded; they are replaced with the text `[image omitted: Black Mamba forwards text only]`.
-9. For a request that carried `x-session-id`, the Pi entry id, the DeepSeek chat id, the DeepSeek message id, and a fingerprint of the context are written under `accounts/<name>/.session/`. A stateless request is not written.
-10. The app receives one JSON chat completion, or an SSE stream when `stream` is true. The response header `x-black-mamba-strategy` names the strategy that was used.
-11. If DeepSeek rejects the stored chat or parent message on a `delta` turn, Black Mamba opens a new chat, sends the full history (`reseed_upstream_rejected`), and answers from that second stream. If that second call fails, or if any other upstream call fails, the error is returned to the app. Upstream failures use HTTP 502.
-
-If the app closes the connection before the response is finished, the DeepSeek request is aborted and the turn is not recorded.

package/src/deepseek/auth-cli.js

@@ -1,119 +0,0 @@
-// Terminal interaction for loading DeepSeek credentials and keeping them healthy.
-
-import readline from "node:readline";
-import { CONFIG } from "../config.js";
-import { createLogger } from "../logger.js";
-import { parseCurlCommand } from "./curl-parser.js";
-
-const log = createLogger("Auth");
-
-export function readCurlFromTerminal(promptLabel, { input = process.stdin, output = process.stdout } = {}) {
-  return new Promise((resolve, reject) => {
-    const rl = readline.createInterface({ input, output, terminal: Boolean(input.isTTY) });
-    console.log(`\n${promptLabel}`);
-    console.log("  (Chrome DevTools -> Network -> right-click 'completion' -> Copy as cURL or Copy as PowerShell, paste below, then press Enter)\n");
-
-    const lines = [];
-    let resolved = false;
-    const finish = () => {
-      if (resolved) return;
-      resolved = true;
-      rl.close();
-      resolve(lines.join("\n"));
-    };
-
-    rl.on("line", (line) => {
-      const trimmed = line.trim();
-      if (trimmed === "" && lines.length > 0) {
-        const prev = lines[lines.length - 1].trim();
-        if (!prev.endsWith("^") && !prev.endsWith("\\") && !prev.endsWith("`")) {
-          finish();
-          return;
-        }
-      }
-      if (trimmed !== "" || lines.length > 0) lines.push(line);
-    });
-
-    rl.on("close", () => {
-      if (resolved) return;
-      resolved = true;
-      if (lines.length === 0) reject(new Error("Input stream closed before receiving cURL command"));
-      else resolve(lines.join("\n"));
-    });
-  });
-}
-
-/**
- * Owns the interactive credential lifecycle: initial paste, re-prompt on expiry, periodic health checks.
- * @param {{ auth: import("./auth.js").DeepSeekAuth, fetchImpl?: typeof fetch, sanitize: (err: unknown) => string, port?: number }} deps
- */
-export function createAuthSupervisor({ auth, fetchImpl = fetch, sanitize, port = CONFIG.port, config = CONFIG.deepseek }) {
-  let promptInProgress = false;
-  let healthTimer = null;
-
-  function printSummary() {
-    const summary = auth.statusSummary();
-    log.info(`Session active | Bearer token: ${auth.token ? "yes" : "no"} | Cookies in RAM: ${auth.cookies.size}`);
-    if (summary.next_due_expiry) {
-      log.info(`Earliest cookie due: "${summary.next_due_expiry.cookie}" in ${summary.next_due_expiry.remaining}`);
-    }
-    log.info(`Live expiry details available anytime at GET http://localhost:${port}/`);
-  }
-
-  async function promptAndLoad(promptLabel = "📋 Paste your DeepSeek cURL command:") {
-    if (promptInProgress) return;
-    promptInProgress = true;
-    try {
-      while (true) {
-        const rawCurl = await readCurlFromTerminal(promptLabel);
-        try {
-          auth.applyParsedSession(parseCurlCommand(rawCurl));
-          await auth.verify(fetchImpl);
-          printSummary();
-          return;
-        } catch (err) {
-          log.error(`❌ ${sanitize(err)}`);
-          if (!process.stdin.isTTY) throw err;
-          promptLabel = "📋 Please paste a fresh, valid DeepSeek cURL command:";
-        }
-      }
-    } finally {
-      promptInProgress = false;
-    }
-  }
-
-  function reprompt(reason) {
-    auth.markInvalid();
-    log.warn(`⚠️ ${reason}`);
-    if (process.stdin.isTTY && !promptInProgress) {
-      promptAndLoad("🔄 Session expired! Paste a fresh DeepSeek cURL command to resume:").catch((err) => {
-        log.error("Failed to reload session:", sanitize(err));
-      });
-    }
-  }
-
-  function startHealthMonitor() {
-    stopHealthMonitor();
-    healthTimer = setInterval(async () => {
-      if (!auth.verified || promptInProgress) return;
-      try {
-        await auth.verify(fetchImpl);
-        const summary = auth.statusSummary();
-        const expiryInfo = summary.next_due_expiry ? `${summary.next_due_expiry.cookie} due in ${summary.next_due_expiry.remaining}` : "active";
-        log.info(`Health check OK (age: ${summary.session_age}, ${expiryInfo})`);
-      } catch (err) {
-        reprompt(sanitize(err));
-      }
-    }, config.healthCheckIntervalMs);
-    healthTimer.unref?.();
-  }
-
-  function stopHealthMonitor() {
-    if (healthTimer) {
-      clearInterval(healthTimer);
-      healthTimer = null;
-    }
-  }
-
-  return Object.freeze({ promptAndLoad, reprompt, startHealthMonitor, stopHealthMonitor });
-}

package/src/pi/messages.js

@@ -1,130 +0,0 @@
-// Canonical view of OpenAI-format messages and the fingerprints Black Mamba uses to verify that the context pi sends
-// matches the context DeepSeek already holds. Hashes are compared, never used as keys.
-
-import { BadRequestError } from "../errors.js";
-import { canonicalJson, sha256Hex, shortHash } from "../utils/hash.js";
-
-/** Exact prefix pi uses when it turns a compaction entry into a user message (pi-coding-agent core/messages.js). */
-export const PI_COMPACTION_SUMMARY_PREFIX =
-  "The conversation history before this point was compacted into the following summary:\n\n<summary>\n";
-/** Exact prefix pi uses for branch summaries after /tree navigation. */
-export const PI_BRANCH_SUMMARY_PREFIX = "The following is a summary of a branch that this conversation came back from:\n\n<summary>\n";
-
-export function normalizeRole(role) {
-  return typeof role === "string" ? role.trim().toLowerCase() : "";
-}
-
-/**
- * Renders message content to text. Non-text parts are made visible as explicit placeholders instead of being dropped.
- */
-export function contentToText(content) {
-  if (content === null || content === undefined) return "";
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((part) => {
-        if (!part || typeof part !== "object") return "[unsupported content part]";
-        if (part.type === "text") return String(part.text ?? "");
-        if (part.type === "image_url" || part.type === "image") return "[image omitted: Black Mamba forwards text only]";
-        return `[unsupported content part: ${String(part.type)}]`;
-      })
-      .join("\n");
-  }
-  throw new BadRequestError("Message 'content' must be a string or an array of content parts", "invalid_message");
-}
-
-/** Parses tool-call arguments; returns { value, raw } where raw is kept only when the string is not valid JSON. */
-export function parseToolArguments(args) {
-  if (args === undefined || args === null) return { value: {} };
-  if (typeof args === "object") return { value: args };
-  if (typeof args === "string") {
-    try {
-      return { value: JSON.parse(args) };
-    } catch {
-      return { value: null, raw: args };
-    }
-  }
-  return { value: null, raw: String(args) };
-}
-
-export function toolCallName(tc) {
-  return tc?.function?.name ?? tc?.name ?? "";
-}
-
-export function toolCallArguments(tc) {
-  return tc?.function?.arguments ?? tc?.arguments;
-}
-
-/** Structural view of a message that ignores presentation-only fields (reasoning_content, name, ids). */
-export function canonicalizeMessage(msg) {
-  const role = normalizeRole(msg.role);
-  const canonical = { role, content: msg.content === null || msg.content === undefined ? null : contentToText(msg.content) };
-  if (role === "assistant" && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
-    canonical.tool_calls = msg.tool_calls.map((tc) => {
-      const parsed = parseToolArguments(toolCallArguments(tc));
-      return { name: toolCallName(tc), arguments: parsed.raw !== undefined ? parsed.raw : canonicalJson(parsed.value) };
-    });
-  }
-  if (role === "tool") canonical.tool_call_id = msg.tool_call_id ?? null;
-  return canonical;
-}
-
-export function messageHash(msg) {
-  return shortHash(canonicalJson(canonicalizeMessage(msg)));
-}
-
-export function hasLeadingSystem(messages) {
-  const role = normalizeRole(messages[0]?.role);
-  return role === "system" || role === "developer";
-}
-
-/** Hash of the leading system message (or "none"). The system prompt is verified separately from the conversation body. */
-export function systemHash(messages) {
-  return hasLeadingSystem(messages) ? messageHash(messages[0]) : "none";
-}
-
-/**
- * Chain hash over the conversation body (every message except a leading system message) of the first `count` messages.
- * Order-sensitive, so insertions, omissions and edits anywhere in the prefix are detected.
- */
-export function prefixHash(messages, count = messages.length) {
-  const start = hasLeadingSystem(messages) ? 1 : 0;
-  let acc = "bm-v2";
-  for (let i = start; i < count; i++) {
-    acc = sha256Hex(`${acc}:${messageHash(messages[i])}`);
-  }
-  return acc.slice(0, 32);
-}
-
-/** Fingerprint of an assistant reply as Black Mamba produced it (streamed text + emitted tool calls). */
-export function assistantFingerprint({ text, toolCalls = [] }) {
-  return {
-    textHash: shortHash((text ?? "").trim()),
-    toolCalls: toolCalls.map((tc) => {
-      const parsed = parseToolArguments(tc.argumentsString ?? tc.arguments);
-      return { name: tc.name, argsHash: shortHash(parsed.raw !== undefined ? parsed.raw : canonicalJson(parsed.value)) };
-    }),
-  };
-}
-
-/** Fingerprint of an assistant message as pi replays it in a later request. */
-export function assistantFingerprintFromMessage(msg) {
-  return assistantFingerprint({
-    text: contentToText(msg.content),
-    toolCalls: Array.isArray(msg.tool_calls) ? msg.tool_calls.map((tc) => ({ name: toolCallName(tc), arguments: toolCallArguments(tc) })) : [],
-  });
-}
-
-export function fingerprintsEqual(a, b) {
-  if (!a || !b) return false;
-  if (a.textHash !== b.textHash || a.toolCalls.length !== b.toolCalls.length) return false;
-  return a.toolCalls.every((tc, i) => tc.name === b.toolCalls[i].name && tc.argsHash === b.toolCalls[i].argsHash);
-}
-
-export function isCompactionSummaryMessage(msg) {
-  return normalizeRole(msg?.role) === "user" && contentToText(msg.content).startsWith(PI_COMPACTION_SUMMARY_PREFIX);
-}
-
-export function isBranchSummaryMessage(msg) {
-  return normalizeRole(msg?.role) === "user" && contentToText(msg.content).startsWith(PI_BRANCH_SUMMARY_PREFIX);
-}

package/src/server/completions.js

@@ -1,214 +0,0 @@
-// POST /v1/chat/completions orchestration: parse -> plan -> DeepSeek turn -> stream back -> record node.
-
-import { CONFIG } from "../config.js";
-import { UpstreamContextRejectedError, UpstreamError } from "../errors.js";
-import { createLogger } from "../logger.js";
-import { consumeDeepSeekSseStream } from "../deepseek/sse.js";
-import { assistantFingerprint } from "../pi/messages.js";
-import { parseChatRequest } from "../pi/request.js";
-import {
-  buildMappingInfo,
-  buildUsageStats,
-  createCompletionMetadata,
-  formatCompletionResponse,
-  formatStreamDeltaEvent,
-  formatStreamFinishEvent,
-  formatStreamReasoningEvent,
-  formatStreamRoleEvent,
-  formatStreamToolCallArgsEvent,
-  formatStreamToolCallStartEvent,
-  formatStreamUsageEvent,
-} from "../pi/response.js";
-import { createToolCallStreamProcessor, parseToolCallsFromText } from "../pi/tool-calls.js";
-import { STRATEGY, planCompletion, reseedAfterUpstreamRejection } from "../session/planner.js";
-import { estimateTokenCount } from "../utils/tokens.js";
-import { readJsonBody, sendJson, startSse, writeSse } from "./http.js";
-
-const STRATEGY_HEADER = "x-black-mamba-strategy";
-
-function describePlan(plan, routing) {
-  const pi = routing ? `${routing.sessionId}/${routing.entryId}` : "stateless";
-  const parent = plan.parentNode ? plan.parentNode.piEntryId : "-";
-  const ds = plan.deepseek.sessionId ? `${plan.deepseek.sessionId}:${plan.deepseek.parentMessageId ?? "root"}` : "new-chat";
-  return `pi=${pi} parent=${parent} strategy=${plan.strategy}${plan.reason ? ` reason=${plan.reason}` : ""} ds=${ds} delta=${plan.deltaMessageCount} prompt_chars=${plan.prompt.length}`;
-}
-
-/**
- * @param {object} deps
- * @param {ReturnType<import("../deepseek/client.js").createDeepSeekClient>} deps.deepseek
- * @param {import("../session/graph.js").SessionGraph} deps.graph
- * @param {ReturnType<import("./pacing.js").createPacer>} deps.pacer
- */
-export function createCompletionHandler({ deepseek, graph, pacer, logger = createLogger("Mapping"), keepAliveIntervalMs = CONFIG.server.keepAliveIntervalMs }) {
-  async function openStream(plan, request, signal) {
-    const dsSessionId = plan.deepseek.sessionId ?? (await deepseek.createChatSession());
-    const { streamBody } = await deepseek.openCompletionStream({
-      chatSessionId: dsSessionId,
-      parentMessageId: plan.deepseek.parentMessageId,
-      prompt: plan.prompt,
-      thinkingEnabled: request.thinkingEnabled,
-      searchEnabled: request.searchEnabled,
-      signal,
-    });
-    return { dsSessionId, streamBody };
-  }
-
-  async function openWithExplicitRecovery(plan, request, signal) {
-    try {
-      return { plan, ...(await openStream(plan, request, signal)) };
-    } catch (err) {
-      if (!(err instanceof UpstreamContextRejectedError) || plan.strategy !== STRATEGY.DELTA) throw err;
-      logger.warn(`DeepSeek rejected chat ${plan.deepseek.sessionId} parent ${plan.deepseek.parentMessageId}: ${err.message}. Re-seeding this branch into a fresh chat.`);
-      const reseeded = reseedAfterUpstreamRejection(request, plan, err.details);
-      logger.info(describePlan(reseeded, request.routing));
-      return { plan: reseeded, ...(await openStream(reseeded, request, signal)) };
-    }
-  }
-
-  function resolveTurnTokens(result, plan, replyText) {
-    if (result.turnTokens > 0) return { turnTokens: result.turnTokens, source: "deepseek" };
-    return { turnTokens: estimateTokenCount(plan.prompt) + estimateTokenCount(replyText), source: "estimated" };
-  }
-
-  async function recordNode({ plan, dsSessionId, result, text, toolCalls, turnTokens }) {
-    if (!plan.record) {
-      if (result.messageId === null || result.messageId === undefined) {
-        logger.warn("DeepSeek stream ended without response_message_id (stateless request; nothing to record).");
-      }
-      return null;
-    }
-    if (result.messageId === null || result.messageId === undefined) {
-      throw new UpstreamError("DeepSeek did not return a response_message_id; this turn cannot be mapped onto the session tree and was not recorded.", {
-        code: "deepseek_missing_message_id",
-        details: { piEntryId: plan.record.piEntryId, deepseekSessionId: dsSessionId },
-      });
-    }
-    const node = {
-      piEntryId: plan.record.piEntryId,
-      piParentEntryId: plan.record.piParentEntryId,
-      strategy: plan.strategy,
-      reason: plan.reason,
-      deepseek: { sessionId: dsSessionId, messageId: result.messageId, parentMessageId: plan.deepseek.parentMessageId },
-      context: { ...plan.record.context, assistant: assistantFingerprint({ text, toolCalls }) },
-      usage: { turnTokens, cachedTokens: plan.cachedTokens },
-      createdAt: Date.now(),
-    };
-    await graph.putNode(plan.session, node);
-    logger.info(`recorded pi=${plan.session.piSessionId}/${node.piEntryId} -> ds=${dsSessionId}:${result.messageId} (parent ${node.deepseek.parentMessageId ?? "root"}, ${turnTokens} turn tokens)`);
-    return node;
-  }
-
-  function mappingInfo({ request, plan, dsSessionId, messageId, usageSource }) {
-    const info = buildMappingInfo({
-      sessionId: request.routing?.sessionId ?? dsSessionId,
-      deepseekSessionId: dsSessionId,
-      messageId,
-      parentMessageId: plan.deepseek.parentMessageId,
-      strategy: plan.strategy,
-      reason: plan.reason,
-      deltaMessageCount: plan.deltaMessageCount,
-    });
-    info.black_mamba.usage_source = usageSource;
-    return info;
-  }
-
-  async function respondJson({ res, request, plan, dsSessionId, streamBody, meta }) {
-    const result = await consumeDeepSeekSseStream(streamBody);
-    let text = result.reply;
-    let toolCalls = [];
-    if (request.tools.length > 0) {
-      const parsed = parseToolCallsFromText(result.reply);
-      text = parsed.cleanText;
-      toolCalls = parsed.toolCalls;
-    }
-    const { turnTokens, source } = resolveTurnTokens(result, plan, result.reply);
-    const fingerprintCalls = toolCalls.map((tc) => ({ name: tc.function.name, argumentsString: tc.function.arguments }));
-    await recordNode({ plan, dsSessionId, result, text, toolCalls: fingerprintCalls, turnTokens });
-
-    const usage = buildUsageStats({ prompt: plan.prompt, reply: result.reply, turnTokens, cachedTokens: plan.cachedTokens });
-    const payload = formatCompletionResponse({
-      ...meta,
-      model: request.model,
-      content: text,
-      toolCalls,
-      usage,
-      mapping: mappingInfo({ request, plan, dsSessionId, messageId: result.messageId, usageSource: source }),
-    });
-    sendJson(res, 200, payload, { [STRATEGY_HEADER]: plan.strategy });
-  }
-
-  async function respondStream({ req, res, request, plan, dsSessionId, streamBody, meta }) {
-    startSse(res, req, { [STRATEGY_HEADER]: plan.strategy });
-    writeSse(res, formatStreamRoleEvent(meta));
-    const keepAlive = setInterval(() => writeSse(res, ": keep-alive\n\n"), keepAliveIntervalMs);
-    keepAlive.unref?.();
-
-    let emittedText = "";
-    const emittedToolCalls = [];
-    const emitText = (content) => {
-      emittedText += content;
-      writeSse(res, formatStreamDeltaEvent(meta, content));
-    };
-    const emitToolCall = ({ index, id, name, argumentsString }) => {
-      emittedToolCalls.push({ name, argumentsString });
-      writeSse(res, formatStreamToolCallStartEvent(meta, { toolCallIndex: index, id, name }));
-      writeSse(res, formatStreamToolCallArgsEvent(meta, { toolCallIndex: index, argumentsChunk: argumentsString }));
-    };
-    const processor = request.tools.length > 0 ? createToolCallStreamProcessor({ onTextDelta: emitText, onToolCall: emitToolCall }) : null;
-
-    let result;
-    try {
-      result = await consumeDeepSeekSseStream(streamBody, (chunk) => {
-        if (chunk.isThinking) writeSse(res, formatStreamReasoningEvent(meta, chunk.text));
-        else if (processor) processor.processChunk(chunk.text);
-        else emitText(chunk.text);
-      });
-      processor?.flush();
-    } finally {
-      clearInterval(keepAlive);
-    }
-
-    const { turnTokens, source } = resolveTurnTokens(result, plan, result.reply);
-    await recordNode({ plan, dsSessionId, result, text: emittedText, toolCalls: emittedToolCalls, turnTokens });
-
-    writeSse(
-      res,
-      formatStreamFinishEvent(meta, {
-        finishReason: emittedToolCalls.length > 0 ? "tool_calls" : "stop",
-        mapping: mappingInfo({ request, plan, dsSessionId, messageId: result.messageId, usageSource: source }),
-      })
-    );
-    if (request.includeUsage) {
-      writeSse(res, formatStreamUsageEvent(meta, buildUsageStats({ prompt: plan.prompt, reply: result.reply, turnTokens, cachedTokens: plan.cachedTokens })));
-    }
-    writeSse(res, "data: [DONE]\n\n");
-    res.end();
-  }
-
-  return async function handleChatCompletions(req, res) {
-    const body = await readJsonBody(req);
-    const request = parseChatRequest(body, req.headers);
-    const initialPlan = await planCompletion({ request, graph, logger });
-    logger.info(describePlan(initialPlan, request.routing));
-
-    // Abort the DeepSeek turn if pi disconnects mid-stream (pi marks its assistant message as aborted and drops it).
-    const abortController = new AbortController();
-    let finished = false;
-    if (typeof res.on === "function") {
-      res.on("close", () => {
-        if (!finished && !res.writableFinished) abortController.abort();
-      });
-    }
-
-    await pacer.apply();
-    try {
-      const { plan, dsSessionId, streamBody } = await openWithExplicitRecovery(initialPlan, request, abortController.signal);
-      const meta = { ...createCompletionMetadata(), model: request.model };
-      if (request.stream) await respondStream({ req, res, request, plan, dsSessionId, streamBody, meta });
-      else await respondJson({ res, request, plan, dsSessionId, streamBody, meta });
-    } finally {
-      finished = true;
-      pacer.recordCompletionFinished();
-    }
-  };
-}