abtars 0.1.0-alpha.2 → 0.1.0-alpha.21

package/bundle/direct-api-transport-SLJ2Z6NX.js

@@ -0,0 +1,861 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  classifyError
+} from "./chunk-ZEY6YZAB.js";
+import {
+  recordUsage
+} from "./chunk-OW64RUE5.js";
+import {
+  executeToolCall,
+  getToolSchemas
+} from "./chunk-JU3UBWLN.js";
+import "./chunk-JAJ3DUQ2.js";
+import "./chunk-JRG4EFMP.js";
+import "./chunk-ELRAH7VL.js";
+import "./chunk-L7YHV5DL.js";
+import "./chunk-MV6CJFWR.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-EX2SRTUE.js";
+import {
+  getEnv,
+  init_env_schema
+} from "./chunk-AQVOAQQI.js";
+import {
+  init_logger,
+  logDebug,
+  logInfo,
+  logTrace,
+  logWarn
+} from "./chunk-2BY6I4P5.js";
+import "./chunk-MJ6PHMOK.js";
+import "./chunk-7K2YZTLD.js";
+
+// src/components/transport/direct-api-transport.ts
+init_env_schema();
+init_logger();
+init_log_and_swallow();
+
+// src/components/retry.ts
+var DEFAULTS = { attempts: 3, minDelayMs: 300, maxDelayMs: 3e4, jitter: 0.1 };
+var FATAL_PATTERNS = [
+  /auth.*fail|invalid.*key|unauthorized/i,
+  /model.*not found|not supported/i,
+  /account.*suspended|quota.*exceeded/i,
+  /bot was blocked/i
+];
+function isFatal(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return FATAL_PATTERNS.some((p) => p.test(msg));
+}
+async function withRetry(fn, policy) {
+  const attempts = Math.max(1, policy?.attempts ?? DEFAULTS.attempts);
+  const minDelay = Math.max(0, policy?.minDelayMs ?? DEFAULTS.minDelayMs);
+  const maxDelay = Math.max(minDelay, policy?.maxDelayMs ?? DEFAULTS.maxDelayMs);
+  const jitter = Math.max(0, Math.min(1, policy?.jitter ?? DEFAULTS.jitter));
+  const isRecoverable = policy?.isRecoverable ?? ((err) => !isFatal(err));
+  let lastErr;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i === attempts - 1) break;
+      if (!isRecoverable(err)) break;
+      const hint = policy?.getDelayHint?.(err);
+      const baseDelay = hint ?? Math.min(maxDelay, minDelay * Math.pow(2, i));
+      const offset = jitter > 0 ? (Math.random() * 2 - 1) * jitter * baseDelay : 0;
+      const delayMs = Math.max(0, Math.round(baseDelay + offset));
+      policy?.onAttempt?.({ attempt: i + 1, maxAttempts: attempts, err, delayMs });
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  throw lastErr;
+}
+
+// src/components/transport/conversation-session.ts
+var ConversationSession = class {
+  messages = [];
+  totalPromptTokens = 0;
+  maxContext;
+  constructor(systemPrompt, maxContext) {
+    this.maxContext = maxContext;
+    this.messages.push({ role: "system", content: systemPrompt });
+  }
+  addUser(content, image) {
+    if (image) {
+      this.messages.push({ role: "user", content: [
+        { type: "image_url", image_url: { url: `data:${image.mime};base64,${image.base64}` } },
+        { type: "text", text: content }
+      ] });
+    } else {
+      this.messages.push({ role: "user", content });
+    }
+  }
+  addAssistant(content, toolCalls) {
+    const msg = { role: "assistant", content };
+    if (toolCalls?.length) msg.tool_calls = toolCalls;
+    this.messages.push(msg);
+  }
+  addToolResult(toolCallId, name, content) {
+    this.messages.push({ role: "tool", content, tool_call_id: toolCallId, name });
+  }
+  updateTokens(promptTokens) {
+    this.totalPromptTokens = promptTokens;
+  }
+  get contextPercent() {
+    if (this.maxContext <= 0) return 0;
+    return Math.round(this.totalPromptTokens / this.maxContext * 100);
+  }
+  reset(systemPrompt) {
+    this.messages = [{ role: "system", content: systemPrompt }];
+    this.totalPromptTokens = 0;
+  }
+  /** Roll back to last user message — remove everything after it for clean fallback. */
+  rollbackToLastUser() {
+    for (let i = this.messages.length - 1; i >= 0; i--) {
+      if (this.messages[i].role === "user") {
+        this.messages.splice(i + 1);
+        return;
+      }
+    }
+  }
+  /** Rough token estimate: ~4 chars per token. */
+  estimateTokens() {
+    return Math.round(this.messages.reduce((sum, m) => sum + (typeof m.content === "string" ? m.content.length : 0), 0) / 4);
+  }
+  /** Drop oldest non-system messages until estimated tokens fit within limit. */
+  truncateToFit(maxTokens) {
+    while (this.messages.length > 2 && this.estimateTokens() > maxTokens * 0.85) {
+      this.messages.splice(1, 1);
+    }
+    this.totalPromptTokens = this.estimateTokens();
+  }
+  /** #621: Replace a literal secret value with [REDACTED] across all messages. */
+  scrubFromHistory(value) {
+    for (const msg of this.messages) {
+      if (typeof msg.content === "string" && msg.content.includes(value)) {
+        msg.content = msg.content.replaceAll(value, "[REDACTED]");
+      }
+    }
+  }
+};
+
+// src/components/transport/sse-parser.ts
+init_log_and_swallow();
+var TAG = "sse_parser";
+var STALE_TIMEOUT_MS = 9e4;
+async function* parseSSEStream(response, signal) {
+  const reader = response.body?.getReader();
+  if (!reader) throw new Error("Response body is not readable");
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let lastChunkAt = Date.now();
+  let staleTimer = null;
+  const resetStaleTimer = () => {
+    lastChunkAt = Date.now();
+    if (staleTimer) clearTimeout(staleTimer);
+    staleTimer = setTimeout(() => {
+      if (Date.now() - lastChunkAt >= STALE_TIMEOUT_MS) {
+        reader.cancel("stale stream").catch((err) => logAndSwallow(TAG, "reader.cancel stale", err));
+      }
+    }, STALE_TIMEOUT_MS);
+  };
+  try {
+    resetStaleTimer();
+    while (true) {
+      if (signal.aborted) break;
+      const { done, value } = await reader.read();
+      if (done) break;
+      resetStaleTimer();
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") return;
+        let parsed;
+        try {
+          parsed = JSON.parse(data);
+        } catch (err) {
+          logAndSwallow(TAG, "JSON.parse SSE chunk", err);
+          continue;
+        }
+        if (parsed["usage"]) {
+          const u = parsed["usage"];
+          yield { type: "done", usage: { prompt_tokens: u["prompt_tokens"] ?? 0, completion_tokens: u["completion_tokens"] ?? 0 } };
+        }
+        const choices = parsed["choices"];
+        if (!choices?.length) continue;
+        const delta = choices[0]["delta"];
+        if (!delta) continue;
+        if (typeof delta["content"] === "string" && delta["content"]) {
+          yield { type: "chunk", content: delta["content"] };
+        }
+        const toolCalls = delta["tool_calls"];
+        if (toolCalls) {
+          for (const tc of toolCalls) {
+            const fn = tc["function"];
+            yield {
+              type: "tool_call_delta",
+              index: tc["index"] ?? 0,
+              id: tc["id"],
+              name: fn?.["name"],
+              arguments: fn?.["arguments"]
+            };
+          }
+        }
+      }
+    }
+  } finally {
+    if (staleTimer) clearTimeout(staleTimer);
+    reader.releaseLock();
+  }
+}
+
+// src/components/transport/transport-utils.ts
+init_logger();
+var TAG2 = "direct-api";
+function normalizeToolCalls(raw) {
+  if (raw.length <= 1) return raw;
+  const result = [];
+  for (let i = 0; i < raw.length; i++) {
+    const tc = raw[i];
+    if (tc.function.name) {
+      if (!tc.function.arguments || tc.function.arguments === "{}") {
+        for (let j = i + 1; j < raw.length; j++) {
+          const next = raw[j];
+          if (next.function.name) break;
+          if (next.function.arguments && next.function.arguments !== "{}") {
+            tc.function.arguments = next.function.arguments;
+            i = j;
+            break;
+          }
+        }
+      }
+      result.push(tc);
+    }
+  }
+  if (result.length !== raw.length) {
+    logWarn(TAG2, `Normalized ${raw.length} tool call entries \u2192 ${result.length} (model fragmentation): ${raw.map((tc) => `${tc.function.name || "(unnamed)"}(${tc.function.arguments.slice(0, 60)})`).join(", ")}`);
+  }
+  return result;
+}
+function parseErrorStatus(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const m = /API error (\d+)/.exec(msg);
+  return m ? parseInt(m[1], 10) : 0;
+}
+function parseRetryAfter(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const jsonMatch = /retry[_-]after["\s:]+(\d+(?:\.\d+)?)/i.exec(msg);
+  if (jsonMatch) return Math.ceil(parseFloat(jsonMatch[1]) * 1e3);
+  const resetMatch = /x-ratelimit-reset["\s:]+(\d{10,13})/i.exec(msg);
+  if (resetMatch) {
+    const ts = parseInt(resetMatch[1], 10);
+    const ms = ts < 1e12 ? ts * 1e3 : ts;
+    const delta = ms - Date.now();
+    return delta > 0 ? delta : void 0;
+  }
+  return void 0;
+}
+function parseUsageLimitCooldown(message) {
+  const lower = message.toLowerCase();
+  if (!lower.includes("limit")) return void 0;
+  if (lower.includes("day")) {
+    const tomorrow = /* @__PURE__ */ new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    tomorrow.setHours(0, 0, 0, 0);
+    return tomorrow.getTime() - Date.now();
+  }
+  if (lower.includes("week")) {
+    const now = /* @__PURE__ */ new Date();
+    const daysUntilMonday = (8 - now.getDay()) % 7 || 7;
+    const monday = new Date(now);
+    monday.setDate(monday.getDate() + daysUntilMonday);
+    monday.setHours(0, 0, 0, 0);
+    return monday.getTime() - Date.now();
+  }
+  if (lower.includes("month")) {
+    const now = /* @__PURE__ */ new Date();
+    const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+    return nextMonth.getTime() - Date.now();
+  }
+  return void 0;
+}
+
+// src/components/transport/direct-api-transport.ts
+var TAG3 = "direct-api";
+var DirectApiTransport = class {
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  abortControllers = /* @__PURE__ */ new Map();
+  systemPrompt = "";
+  _contextPercent = -1;
+  _lastAnswer = "";
+  _timeoutOverrideMs = null;
+  _toolCallsSucceeded = 0;
+  _intermediateText = "";
+  _promptStartedAt = null;
+  _lastActivityAt = null;
+  activeEndpoint;
+  activeApiKey;
+  activeModel;
+  _lastPromptTokens = 0;
+  _activeSessionKey = "";
+  _activeUserId = "master";
+  /** Currently active model (may differ from config if on fallback). */
+  get currentModel() {
+    return this.activeModel;
+  }
+  onIntermediateResponse;
+  onToolCallStart;
+  onSegmentBreak;
+  /** Sandbox policy for tool access control (#681). Set by pipeline before prompt. */
+  sandboxPolicy;
+  /** Called when fallback model is selected — send notification before response. */
+  onFallback;
+  /** Cooperative pause check — if returns true, agent loop breaks between tool calls. */
+  isPaused;
+  /** Returns a pending instruction from parent, if any. Consumed once. */
+  getPendingInstruction;
+  /** Context orchestrator — when set, messages are built from DB instead of in-memory session. */
+  contextOrchestrator;
+  policy;
+  emergencyOverride = null;
+  /** Activate emergency (hailMary) mode — next prompts bypass the fallback policy. */
+  setEmergencyMode(override) {
+    if (!override && !this.emergencyOverride) return;
+    this.emergencyOverride = override;
+    if (override) logWarn(TAG3, `\u{1F6A8} EMERGENCY MODE: using ${override.model} (paid) \u2014 bypassing fallback chain`);
+    else {
+      this.activeModel = this.config.model;
+      logInfo(TAG3, `Emergency mode cleared \u2014 restored ${this.config.model}`);
+    }
+  }
+  /** True if emergency (hailMary) mode is active. */
+  get isEmergencyMode() {
+    return this.emergencyOverride !== null;
+  }
+  constructor(config, policy) {
+    this.config = config;
+    this.activeEndpoint = config.endpoint;
+    this.activeApiKey = config.apiKey;
+    this.activeModel = config.model;
+    this.policy = policy ?? null;
+  }
+  async initialize() {
+    const count = this.policy ? this.policy.candidates.length : (this.config.fallbacks?.length ?? 0) + 1;
+    const fb = count > 1 ? ` (+${count - 1} fallback${count > 2 ? "s" : ""})` : "";
+    logInfo(TAG3, `\u{1F50C} Direct API transport (${this.config.endpoint}, model: ${this.config.model}${fb})`);
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  async sendPrompt(sessionKey, message, image, userId) {
+    const session = this.getOrCreateSession(sessionKey);
+    this._activeSessionKey = sessionKey;
+    this._activeUserId = userId || "master";
+    if (this.contextOrchestrator) {
+      try {
+        const ctx = await this.contextOrchestrator.getContext(sessionKey, this.config.maxContext);
+        session.messages = [
+          { role: "system", content: this.systemPrompt },
+          ...ctx.messages.map((m) => ({ role: m.role, content: m.content }))
+        ];
+        if (ctx.compacted) logDebug(TAG3, `Context compacted for ${sessionKey}`);
+      } catch (err) {
+        logWarn(TAG3, `Context engine failed, falling back to in-memory: ${err}`);
+      }
+    }
+    session.addUser(message, image);
+    this._lastAnswer = "";
+    this._toolCallsSucceeded = 0;
+    this._intermediateText = "";
+    this._promptStartedAt = Date.now();
+    this._lastActivityAt = Date.now();
+    const ac = new AbortController();
+    this.abortControllers.set(sessionKey, ac);
+    try {
+      if (this.emergencyOverride) return await this.sendEmergency(session, ac.signal);
+      if (!this.policy) throw new Error("DirectApiTransport requires a FallbackPolicy");
+      return await this.sendWithPolicy(session, ac.signal);
+    } finally {
+      const durationMs = Date.now() - (this._promptStartedAt ?? Date.now());
+      import("./hook-system-POI5VRIX.js").then(({ hasHooks, fire }) => {
+        if (!hasHooks("AfterPrompt")) return;
+        fire("AfterPrompt", {
+          event: "AfterPrompt",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          sessionKey,
+          platform: "",
+          userId: "",
+          model: this.activeModel,
+          durationMs,
+          inputTokens: this._lastPromptTokens || null,
+          outputTokens: null
+          // not tracked per-prompt in DirectApi
+        }).catch((err) => logAndSwallow(TAG3, "fire AfterPrompt", err));
+      }).catch((err) => logAndSwallow(TAG3, "import hook-system", err));
+      this._promptStartedAt = null;
+      this.abortControllers.delete(sessionKey);
+    }
+  }
+  async sendEmergency(session, signal) {
+    const em = this.emergencyOverride;
+    this.activeEndpoint = em.endpoint;
+    this.activeApiKey = em.apiKey;
+    this.activeModel = em.model;
+    this._lastActivityAt = Date.now();
+    logWarn(TAG3, `\u{1F6A8} Emergency mode: using ${em.model}`);
+    const result = await this.agentLoop(session, signal);
+    this._lastAnswer = result;
+    return result;
+  }
+  async sendWithPolicy(session, signal) {
+    const policy = this.policy;
+    const failedAttempts = [];
+    const isPrimary = (m) => m === this.config.model;
+    let candidate = policy.selectModel(this._lastPromptTokens);
+    while (candidate) {
+      this.activeEndpoint = candidate.endpoint;
+      this.activeApiKey = candidate.apiKey;
+      this.activeModel = candidate.model;
+      this._lastActivityAt = Date.now();
+      logDebug(TAG3, `Trying model: ${candidate.model}`);
+      if (!isPrimary(candidate.model) && this.onFallback) {
+        const ctxPct = candidate.maxContext > 0 ? Math.round(this._lastPromptTokens / candidate.maxContext * 100) : -1;
+        const lastFail = failedAttempts[failedAttempts.length - 1];
+        this.onFallback(candidate.model, ctxPct, lastFail?.kind);
+      }
+      try {
+        const result = await this.agentLoop(session, signal);
+        this._lastAnswer = result;
+        if (!result || !result.trim()) {
+          policy.recordError(candidate, "empty");
+        } else {
+          policy.recordSuccess(candidate);
+        }
+        return result;
+      } catch (err) {
+        if (signal.aborted) {
+          session.rollbackToLastUser();
+          throw err;
+        }
+        const errMsg = err instanceof Error ? err.message : String(err);
+        if (errMsg.includes("does not support image input") || errMsg.includes("No endpoints found that support image")) {
+          session.rollbackToLastUser();
+          for (const m of session.messages) {
+            if (Array.isArray(m.content)) {
+              const textParts = m.content.filter((p) => p.type === "text");
+              m.content = textParts.map((p) => p.text ?? "").join("\n") || "User sent an image (not supported by this model).";
+            }
+          }
+          logWarn(TAG3, `${candidate.model} doesn't support images \u2014 retrying text-only`);
+          if (this.onIntermediateResponse) this.onIntermediateResponse("\u26A0\uFE0F Model doesn't support images via this provider. Sending text-only.\n");
+          try {
+            const result = await this.agentLoop(session, signal);
+            this._lastAnswer = result;
+            policy.recordSuccess(candidate);
+            return result;
+          } catch (retryErr) {
+            const retryStatus = this.parseErrorStatus(retryErr);
+            const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+            policy.recordError(candidate, classifyError(retryStatus, retryMsg));
+            session.rollbackToLastUser();
+            throw retryErr;
+          }
+        }
+        const status = this.parseErrorStatus(err);
+        const kind = classifyError(status, errMsg);
+        const retryAfterMs = this.parseRetryAfter(err) ?? parseUsageLimitCooldown(errMsg);
+        policy.recordError(candidate, kind, retryAfterMs);
+        const bucket = policy.registry.getBucketLevel(candidate.model, candidate.endpoint);
+        failedAttempts.push({ model: candidate.model, kind, bucket });
+        session.rollbackToLastUser();
+        logWarn(TAG3, `${candidate.model} failed (${kind}, bucket: ${bucket}%${retryAfterMs ? `, retry-after: ${Math.round(retryAfterMs / 1e3)}s` : ""}): ${errMsg.slice(0, 100)}`);
+      }
+      candidate = policy.selectModel(this._lastPromptTokens);
+    }
+    const surviving = policy.survivingCandidates().filter((c) => c.maxContext > 0).sort((a, b) => a.maxContext - b.maxContext);
+    const smallest = surviving[0];
+    if (smallest && this._lastPromptTokens > smallest.maxContext * 0.95) {
+      logWarn(TAG3, `Compacting session to fit ${smallest.model} (${smallest.maxContext} tokens)`);
+      session.truncateToFit(smallest.maxContext);
+      this.activeEndpoint = smallest.endpoint;
+      this.activeApiKey = smallest.apiKey;
+      this.activeModel = smallest.model;
+      if (this.onFallback) {
+        this.onFallback(`${smallest.model} (compacted)`, Math.round(session.estimateTokens() / smallest.maxContext * 100));
+      }
+      try {
+        const result = await this.agentLoop(session, signal);
+        this._lastAnswer = result;
+        if (!result || !result.trim()) policy.recordError(smallest, "empty");
+        else policy.recordSuccess(smallest);
+        return result;
+      } catch (err) {
+        const status = this.parseErrorStatus(err);
+        const errMsg2 = err instanceof Error ? err.message : String(err);
+        policy.recordError(smallest, classifyError(status, errMsg2));
+        failedAttempts.push({ model: smallest.model, kind: classifyError(status, errMsg2), bucket: policy.registry.getBucketLevel(smallest.model, smallest.endpoint) });
+      }
+    }
+    const summary = failedAttempts.map((a) => `  - ${a.model}: ${a.kind} (bucket: ${a.bucket}%)`).join("\n");
+    if (policy.lastDecision) {
+      logDebug(TAG3, `Last decision: ${JSON.stringify(policy.lastDecision)}`);
+    }
+    throw new Error(`All models exhausted:
+${summary}`);
+  }
+  async agentLoop(session, signal) {
+    let zeroTokenRetries = 0;
+    const loopStart = Date.now();
+    for (let turn = 0; turn < this.config.maxTurns; turn++) {
+      if (signal.aborted) throw new Error("Aborted");
+      if (this.isPaused?.()) return "\u23F8 Session paused. Use `/session resume` to continue.";
+      const pendingInstruction = this.getPendingInstruction?.();
+      if (pendingInstruction) session.addUser(pendingInstruction);
+      const { content, toolCalls, usage } = await this.streamCompletion(session, signal);
+      if (usage) {
+        session.updateTokens(usage.prompt_tokens);
+        this._contextPercent = session.contextPercent;
+        this._lastPromptTokens = usage.prompt_tokens;
+        this.contextOrchestrator?.onApiResponse(this._activeSessionKey, usage.prompt_tokens, this.config.maxContext);
+        logTrace(TAG3, `${this.activeModel} \u2014 ${usage.prompt_tokens}\u2192${usage.completion_tokens ?? 0} tokens, ${Date.now() - (this._lastActivityAt ?? Date.now())}ms`);
+        recordUsage(this.activeModel, usage.prompt_tokens, usage.completion_tokens ?? 0);
+      }
+      if (toolCalls.length > 0) {
+        session.addAssistant(content, toolCalls);
+        logDebug(TAG3, `Tool calls: ${toolCalls.map((tc) => tc.function.name).join(", ")}`);
+        logTrace(TAG3, `Tool args: ${toolCalls.map((tc) => {
+          if ((tc.function.name === "abmind_store" || tc.function.name === "memory_store") && /class(?:ification)?[":\s]+[23]/.test(tc.function.arguments)) {
+            return `${tc.function.name}([REDACTED])`;
+          }
+          return `${tc.function.name}(${tc.function.arguments})`;
+        }).join(", ")}`);
+        if (content?.trim()) {
+          this.onSegmentBreak?.(content.trim());
+        }
+        for (const tc of toolCalls) {
+          if (signal.aborted) throw new Error("Aborted");
+          this._lastActivityAt = Date.now();
+          this.onToolCallStart?.(tc.function.name ?? "tool");
+          let args;
+          try {
+            args = JSON.parse(tc.function.arguments);
+          } catch (err) {
+            logAndSwallow(TAG3, "JSON.parse tool args", err);
+            args = {};
+          }
+          const result = await executeToolCall(tc.function.name, args, { userId: this._activeUserId, signal, sandboxPolicy: this.sandboxPolicy });
+          session.addToolResult(tc.id, tc.function.name, result);
+          if ((tc.function.name === "abmind_store" || tc.function.name === "memory_store") && parseInt(args.classification ?? args.class ?? "1", 10) >= 2) {
+            const secretValue = args.content ?? args.value ?? args.translated;
+            if (secretValue && secretValue.length > 4) {
+              session.scrubFromHistory(secretValue);
+            }
+          }
+          try {
+            if (!JSON.parse(result).error) this._toolCallsSucceeded++;
+          } catch (err) {
+            logAndSwallow(TAG3, "JSON.parse tool result", err);
+            this._toolCallsSucceeded++;
+          }
+        }
+        continue;
+      }
+      const answer = content ?? "";
+      if (!answer && usage && usage.prompt_tokens === 0) {
+        const elapsed = Date.now() - loopStart;
+        const remaining = (this._timeoutOverrideMs ?? 6e4) - elapsed;
+        const retryDelay = 5e3 + zeroTokenRetries * 3e3;
+        if (remaining > retryDelay + 5e3) {
+          zeroTokenRetries++;
+          logWarn(TAG3, `API returned 0 tokens \u2014 retry #${zeroTokenRetries} after ${retryDelay / 1e3}s (${Math.round(remaining / 1e3)}s left)`);
+          await new Promise((r) => setTimeout(r, retryDelay));
+          continue;
+        }
+      }
+      session.addAssistant(answer);
+      return answer;
+    }
+    logWarn(TAG3, `Max turns (${this.config.maxTurns}) reached`);
+    const last = session.messages.at(-1)?.content;
+    return (typeof last === "string" ? last : null) ?? "(max turns reached)";
+  }
+  parseErrorStatus(err) {
+    return parseErrorStatus(err);
+  }
+  /** Extract Retry-After from error (seconds or date). Returns ms or undefined. */
+  parseRetryAfter(err) {
+    return parseRetryAfter(err);
+  }
+  async streamCompletion(session, signal) {
+    const timeoutCtrl = new AbortController();
+    const timer = setTimeout(() => timeoutCtrl.abort(new Error("model API timeout")), this._timeoutOverrideMs ?? getEnv().modelApiTimeoutMs);
+    const composed = AbortSignal.any([signal, timeoutCtrl.signal]);
+    try {
+      if (this.config.apiFormat === "responses") {
+        const { toResponsesRequest } = await import("./responses-adapter-DAV2JUL7.js");
+        const { parseResponsesSSE } = await import("./sse-parser-responses-WG2LY2ML.js");
+        const msgs = session.messages.map((m) => ({ role: m.role, content: m.content ?? "" }));
+        const reqBody = { ...toResponsesRequest(this.activeModel, msgs, getToolSchemas(this.sandboxPolicy), this.config.maxOutput), stream: true };
+        const hdrs = { "Content-Type": "application/json" };
+        if (this.activeApiKey) hdrs["Authorization"] = `Bearer ${this.activeApiKey}`;
+        const res = await fetch(`${this.activeEndpoint}/responses`, {
+          method: "POST",
+          headers: hdrs,
+          body: JSON.stringify(reqBody),
+          signal: composed
+        });
+        if (!res.ok) {
+          const text = await res.text().catch((err) => {
+            logAndSwallow(TAG3, "read error body", err);
+            return "";
+          });
+          throw new Error(`API error ${res.status}: ${text.slice(0, 500)}`);
+        }
+        let content2 = "";
+        let usage2 = null;
+        const toolCallAcc = /* @__PURE__ */ new Map();
+        for await (const event of parseResponsesSSE(res, composed)) {
+          this._lastActivityAt = Date.now();
+          if (event.type === "chunk") {
+            content2 += event.content;
+            this._intermediateText += event.content;
+            this.onIntermediateResponse?.(event.content);
+          } else if (event.type === "tool_call_delta") {
+            this.accumulateToolCall(toolCallAcc, event);
+          } else if (event.type === "done") {
+            usage2 = event.usage;
+          }
+        }
+        clearTimeout(timer);
+        const toolCalls2 = this.finalizeToolCalls(toolCallAcc);
+        return { content: content2 || null, toolCalls: toolCalls2, usage: usage2 };
+      }
+      if (this.config.apiFormat === "anthropic") {
+        const { toAnthropicRequest, buildAnthropicHeaders } = await import("./anthropic-adapter-IBY3NPXW.js");
+        const { parseAnthropicSSE } = await import("./sse-parser-anthropic-H42TTLBD.js");
+        const msgs = session.messages.map((m) => ({ role: m.role, content: m.content ?? "", tool_call_id: m.tool_call_id }));
+        const reqBody = { ...toAnthropicRequest(this.activeModel, msgs, this.config.maxOutput, getToolSchemas(this.sandboxPolicy)), stream: true };
+        const hdrs = buildAnthropicHeaders(this.activeApiKey ?? "");
+        const res = await fetch(`${this.activeEndpoint}/messages`, {
+          method: "POST",
+          headers: hdrs,
+          body: JSON.stringify(reqBody),
+          signal: composed
+        });
+        if (!res.ok) {
+          const text = await res.text().catch((err) => {
+            logAndSwallow(TAG3, "read error body", err);
+            return "";
+          });
+          throw new Error(`API error ${res.status}: ${text.slice(0, 500)}`);
+        }
+        let content2 = "";
+        let usage2 = null;
+        const toolCallAcc = /* @__PURE__ */ new Map();
+        for await (const event of parseAnthropicSSE(res, composed)) {
+          this._lastActivityAt = Date.now();
+          if (event.type === "chunk") {
+            content2 += event.content;
+            this._intermediateText += event.content;
+            this.onIntermediateResponse?.(event.content);
+          } else if (event.type === "tool_call_delta") {
+            this.accumulateToolCall(toolCallAcc, event);
+          } else if (event.type === "done") {
+            usage2 = event.usage;
+          }
+        }
+        clearTimeout(timer);
+        const toolCalls2 = this.finalizeToolCalls(toolCallAcc);
+        return { content: content2 || null, toolCalls: toolCalls2, usage: usage2 };
+      }
+      const body = {
+        model: this.activeModel,
+        messages: session.messages,
+        tools: getToolSchemas(this.sandboxPolicy),
+        max_tokens: this.config.maxOutput,
+        stream: true,
+        stream_options: { include_usage: true }
+      };
+      if (this.config.thinking) {
+        if (this.config.thinking.style === "effort") {
+          body.reasoning_effort = this.config.thinking.default;
+        } else if (this.config.thinking.style === "extended") {
+          body.thinking = { type: "enabled", budget_tokens: this.config.thinking.default };
+        }
+      }
+      const headers = { "Content-Type": "application/json" };
+      if (this.activeApiKey) headers["Authorization"] = `Bearer ${this.activeApiKey}`;
+      const response = await withRetry(
+        async () => {
+          const res = await fetch(`${this.activeEndpoint}/chat/completions`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: composed
+          });
+          if (!res.ok) {
+            const text = await res.text().catch((err) => {
+              logAndSwallow(TAG3, "read error body", err);
+              return "";
+            });
+            throw new Error(`API error ${res.status}: ${text.slice(0, 500)}`);
+          }
+          return res;
+        },
+        {
+          attempts: 3,
+          minDelayMs: 3e3,
+          isRecoverable: (err) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (/model API timeout/.test(msg)) return false;
+            if (/API error (429|401|402|403)/.test(msg)) return false;
+            return !isFatal(err);
+          }
+        }
+      );
+      let content = "";
+      const toolCallAccumulator = /* @__PURE__ */ new Map();
+      let usage = null;
+      for await (const event of parseSSEStream(response, composed)) {
+        this._lastActivityAt = Date.now();
+        switch (event.type) {
+          case "chunk":
+            content += event.content;
+            this._intermediateText += event.content;
+            this.onIntermediateResponse?.(event.content);
+            break;
+          case "tool_call_delta":
+            this.accumulateToolCall(toolCallAccumulator, event);
+            break;
+          case "done":
+            usage = event.usage;
+            break;
+        }
+      }
+      const toolCalls = this.finalizeToolCalls(toolCallAccumulator);
+      return { content: content || null, toolCalls, usage };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /** Accumulate streaming tool call deltas by ID (Ollama-safe: tracks by ID not index). */
+  accumulateToolCall(acc, delta) {
+    const key = delta.id ?? `idx:${delta.index}`;
+    const existing = acc.get(key);
+    if (existing) {
+      if (delta.arguments) existing.arguments += delta.arguments;
+    } else {
+      acc.set(key, { id: delta.id ?? `call_${acc.size}`, name: delta.name ?? "", arguments: delta.arguments ?? "" });
+    }
+  }
+  /**
+   * Convert accumulated tool call map → normalized ToolCall array.
+   * Handles model fragmentation: some models (nemotron, mistral-free) split a
+   * single tool call across multiple SSE entries with different indices/IDs.
+   * Pattern: [name="execute_bash" args="{}"], [name="" args=""], [name="" args='{"command":"..."}']
+   * Fix: merge adjacent unnamed entries' args into the preceding named entry.
+   */
+  finalizeToolCalls(acc) {
+    const raw = [...acc.values()].map((tc) => ({
+      id: tc.id,
+      type: "function",
+      function: { name: tc.name, arguments: tc.arguments }
+    }));
+    return normalizeToolCalls(raw);
+  }
+  getOrCreateSession(sessionKey) {
+    let session = this.sessions.get(sessionKey);
+    if (!session) {
+      session = new ConversationSession(this.systemPrompt, this.config.maxContext);
+      this.sessions.set(sessionKey, session);
+    }
+    return session;
+  }
+  async resetSession(sessionKey) {
+    const session = this.sessions.get(sessionKey);
+    if (session) session.reset(this.systemPrompt);
+    else this.sessions.delete(sessionKey);
+    logInfo(TAG3, `Session ${sessionKey} reset`);
+  }
+  async sendInterrupt() {
+    for (const ac of this.abortControllers.values()) ac.abort();
+  }
+  destroy() {
+    for (const ac of this.abortControllers.values()) ac.abort();
+    this.sessions.clear();
+    this.abortControllers.clear();
+  }
+  get isReady() {
+    return true;
+  }
+  get contextPercent() {
+    return this._contextPercent;
+  }
+  get answerOnly() {
+    return this._lastAnswer;
+  }
+  get toolCallsSucceeded() {
+    return this._toolCallsSucceeded;
+  }
+  /** Hot-swap the active model. Takes effect on next API call. */
+  setModel(model) {
+    this.activeModel = model;
+    this.config.model = model;
+    logInfo(TAG3, `Model switched (user): ${model}`);
+  }
+  /** Hot-swap provider+model+policy. Rejects if prompt is in flight. */
+  switchProvider(opts) {
+    if (this._promptStartedAt !== null) {
+      throw new Error("Cannot switch provider while a prompt is in progress \u2014 try after the response");
+    }
+    this.activeEndpoint = opts.endpoint;
+    this.activeApiKey = opts.apiKey;
+    this.activeModel = opts.model;
+    this.config.model = opts.model;
+    this.config.maxContext = opts.maxContext;
+    this.policy = opts.policy;
+    logInfo(TAG3, `Provider switched: ${opts.model} @ ${opts.endpoint} (maxCtx=${opts.maxContext})`);
+  }
+  /** Get current active model name. */
+  getModel() {
+    return this.activeModel;
+  }
+  get intermediateDeliveredText() {
+    return this._intermediateText;
+  }
+  get transportCommands() {
+    return [];
+  }
+  // Watchdog support
+  get promptStartedAt() {
+    return this._promptStartedAt;
+  }
+  setTimeoutOverride(ms) {
+    this._timeoutOverrideMs = ms;
+  }
+  get lastActivityAt() {
+    return this._lastActivityAt;
+  }
+  _stuckTimeout = getEnv().watchdogSilentSec * 1e3;
+  async healthCheck() {
+    if (!this._promptStartedAt) return;
+    const idle = Date.now() - (this._lastActivityAt ?? this._promptStartedAt);
+    if (idle > this._stuckTimeout) {
+      logWarn(TAG3, `[transport-health] Prompt stuck (${Math.round(idle / 1e3)}s idle) \u2014 aborting`);
+      await this.sendInterrupt();
+    }
+  }
+};
+export {
+  DirectApiTransport,
+  normalizeToolCalls
+};
+//# sourceMappingURL=direct-api-transport-SLJ2Z6NX.js.map