@mathew-macharia/black-mamba 1.0.2 → 1.0.4

package/.env.example

@@ -1,13 +1,12 @@
+# Port for Black Mamba central hub server
 PORT=3000
 
-# Human pacing delay between turns (800ms - 2000ms with jitter to mimic human reading pace and avoid Cloudflare CHALLENGE_REQUIRED)
-# MIN_TURN_DELAY_MS=800
-# MAX_TURN_DELAY_MS=2000
+# Single API key to authenticate all requests from Pi and other apps
+API_KEY=bm-secret-key-12345
 
-# DeepSeek biz codes that mean "the chat session / parent message you referenced no longer exists".
-# Only these (plus a narrow "chat_session|parent_message ... not found|invalid|expired" message match) trigger an
-# explicit re-seed of a branch (strategy reseed_upstream_rejected). Every other upstream error surfaces as 502.
-# DEEPSEEK_STALE_CONTEXT_BIZ_CODES=40401,40002
+# Human-like pacing delay between turns per account (800ms - 2000ms with jitter to mimic human pace and avoid Cloudflare challenges)
+MIN_TURN_DELAY_MS=800
+MAX_TURN_DELAY_MS=2000
 
-# Verbose mapping/decoder logging
+# Verbose debug logging (optional)
 # BM_DEBUG=1

package/index.js

@@ -1,31 +1,39 @@
 #!/usr/bin/env node
-// Black Mamba — OpenAI-compatible proxy that maps pi's session tree onto DeepSeek web chat precisely.
-// This file only wires the modules together; see src/ for the implementation.
+// Black Mamba — Central rotational proxy hub for DeepSeek.
+// Converges all added accounts into a single OpenAI-compatible API key.
 
 import http from "node:http";
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
-import { findAccount, listAccountDirs, loadAccounts } from "./src/accounts.js";
+import { createAccountPool, listAccountDirs, loadAccounts } from "./src/accounts.js";
 import { CONFIG } from "./src/config.js";
-import { createLogger } from "./src/logger.js";
+import { createCompletionHandler } from "./src/completions.js";
 import { createPowSolver, loadWasm } from "./src/deepseek/pow.js";
