@mathew-macharia/black-mamba 1.0.4 → 1.0.6

package/src/server/completions.js

@@ -0,0 +1,214 @@
+// 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();
+    }
+  };
+}

package/src/{http.js → server/http.js}

@@ -1,18 +1,17 @@
 // HTTP plumbing: routing, body parsing, API-key validation, JSON/SSE writers, error rendering.
 
 import crypto from "node:crypto";
-import { CONFIG } from "./config.js";
-import { BadRequestError, HttpError } from "./errors.js";
-import { createLogger } from "./logger.js";
-import { formatStreamErrorEvent } from "./response.js";
+import { CONFIG } from "../config.js";
+import { BadRequestError, HttpError } from "../errors.js";
+import { createLogger } from "../logger.js";
+import { formatStreamErrorEvent } from "../pi/response.js";
 
 const SUPPORTED_MODEL_IDS = Object.freeze(["deepseek-chat", "deepseek-reasoner", "deepseek-chat-search", "deepseek-reasoner-search"]);
-const CORS_HEADERS = "Content-Type, Authorization";
+const CORS_HEADERS = "Content-Type, Authorization, X-Session-Id, X-Entry-Id, X-Parent-Id, X-Parent-Session-Id";
 
 export function validateApiKey(req, apiKey) {
-  if (!apiKey) return true; // if no apiKey configured, allow all
   const authHeader = req.headers["authorization"];
-  if (typeof authHeader !== "string" || !authHeader.startsWith("Bearer ")) return false;
+  if (typeof authHeader !== "string" || !authHeader.startsWith("Bearer ") || !apiKey) return false;
   const expected = Buffer.from(apiKey, "utf8");
   const provided = Buffer.from(authHeader.slice("Bearer ".length), "utf8");
   return expected.length === provided.length && crypto.timingSafeEqual(expected, provided);
@@ -69,7 +68,7 @@ export function errorBody(err, sanitize) {
   return { message: sanitize(err instanceof Error ? err.message : "Internal server error"), code: "internal_error" };
 }
 
-async function routeAuthed(req, res, pathname, { handleChatCompletions }) {
+async function routeAuthed(req, res, pathname, { handleChatCompletions, graph }) {
   if (req.method === "GET" && pathname === "/v1/models") {
     const created = Math.floor(Date.now() / 1000);
     sendJson(res, 200, { object: "list", data: SUPPORTED_MODEL_IDS.map((id) => ({ id, object: "model", created, owned_by: "deepseek" })) });
@@ -80,22 +79,41 @@ async function routeAuthed(req, res, pathname, { handleChatCompletions }) {
     return;
   }
 
+  const sessionMatch = pathname.match(/^\/v1\/sessions\/([^/]+)$/);
+  if (sessionMatch) {
+    const piSessionId = decodeURIComponent(sessionMatch[1]);
+    if (req.method === "GET") {
+      const session = await graph.getSession(piSessionId);
+      if (!session) {
+        sendJson(res, 404, { error: { message: `No mapping for pi session ${piSessionId}`, code: "session_not_found" } });
+      } else {
+        sendJson(res, 200, graph.describeSession(session));
+      }
+      return;
+    }
+    if (req.method === "DELETE") {
+      const existed = await graph.deleteSession(piSessionId);
+      sendJson(res, 200, { deleted: existed, piSessionId, note: "The next request for this session will seed a fresh DeepSeek chat." });
+      return;
+    }
+  }
+
   sendJson(res, 404, { error: { message: "Route not found", code: "not_found" } });
 }
 
 /**
  * @param {object} deps
- * @param {(req, res) => Promise<void>} deps.handleChatCompletions
+ * @param {(req, res) => Promise<void>} [deps.handleChatCompletions]
  * @param {() => object} [deps.getStatus]
+ * @param {import("../session/graph.js").SessionGraph} [deps.graph]
  * @param {(err: unknown) => string} deps.sanitize
- * @param {string} [deps.apiKey]
- * @param {object} [deps.logger]
+ * @param {(authorizationHeader: string) => object|null} [deps.resolveAccount]
  */
-export function createRequestHandler({ handleChatCompletions, getStatus = () => ({ status: "ok" }), sanitize, apiKey = CONFIG.apiKey, logger = createLogger("Server") }) {
+export function createRequestHandler({ handleChatCompletions, getStatus, graph, sanitize, apiKey = "", logger = createLogger("Server"), resolveAccount = null }) {
   return async function handleRequest(req, res) {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Headers", CORS_HEADERS);
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
 
     if (req.method === "OPTIONS") {
       res.writeHead(204);
@@ -104,8 +122,24 @@ export function createRequestHandler({ handleChatCompletions, getStatus = () =>
     }
 
     const pathname = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`).pathname;
+    let requestLog = logger;
 
     try {
+      if (resolveAccount) {
+        const account = resolveAccount(req.headers.authorization);
+        if (!account) {
+          sendJson(res, 401, { error: { message: "Invalid API key", code: "invalid_api_key" } });
+          return;
+        }
+        requestLog = account.logger;
+        if (req.method === "GET" && pathname === "/") {
+          sendJson(res, 200, account.auth.statusSummary());
+          return;
+        }
+        await routeAuthed(req, res, pathname, { handleChatCompletions: account.handleChatCompletions, graph: account.graph });
+        return;
+      }
+
       if (req.method === "GET" && pathname === "/") {
         sendJson(res, 200, getStatus());
         return;
@@ -114,12 +148,12 @@ export function createRequestHandler({ handleChatCompletions, getStatus = () =>
         sendJson(res, 401, { error: { message: "Invalid API key", code: "invalid_api_key" } });
         return;
       }
-      await routeAuthed(req, res, pathname, { handleChatCompletions });
+      await routeAuthed(req, res, pathname, { handleChatCompletions, graph });
     } catch (err) {
       const statusCode = err instanceof HttpError ? err.statusCode : 500;
       const body = errorBody(err, sanitize);
-      if (statusCode >= 500) logger.error(`Request error (${req.method} ${pathname}):`, body.message, body.details ? JSON.stringify(body.details) : "");
-      else logger.warn(`Request rejected (${req.method} ${pathname}) ${statusCode}:`, body.message);
+      if (statusCode >= 500) requestLog.error(`Request error (${req.method} ${pathname}):`, body.message, body.details ? JSON.stringify(body.details) : "");
+      else requestLog.warn(`Request rejected (${req.method} ${pathname}) ${statusCode}:`, body.message);
 
       if (!res.headersSent) {
         sendJson(res, statusCode, { error: body });

package/src/{pacing.js → server/pacing.js}

@@ -1,6 +1,6 @@
 // Human-like pacing between consecutive DeepSeek turns (DeepSeek web challenges rapid-fire automation).
 
-import { CONFIG } from "./config.js";
+import { CONFIG } from "../config.js";
 
 export function calculateTurnPacingDelay({ lastFinishedAt, now = Date.now(), minDelayMs = CONFIG.pacing.minTurnDelayMs, maxDelayMs = CONFIG.pacing.maxTurnDelayMs, randomFn = Math.random }) {
   if (!lastFinishedAt || lastFinishedAt <= 0) return 0;

package/src/session/graph.js

@@ -0,0 +1,182 @@
+// Session graph: the mapping between pi's session tree and DeepSeek's chat trees.
+//
+// One Session per pi session id. One Node per LLM request pi made, keyed by the pi entry id at which the
+// request was made (x-entry-id). Each node records which DeepSeek chat session and message it produced and a
+// fingerprint of the context that produced it. DeepSeek message ids are never used as keys because they
+// restart in every DeepSeek chat session.
+
+import { CONFIG } from "../config.js";
+import { createLogger } from "../logger.js";
+import { SESSION_SCHEMA_VERSION, SessionStore } from "./store.js";
+
+/**
+ * @typedef {object} Node
+ * @property {string} piEntryId                 pi entry id at which the request was made
+ * @property {string|null} piParentEntryId      pi entry id of the node this request attached to (null for seeds)
+ * @property {string} strategy                  how the node was created (root_seed | delta | reseed_* ...)
+ * @property {string|null} reason
+ * @property {{ sessionId: string, messageId: number|string, parentMessageId: number|string|null }} deepseek
+ * @property {{ messageCount: number, systemHash: string, prefixHash: string, assistant: { textHash: string, toolCalls: {name:string, argsHash:string}[] } }} context
+ * @property {{ turnTokens: number, cachedTokens: number }} usage
+ * @property {number} createdAt
+ */
+
+export class SessionGraph {
+  constructor({ sessionsDir = CONFIG.sessions.dir, ttlMs = CONFIG.sessions.ttlMs, maxEntries = CONFIG.sessions.maxEntries, logger = createLogger("SessionGraph") } = {}) {
+    this.logger = logger;
+    this.ttlMs = ttlMs;
+    this.maxEntries = maxEntries;
+    this.store = new SessionStore({ dir: sessionsDir, ttlMs, logger });
+    this.sessions = new Map(); // piSessionId -> Session
+    this.cleanupTimer = null;
+  }
+
+  async init() {
+    await this.store.init();
+    await this.pruneExpired();
+  }
+
+  async getSession(piSessionId) {
+    if (!piSessionId) return null;
+    const key = String(piSessionId);
+    let session = this.sessions.get(key);
+    if (!session) {
+      session = await this.store.read(key);
+      if (session) this.sessions.set(key, session);
+    }
+    if (session) session.lastAccessedAt = Date.now();
+    return session ?? null;
+  }
+
+  async createSession(piSessionId) {
+    const key = String(piSessionId);
+    if (!key) throw new Error("piSessionId is required");
+    const existing = await this.getSession(key);
+    if (existing) return existing;
+
+    const now = Date.now();
+    const session = {
+      schemaVersion: SESSION_SCHEMA_VERSION,
+      piSessionId: key,
+      createdAt: now,
+      lastAccessedAt: now,
+      forkedFrom: null,
+      nodes: {},
+    };
+    this.sessions.set(key, session);
+    await this.store.write(key, session);
+    return session;
+  }
+
+  getNode(session, piEntryId) {
+    if (!session || piEntryId === null || piEntryId === undefined) return null;
+    return session.nodes[String(piEntryId)] ?? null;
+  }
+
+  nodeCount(session) {
+    return session ? Object.keys(session.nodes).length : 0;
+  }
+
+  /** Records (or replaces) the node for a pi entry id and persists the session. */
+  async putNode(session, node) {
+    if (!node?.piEntryId) throw new Error("node.piEntryId is required");
+    const key = String(node.piEntryId);
+    if (session.nodes[key]) {
+      this.logger.warn(`Node ${key} in session ${session.piSessionId} already existed and was replaced (pi re-used a leaf entry id).`);
+    }
+    session.nodes[key] = node;
+    session.lastAccessedAt = Date.now();
+    await this.store.write(session.piSessionId, session);
+    return node;
+  }
+
+  /** Copies every node of `source` into `target` (used when pi forks a session; entry ids are preserved by pi). */
+  async adoptNodes(target, source) {
+    for (const [key, node] of Object.entries(source.nodes)) {
+      if (!target.nodes[key]) target.nodes[key] = node;
+    }
+    target.forkedFrom = { piSessionId: source.piSessionId, adoptedAt: Date.now() };
+    target.lastAccessedAt = Date.now();
+    await this.store.write(target.piSessionId, target);
+  }
+
+  /**
+   * Tokens DeepSeek already holds in context when attaching to `node`: the node's own turn plus every
+   * ancestor turn in the same DeepSeek chat session.
+   */
+  branchCachedTokens(session, node) {
+    let total = 0;
+    const visited = new Set();
+    let current = node;
+    while (current && !visited.has(current.piEntryId)) {
+      visited.add(current.piEntryId);
+      if (current.deepseek.sessionId !== node.deepseek.sessionId) break;
+      total += current.usage?.turnTokens || 0;
+      current = current.piParentEntryId ? this.getNode(session, current.piParentEntryId) : null;
+    }
+    return total;
+  }
+
+  async deleteSession(piSessionId) {
+    const key = String(piSessionId);
+    const existed = this.sessions.delete(key);
+    await this.store.remove(key);
+    return existed;
+  }
+
+  async pruneExpired(now = Date.now()) {
+    for (const [key, session] of this.sessions.entries()) {
+      if (now - (session.lastAccessedAt || 0) > this.ttlMs) {
+        this.sessions.delete(key);
+        await this.store.remove(key);
+      }
+    }
+    await this.store.pruneOlderThan(now);
+
+    if (this.sessions.size > this.maxEntries) {
+      const sorted = Array.from(this.sessions.entries()).sort(([, a], [, b]) => (a.lastAccessedAt || 0) - (b.lastAccessedAt || 0));
+      for (const [key] of sorted.slice(0, this.sessions.size - this.maxEntries)) {
+        // Evict from memory only; the file stays until its TTL so the session can be reloaded.
+        this.sessions.delete(key);
+      }
+    }
+  }
+
+  startPeriodicPrune(intervalMs = 60 * 60 * 1000) {
+    this.stopPeriodicPrune();
+    this.cleanupTimer = setInterval(() => {
+      this.pruneExpired().catch((err) => this.logger.warn("Periodic prune error:", err.message));
+    }, intervalMs);
+    this.cleanupTimer.unref?.();
+  }
+
+  stopPeriodicPrune() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  /** Read-only view for the inspection endpoint. */
+  describeSession(session) {
+    return {
+      piSessionId: session.piSessionId,
+      createdAt: new Date(session.createdAt).toISOString(),
+      lastAccessedAt: new Date(session.lastAccessedAt).toISOString(),
+      forkedFrom: session.forkedFrom,
+      nodeCount: this.nodeCount(session),
+      nodes: Object.values(session.nodes)
+        .sort((a, b) => a.createdAt - b.createdAt)
+        .map((n) => ({
+          piEntryId: n.piEntryId,
+          piParentEntryId: n.piParentEntryId,
+          strategy: n.strategy,
+          reason: n.reason,
+          deepseek: n.deepseek,
+          messageCount: n.context.messageCount,
+          turnTokens: n.usage.turnTokens,
+          createdAt: new Date(n.createdAt).toISOString(),
+        })),
+    };
+  }
+}