-import { createRequestHandler } from "./src/server/http.js";
-import { createSanitizer } from "./src/utils/sanitize.js";
+import { createRequestHandler } from "./src/http.js";
+import { createLogger } from "./src/logger.js";
+import { createSanitizer } from "./src/sanitize.js";
+
+export function createHubApp({ pool, apiKey = CONFIG.apiKey, logger = createLogger("Server") }) {
+  const sanitize = createSanitizer(() => [
+    apiKey,
+    ...pool.slots.flatMap((slot) => slot.auth.secrets()),
+  ]);
 
-export function createAccountsApp({ slots, logger = createLogger("Server") }) {
-  const sanitize = createSanitizer(() => slots.flatMap((slot) => [slot.apiKey, ...slot.auth.secrets()]));
+  const handleChatCompletions = createCompletionHandler({ pool, logger });
   const handleRequest = createRequestHandler({
-    resolveAccount: (authorization) => findAccount(slots, authorization),
+    handleChatCompletions,
+    getStatus: () => pool.statusSummary(),
     sanitize,
+    apiKey,
     logger,
   });
-  return { slots, handleRequest, sanitize, log: logger };
+
+  return { pool, handleRequest, sanitize, log: logger };
 }
 
 function stopApp(app) {
-  for (const slot of app.slots) {
-    slot.graph.stopPeriodicPrune();
+  for (const slot of app.pool.slots) {
     slot.stopHealthMonitor();
   }
 }
@@ -35,27 +43,38 @@ async function main() {
   try {
     const accountNames = await listAccountDirs();
     if (accountNames.length === 0) {
-      console.error("No accounts found!");
+      console.error("❌ No accounts found! Add at least one account in accounts/<name>/curl.txt");
       process.exit(1);
     }
 
     const log = createLogger("Server");
     const wasm = await loadWasm({ logger: createLogger("WASM") });
-    const slots = await loadAccounts({ powSolver: createPowSolver(wasm), onLoggedOut: (name) => log.error(`${name} logged out`) });
-    app = createAccountsApp({ slots, logger: log });
+    const slots = await loadAccounts({
+      powSolver: createPowSolver(wasm),
+      onLoggedOut: (name) => log.error(`Account [${name}] logged out`),
+    });
+
+    const pool = createAccountPool(slots, { logger: createLogger("Router") });
+    app = createHubApp({ pool, apiKey: CONFIG.apiKey, logger: log });
+
     for (const slot of slots) {
-      slot.graph.startPeriodicPrune();
       slot.startHealthMonitor();
     }
 
     const server = http.createServer((req, res) => {
       app.handleRequest(req, res);
     });
+
     server.listen(CONFIG.port, () => {
-      app.log.info(`🚀 Black Mamba listening on http://localhost:${CONFIG.port}`);
+      app.log.info(`🚀 Black Mamba Hub listening on http://localhost:${CONFIG.port}`);
+      if (CONFIG.apiKey) {
+        app.log.info(`🔑 API Key protection enabled (configured via environment)`);
+      } else {
+        app.log.warn(`⚠️ No API_KEY configured in environment; proxy will accept unauthenticated requests`);
+      }
       for (const slot of slots) {
-        if (slot.auth.verified) app.log.info(`${slot.name} logged in successfully`);
-        else app.log.error(`${slot.name} log in failed`);
+        if (slot.auth.verified) app.log.info(`✅ Account [${slot.name}] verified and ready`);
+        else app.log.error(`❌ Account [${slot.name}] verification failed`);
       }
     });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mathew-macharia/black-mamba",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "OpenAI-compatible proxy that maps chat sessions onto DeepSeek web chat",
   "type": "module",
   "main": "index.js",

package/src/accounts.js

@@ -1,4 +1,4 @@
-// One folder per DeepSeek login: app key, cURL, log file, and session store.
+// Multi-account management and rotational routing pool ("Wi-Fi router" hub).
 
 import path from "node:path";
 import { existsSync } from "node:fs";
@@ -9,11 +9,8 @@ import { createDeepSeekClient } from "./deepseek/client.js";
 import { DeepSeekAuth } from "./deepseek/auth.js";
 import { parseCurlCommand } from "./deepseek/curl-parser.js";
 import { createLogger, createFileSink } from "./logger.js";
-import { createCompletionHandler } from "./server/completions.js";
-import { createPacer } from "./server/pacing.js";
-import { validateApiKey } from "./server/http.js";
-import { SessionGraph } from "./session/graph.js";
-import { createSanitizer } from "./utils/sanitize.js";
+import { createPacer } from "./pacing.js";
+import { createSanitizer } from "./sanitize.js";
 
 function accountsDir(rootDir) {
   return path.join(rootDir, "accounts");
@@ -26,31 +23,33 @@ export async function listAccountDirs(rootDir = CONFIG.rootDir) {
   return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
 }
 
-export function findAccount(slots, authorizationHeader) {
-  const req = { headers: { authorization: authorizationHeader } };
-  return slots.find((slot) => validateApiKey(req, slot.apiKey)) ?? null;
-}
-
-export async function loadAccounts({ rootDir = CONFIG.rootDir, powSolver, fetchImpl = fetch, minDelayMs, maxDelayMs, onLoggedOut = () => {} } = {}) {
+/**
+ * Loads all account slots from accounts/<name>/curl.txt
+ */
+export async function loadAccounts({
+  rootDir = CONFIG.rootDir,
+  powSolver,
+  fetchImpl = fetch,
+  minDelayMs = CONFIG.pacing.minTurnDelayMs,
+  maxDelayMs = CONFIG.pacing.maxTurnDelayMs,
+  onLoggedOut = () => {},
+} = {}) {
   const names = await listAccountDirs(rootDir);
   if (names.length === 0) return [];
 
   const specs = [];
-  const seen = new Map();
   for (const name of names) {
     const dir = path.join(accountsDir(rootDir), name);
-    const apiKey = (await readFile(path.join(dir, "api-key.txt"), "utf8")).trim();
-    const curl = await readFile(path.join(dir, "curl.txt"), "utf8");
-    if (!apiKey) throw new Error(`accounts/${name}/api-key.txt is empty`);
-    if (seen.has(apiKey)) throw new Error(`Duplicate api key in accounts/${seen.get(apiKey)} and accounts/${name}`);
-    seen.set(apiKey, name);
+    const curlPath = path.join(dir, "curl.txt");
+    if (!existsSync(curlPath)) continue;
+    const curl = await readFile(curlPath, "utf8");
     let parsed;
     try {
       parsed = parseCurlCommand(curl);
     } catch (err) {
       throw new Error(`accounts/${name}/curl.txt: ${err.message}`);
     }
-    specs.push({ name, dir, apiKey, parsed });
+    specs.push({ name, dir, parsed });
   }
 
   const slots = [];
@@ -58,10 +57,9 @@ export async function loadAccounts({ rootDir = CONFIG.rootDir, powSolver, fetchI
     const logger = createLogger(spec.name, { sink: createFileSink(path.join(spec.dir, "logs.txt")) });
     const auth = new DeepSeekAuth();
     auth.applyParsedSession(spec.parsed);
-    const sanitize = createSanitizer(() => [spec.apiKey, ...auth.secrets()]);
-    const graph = new SessionGraph({ sessionsDir: path.join(spec.dir, ".session"), logger });
-    await graph.init();
+    const sanitize = createSanitizer(() => auth.secrets());
     const pacer = createPacer({ logger, minDelayMs, maxDelayMs });
+
     let connected = false;
     const noteDisconnect = (reason) => {
       logger.error(sanitize(reason));
@@ -69,8 +67,8 @@ export async function loadAccounts({ rootDir = CONFIG.rootDir, powSolver, fetchI
       connected = false;
       onLoggedOut(spec.name);
     };
+
     const deepseek = createDeepSeekClient({ auth, powSolver, fetchImpl, onAuthFailure: noteDisconnect });
-    const handleChatCompletions = createCompletionHandler({ deepseek, graph, pacer, logger });
 
     let healthTimer = null;
     const stopHealthMonitor = () => {
@@ -101,7 +99,68 @@ export async function loadAccounts({ rootDir = CONFIG.rootDir, powSolver, fetchI
       logger.error(sanitize(err));
     }
 
-    slots.push(Object.freeze({ name: spec.name, apiKey: spec.apiKey, auth, graph, logger, handleChatCompletions, startHealthMonitor, stopHealthMonitor }));
+    slots.push(
+      Object.freeze({
+        name: spec.name,
+        dir: spec.dir,
+        auth,
+        deepseek,
+        pacer,
+        logger,
+        startHealthMonitor,
+        stopHealthMonitor,
+      })
+    );
   }
   return slots;
 }
+
+/**
+ * Creates a round-robin rotational account pool.
+ * Acts like a Wi-Fi router / hub: converges all accounts into a pool and rotates requests across them.
+ */
+export function createAccountPool(slots, { logger = createLogger("Router") } = {}) {
+  let currentIndex = 0;
+
+  function nextAccount() {
+    if (slots.length === 0) {
+      throw new Error("No DeepSeek accounts available in pool. Please add an account in accounts/<name>/curl.txt");
+    }
+
+    // Try finding the next verified account starting at currentIndex
+    for (let i = 0; i < slots.length; i++) {
+      const idx = (currentIndex + i) % slots.length;
+      const candidate = slots[idx];
+      if (candidate.auth.verified) {
+        currentIndex = (idx + 1) % slots.length;
+        logger.info(`🔄 Routed request to account [${candidate.name}] (index ${idx + 1}/${slots.length})`);
+        return candidate;
+      }
+    }
+
+    // If none verified, return next slot anyway
+    const fallback = slots[currentIndex % slots.length];
+    currentIndex = (currentIndex + 1) % slots.length;
+    logger.warn(`⚠️ Routed request to unverified account [${fallback.name}]`);
+    return fallback;
+  }
+
+  function statusSummary() {
+    return {
+      status: "ok",
+      total_accounts: slots.length,
+      verified_accounts: slots.filter((s) => s.auth.verified).length,
+      accounts: slots.map((s) => ({
+        name: s.name,
+        verified: s.auth.verified,
+        ...s.auth.statusSummary(),
+      })),
+    };
+  }
+
+  return Object.freeze({
+    slots,
+    nextAccount,
+    statusSummary,
+  });
+}

package/src/completions.js

@@ -0,0 +1,149 @@
+// POST /v1/chat/completions handler:
+// Stateless prompt dump -> rotational account selection -> human pacing -> DeepSeek turn -> OpenAI stream/JSON.
+
+import { CONFIG } from "./config.js";
+import { createLogger } from "./logger.js";
+import { consumeDeepSeekSseStream } from "./deepseek/sse.js";
+import { renderSeedPrompt } from "./prompt.js";
+import { parseChatRequest } from "./request.js";
+import {
+  buildUsageStats,
+  createCompletionMetadata,
+  formatCompletionResponse,
+  formatStreamDeltaEvent,
+  formatStreamFinishEvent,
+  formatStreamReasoningEvent,
+  formatStreamRoleEvent,
+  formatStreamToolCallArgsEvent,
+  formatStreamToolCallStartEvent,
+  formatStreamUsageEvent,
+} from "./response.js";
+import { createToolCallStreamProcessor, parseToolCallsFromText } from "./tool-calls.js";
+import { estimateTokenCount } from "./tokens.js";
+import { readJsonBody, sendJson, startSse, writeSse } from "./http.js";
+
+/**
+ * @param {object} deps
+ * @param {ReturnType<import("./accounts.js").createAccountPool>} deps.pool
+ * @param {object} [deps.logger]
+ */
+export function createCompletionHandler({ pool, logger = createLogger("Completions"), keepAliveIntervalMs = CONFIG.server.keepAliveIntervalMs }) {
+  async function respondJson({ res, request, account, streamBody, prompt, 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 = result.turnTokens > 0
+      ? result.turnTokens
+      : estimateTokenCount(prompt) + estimateTokenCount(result.reply);
+
+    const usage = buildUsageStats({ prompt, reply: result.reply, turnTokens });
+    const payload = formatCompletionResponse({
+      ...meta,
+      model: request.model,
+      content: text,
+      toolCalls,
+      usage,
+    });
+    sendJson(res, 200, payload);
+  }
+
+  async function respondStream({ req, res, request, account, streamBody, prompt, meta }) {
+    startSse(res, req);
+    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 = result.turnTokens > 0
+      ? result.turnTokens
+      : estimateTokenCount(prompt) + estimateTokenCount(result.reply);
+
+    writeSse(
+      res,
+      formatStreamFinishEvent(meta, {
+        finishReason: emittedToolCalls.length > 0 ? "tool_calls" : "stop",
+      })
+    );
+
+    if (request.includeUsage) {
+      writeSse(res, formatStreamUsageEvent(meta, buildUsageStats({ prompt, reply: result.reply, turnTokens })));
+    }
+    writeSse(res, "data: [DONE]\n\n");
+    res.end();
+  }
+
+  return async function handleChatCompletions(req, res) {
+    const body = await readJsonBody(req);
+    const request = parseChatRequest(body);
+    const prompt = renderSeedPrompt(request.messages, request.tools);
+
+    // Rotational account selection ("Wi-Fi router" hub)
+    const account = pool.nextAccount();
+    logger.info(`Request [${request.model}] -> [${account.name}] (prompt: ${prompt.length} chars, tools: ${request.tools.length})`);
+
+    const abortController = new AbortController();
+    let finished = false;
+    if (typeof res.on === "function") {
+      res.on("close", () => {
+        if (!finished && !res.writableFinished) abortController.abort();
+      });
+    }
+
+    // Apply per-account human pacing
+    await account.pacer.apply();
+
+    try {
+      const { streamBody } = await account.deepseek.openCompletionStream({
+        prompt,
+        thinkingEnabled: request.thinkingEnabled,
+        searchEnabled: request.searchEnabled,
+        signal: abortController.signal,
+      });
+
+      const meta = { ...createCompletionMetadata(), model: request.model };
+      if (request.stream) {
+        await respondStream({ req, res, request, account, streamBody, prompt, meta });
+      } else {
+        await respondJson({ res, request, account, streamBody, prompt, meta });
+      }
+    } finally {
+      finished = true;
+      account.pacer.recordCompletionFinished();
+    }
+  };
+}
+

package/src/config.js

@@ -30,6 +30,7 @@ export function loadConfig(env = process.env, rootDir = ROOT_DIR) {
   return Object.freeze({
     rootDir,
     port: readNumber(env.PORT, 3000),
+    apiKey: (env.API_KEY || env.BM_API_KEY || "").trim(),
     debug: env.BM_DEBUG === "1" || env.BM_DEBUG === "true",
 
     deepseek: Object.freeze({
@@ -44,9 +45,6 @@ export function loadConfig(env = process.env, rootDir = ROOT_DIR) {
       healthCheckIntervalMs: 30 * 60 * 1000,
       estimatedWafTtlMs: 4 * 24 * 60 * 60 * 1000,
       estimatedSessionTtlMs: 30 * 24 * 60 * 60 * 1000,
-      // DeepSeek biz codes that mean "the chat session / parent message you referenced no longer exists".
-      // Only these (plus a narrow message pattern) trigger an explicit re-seed of a stateful branch.
-      staleContextBizCodes: readList(env.DEEPSEEK_STALE_CONTEXT_BIZ_CODES).map(Number),
     }),
 
     server: Object.freeze({
@@ -54,12 +52,6 @@ export function loadConfig(env = process.env, rootDir = ROOT_DIR) {
       keepAliveIntervalMs: 10_000,
     }),
 
-    sessions: Object.freeze({
-      dir: path.join(rootDir, ".sessions"),
-      ttlMs: 14 * 24 * 60 * 60 * 1000,
-      maxEntries: 1000,
-    }),
-
     pacing: Object.freeze({
       minTurnDelayMs: readNumber(env.MIN_TURN_DELAY_MS, 800),
       maxTurnDelayMs: readNumber(env.MAX_TURN_DELAY_MS, 2000),

package/src/deepseek/classify.js

@@ -21,17 +21,17 @@ export function upstreamReason(jsonBody, rawText, status) {
   return jsonBody?.data?.biz_msg || jsonBody?.msg || (rawText ? rawText.slice(0, 200) : "") || `HTTP ${status}`;
 }
 
-/**
- * True only when DeepSeek tells us the chat session or parent message we referenced is gone.
- * Deliberately narrow: anything else is a real failure that must surface to the client.
- */
-export function isStaleContextRejection(res, jsonBody, staleBizCodes = []) {
-  if (!(res.status === 400 || res.status === 404 || res.status === 200)) return false;
-  const bizCode = jsonBody?.data?.biz_code ?? jsonBody?.code;
-  if (typeof bizCode === "number" && staleBizCodes.includes(bizCode)) return true;
-  const msg = String(jsonBody?.data?.biz_msg || jsonBody?.msg || "").toLowerCase();
-  if (!msg) return false;
-  const mentionsContext = /(chat[_ ]?session|parent[_ ]?message|message[_ ]?id)/.test(msg);
-  const mentionsGone = /(not\s*found|invalid|expired|deleted|does not exist|not exist)/.test(msg);
-  return mentionsContext && mentionsGone;
+/** Safe fields from an auth-failure response for account logs. */
+export function deepSeekAuthFacts(res, jsonBody = null) {
+  const facts = { http: res?.status ?? null };
+  const waf = res?.headers?.get?.("x-amzn-waf-action");
+  if (waf) facts.waf = waf;
+  if (jsonBody && typeof jsonBody === "object") {
+    if (jsonBody.code != null) facts.code = jsonBody.code;
+    if (jsonBody.msg != null) facts.msg = String(jsonBody.msg).slice(0, 300);
+    const data = jsonBody.data;
+    if (data?.biz_code != null) facts.biz_code = data.biz_code;
+    if (data?.biz_msg != null) facts.biz_msg = String(data.biz_msg).slice(0, 300);
+  }
+  return facts;
 }

package/src/deepseek/client.js

@@ -1,11 +1,11 @@
 // HTTP client for the DeepSeek web API. Every failure is classified and thrown; nothing is papered over.
 
 import { CONFIG } from "../config.js";
-import { DeepSeekAuthError, UpstreamContextRejectedError, UpstreamError } from "../errors.js";
+import { DeepSeekAuthError, UpstreamError } from "../errors.js";
 import {
+  deepSeekAuthFacts,
   isDeepSeekAuthFailure,
   isHumanChallengeRequired,
-  isStaleContextRejection,
   isWafChallengeResponse,
   upstreamReason,
 } from "./classify.js";
@@ -22,10 +22,12 @@ const SESSION_EXPIRED_NOTICE = "DeepSeek session expired. Paste a fresh cURL in
  * @param {(reason: string) => void} [deps.onAuthFailure]  Called once per detected credential failure.
  */
 export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, config = CONFIG.deepseek, onAuthFailure = () => {} }) {
-  function authFailure(notice) {
+  function authFailure(notice, res, jsonBody = null) {
     auth.markInvalid();
-    onAuthFailure(notice);
-    return new DeepSeekAuthError(notice);
+    const facts = res ? deepSeekAuthFacts(res, jsonBody) : null;
+    if (facts) onAuthFailure(`${notice} ${JSON.stringify(facts)}`);
+    else onAuthFailure(notice);
+    return new DeepSeekAuthError(notice, facts ?? undefined);
   }
 
   function ensureCredentials() {
@@ -51,7 +53,7 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
     const json = await res.json().catch(() => null);
 
     if (isDeepSeekAuthFailure(res, json)) {
-      throw authFailure("DeepSeek session expired while creating chat session. " + SESSION_EXPIRED_NOTICE);
+      throw authFailure("DeepSeek session expired while creating chat session. " + SESSION_EXPIRED_NOTICE, res, json);
     }
     const remoteId = json?.data?.biz_data?.id || json?.data?.biz_data?.chat_session?.id;
     if (!res.ok || typeof remoteId !== "string" || !remoteId) {
@@ -67,7 +69,7 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
     const res = await postJson(config.powChallengeUrl, { target_path: config.powTargetPath });
 
     if (isWafChallengeResponse(res)) {
-      throw authFailure("AWS WAF cookie expired during PoW challenge. " + SESSION_EXPIRED_NOTICE);
+      throw authFailure("AWS WAF cookie expired during PoW challenge. " + SESSION_EXPIRED_NOTICE, res);
     }
     let json;
     try {
@@ -76,7 +78,11 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
       throw new UpstreamError(`Invalid PoW challenge response (HTTP ${res.status})`, { code: "pow_challenge_invalid" });
     }
     if (isDeepSeekAuthFailure(res, json)) {
-      throw authFailure(isHumanChallengeRequired(json) ? HUMAN_CHALLENGE_NOTICE : "DeepSeek session expired during PoW challenge. " + SESSION_EXPIRED_NOTICE);
+      throw authFailure(
+        isHumanChallengeRequired(json) ? HUMAN_CHALLENGE_NOTICE : "DeepSeek session expired during PoW challenge. " + SESSION_EXPIRED_NOTICE,
+        res,
+        json
+      );
     }
     const challenge = json?.data?.biz_data?.challenge;
     if (!res.ok || !challenge) {
@@ -89,21 +95,19 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
   }
 
   /**
-   * Opens a completion stream. Returns the raw SSE body; decoding lives in sse.js.
-   * @param {{ chatSessionId: string, parentMessageId: number|null, prompt: string, thinkingEnabled: boolean, searchEnabled: boolean, signal?: AbortSignal }} params
+   * Opens a completion stream on a fresh DeepSeek chat session. Returns the raw SSE body; decoding lives in sse.js.
+   * @param {{ prompt: string, thinkingEnabled: boolean, searchEnabled: boolean, chatSessionId?: string, signal?: AbortSignal }} params
    */
-  async function openCompletionStream({ chatSessionId, parentMessageId, prompt, thinkingEnabled, searchEnabled, signal }) {
+  async function openCompletionStream({ prompt, thinkingEnabled, searchEnabled, chatSessionId, signal }) {
     ensureCredentials();
-    if (typeof chatSessionId !== "string" || !chatSessionId) {
-      throw new Error("openCompletionStream requires a DeepSeek chat session id");
-    }
+    const sessionId = chatSessionId || (await createChatSession());
 
     const powHeader = powSolver.solve(await fetchPowChallenge());
     const res = await postJson(
       config.chatCompletionUrl,
       {
-        chat_session_id: chatSessionId,
-        parent_message_id: parentMessageId,
+        chat_session_id: sessionId,
+        parent_message_id: null,
         model_type: "default",
         prompt,
         ref_file_ids: [],
@@ -117,7 +121,7 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
     );
 
     if (isWafChallengeResponse(res) || res.status === 401) {
-      throw authFailure("DeepSeek returned unauthorized / WAF challenge on chat completion. " + SESSION_EXPIRED_NOTICE);
+      throw authFailure("DeepSeek returned unauthorized / WAF challenge on chat completion. " + SESSION_EXPIRED_NOTICE, res);
     }
 
     const contentType = res.headers.get("content-type") || "";
@@ -130,12 +134,9 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
         // non-JSON body
       }
       if (isDeepSeekAuthFailure(res, errJson)) {
-        throw authFailure(isHumanChallengeRequired(errJson) ? HUMAN_CHALLENGE_NOTICE : SESSION_EXPIRED_NOTICE);
-      }
-      const details = { status: res.status, body: errJson ?? rawText.slice(0, 500), chat_session_id: chatSessionId, parent_message_id: parentMessageId };
-      if (isStaleContextRejection(res, errJson, config.staleContextBizCodes)) {
-        throw new UpstreamContextRejectedError(`DeepSeek rejected the referenced chat context: ${upstreamReason(errJson, rawText, res.status)}`, details);
+        throw authFailure(isHumanChallengeRequired(errJson) ? HUMAN_CHALLENGE_NOTICE : SESSION_EXPIRED_NOTICE, res, errJson);
       }
+      const details = { status: res.status, body: errJson ?? rawText.slice(0, 500), chat_session_id: sessionId };
       throw new UpstreamError(`DeepSeek completion failed: ${upstreamReason(errJson, rawText, res.status)}`, { details });
     }
 
@@ -144,7 +145,7 @@ export function createDeepSeekClient({ auth, powSolver, fetchImpl = fetch, confi
     }
 
     auth.markVerified();
-    return { streamBody: res.body };
+    return { streamBody: res.body, chatSessionId: sessionId };
   }
 
   return Object.freeze({ createChatSession, openCompletionStream, fetchPowChallenge });

package/src/errors.js

@@ -45,14 +45,3 @@ export class UpstreamError extends HttpError {
     this.name = "UpstreamError";
   }
 }
-
-/**
- * Raised when DeepSeek explicitly rejected the chat session / parent message we referenced.
- * The completion handler converts this into an explicit, logged re-seed for stateful branches.
- */
-export class UpstreamContextRejectedError extends UpstreamError {
-  constructor(message, details) {
-    super(message, { statusCode: 502, code: "deepseek_context_rejected", details });
-    this.name = "UpstreamContextRejectedError";
-  }
-}