@atlasharness/atlascode 0.1.57 → 0.1.58

package/dist/cli.js

@@ -26920,6 +26920,63 @@ function gatewayUnreachableRemediationHint(error) {
     return null;
   return "IFF 不可达：已切人工确认 —— /doctor 排查";
 }
+function modelRetryBackoffMs(attempt, baseMs = MODEL_RETRY_BACKOFF_BASE_MS, capMs = MODEL_RETRY_BACKOFF_CAP_MS) {
+  const base = Math.max(0, baseMs);
+  const cap = Math.max(base, capMs);
+  if (attempt <= 0)
+    return Math.min(base, cap);
+  return Math.min(base * 2 ** attempt, cap);
+}
+function sleepSignalAware(ms, signal) {
+  if (ms <= 0)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    let settled = false;
+    const timer = setTimeout(() => {
+      settled = true;
+      if (signal)
+        signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve();
+    }
+    if (signal)
+      signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function buildStreamErrorEvent(err, signal) {
+  const message = err instanceof Error ? err.message || err.name : String(err);
+  const code = isClientRequestTimeout(err) ? "TIMEOUT" : "API_ERROR";
+  return { type: "error", code, message, retryable: shouldRetryModelError(err, signal) };
+}
+function buildStreamContentBlocks(reasoningText, fullText, toolCalls) {
+  const blocks = [];
+  if (reasoningText)
+    blocks.push({ type: "thinking", thinking: reasoningText, signature: "first-party" });
+  if (fullText)
+    blocks.push({ type: "text", text: fullText });
+  blocks.push(...[...toolCalls.values()].filter((t) => t.name).map((t) => {
+    let input = {};
+    if (t.args) {
+      try {
+        input = JSON.parse(t.args);
+      } catch {
+        input = { _raw_arguments: t.args };
+      }
+    }
+    return { type: "tool_use", id: t.id || `toolu_${randomUUID()}`, name: t.name, input };
+  }));
+  return blocks;
+}
 function startLlmWaitHeartbeat(modelId, attempt, totalRetries) {
   const startedAt = Date.now();
   const id = setInterval(() => {
@@ -26934,10 +26991,16 @@ class OpenAIProvider {
   maxRetriesPerModel;
   timeoutMs;
   timeoutResolver;
-  constructor(maxRetriesPerModel = 3, timeoutMs = LLM_TIMEOUT_DEFAULT_MS, timeoutResolver) {
+  retryBackoffBaseMs;
+  retryBackoffCapMs;
+  retryBackoffSleep;
+  constructor(maxRetriesPerModel = 3, timeoutMs = LLM_TIMEOUT_DEFAULT_MS, timeoutResolver, retryBackoff) {
     this.maxRetriesPerModel = maxRetriesPerModel;
     this.timeoutMs = timeoutMs;
     this.timeoutResolver = timeoutResolver;
+    this.retryBackoffBaseMs = retryBackoff?.baseMs ?? MODEL_RETRY_BACKOFF_BASE_MS;
+    this.retryBackoffCapMs = retryBackoff?.capMs ?? MODEL_RETRY_BACKOFF_CAP_MS;
+    this.retryBackoffSleep = retryBackoff?.sleep ?? ((ms, signal) => sleepSignalAware(ms, signal));
   }
   getTimeoutMs() {
     return this.timeoutResolver ? this.timeoutResolver() : this.timeoutMs;
@@ -27030,6 +27093,9 @@ class OpenAIProvider {
           lastErr = err;
           if (!shouldRetryModelError(err, args.signal))
             break;
+          if (attempt < this.maxRetriesPerModel - 1) {
+            await this.retryBackoffSleep(modelRetryBackoffMs(attempt, this.retryBackoffBaseMs, this.retryBackoffCapMs), args.signal);
+          }
         }
       }
     }
@@ -27045,6 +27111,7 @@ class OpenAIProvider {
     const attemptRefs = refs;
     let lastErr = null;
     let succeeded = false;
+    let partialRetained = false;
     for (const ref of attemptRefs) {
       const entry = resolveModel(ref);
       if (!entry) {
@@ -27073,22 +27140,27 @@ class OpenAIProvider {
         if (args.signal?.aborted)
           return;
         try {
-          yield* this.streamOneAttempt(client, params, entry, args.signal, attempt, this.maxRetriesPerModel);
+          const outcome = yield* this.streamOneAttempt(client, params, entry, args.signal, attempt, this.maxRetriesPerModel);
+          if (outcome.partialRetained) {
+            partialRetained = true;
+            break;
+          }
           succeeded = true;
           break;
         } catch (err) {
           lastErr = err;
           if (!shouldRetryModelError(err, args.signal))
             break;
+          if (attempt < this.maxRetriesPerModel - 1) {
+            await this.retryBackoffSleep(modelRetryBackoffMs(attempt, this.retryBackoffBaseMs, this.retryBackoffCapMs), args.signal);
+          }
         }
       }
-      if (succeeded || args.signal?.aborted)
+      if (succeeded || partialRetained || args.signal?.aborted)
         return;
     }
     if (lastErr) {
-      const message = lastErr instanceof Error ? lastErr.message || lastErr.name : String(lastErr);
-      const code = isClientRequestTimeout(lastErr) ? "TIMEOUT" : "API_ERROR";
-      yield { type: "error", code, message, retryable: shouldRetryModelError(lastErr, args.signal) };
+      yield buildStreamErrorEvent(lastErr, args.signal);
       return;
     }
     throw new Error(`No models configured for role '${args.role}'.`);
@@ -27107,66 +27179,111 @@ class OpenAIProvider {
     const toolCalls = new Map;
     let finishReason = null;
     let usage = null;
-    for await (const chunk of stream) {
-      const choice = chunk.choices?.[0];
-      const delta = choice?.delta;
-      if (delta?.content) {
-        fullText += delta.content;
-        yield { type: "text_delta", text: delta.content };
-      }
-      if (delta?.reasoning_content)
-        reasoningText += delta.reasoning_content;
-      if (delta?.tool_calls) {
-        for (const tc of delta.tool_calls) {
-          const idx = tc.index ?? 0;
-          const cur = toolCalls.get(idx) ?? { id: "", name: "", args: "" };
-          if (tc.id)
-            cur.id = tc.id;
-          if (tc.function?.name) {
-            cur.name = tc.function.name;
-            if (currentToolCall) {
-              let input = {};
-              if (currentToolCall.args) {
-                try {
-                  input = JSON.parse(currentToolCall.args);
-                } catch {
-                  input = { _raw_arguments: currentToolCall.args };
+    let streamError = null;
+    try {
+      for await (const chunk of stream) {
+        const choice = chunk.choices?.[0];
+        const delta = choice?.delta;
+        if (delta?.content) {
+          fullText += delta.content;
+          yield { type: "text_delta", text: delta.content };
+        }
+        if (delta?.reasoning_content)
+          reasoningText += delta.reasoning_content;
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index ?? 0;
+            const cur = toolCalls.get(idx) ?? { id: "", name: "", args: "" };
+            if (tc.id)
+              cur.id = tc.id;
+            if (tc.function?.name) {
+              cur.name = tc.function.name;
+              if (currentToolCall) {
+                let input = {};
+                if (currentToolCall.args) {
+                  try {
+                    input = JSON.parse(currentToolCall.args);
+                  } catch {
+                    input = { _raw_arguments: currentToolCall.args };
+                  }
                 }
+                yield { type: "tool_use_end", id: currentToolCall.id, name: currentToolCall.name, input };
               }
-              yield { type: "tool_use_end", id: currentToolCall.id, name: currentToolCall.name, input };
+              currentToolCall = { id: cur.id, name: cur.name, args: cur.args };
+              yield { type: "tool_use_start", id: cur.id, name: cur.name };
             }
-            currentToolCall = { id: cur.id, name: cur.name, args: cur.args };
-            yield { type: "tool_use_start", id: cur.id, name: cur.name };
-          }
-          if (tc.function?.arguments) {
-            cur.args += tc.function.arguments;
-            if (currentToolCall && cur.name) {
-              currentToolCall.args = cur.args;
-              yield { type: "tool_use_delta", id: cur.id, inputJsonDelta: tc.function.arguments };
+            if (tc.function?.arguments) {
+              cur.args += tc.function.arguments;
+              if (currentToolCall && cur.name) {
+                currentToolCall.args = cur.args;
+                yield { type: "tool_use_delta", id: cur.id, inputJsonDelta: tc.function.arguments };
+              }
             }
+            toolCalls.set(idx, cur);
           }
-          toolCalls.set(idx, cur);
         }
-      }
-      if (choice?.finish_reason) {
-        if (currentToolCall) {
-          let input = {};
-          if (currentToolCall.args) {
-            try {
-              input = JSON.parse(currentToolCall.args);
-            } catch {
-              input = { _raw_arguments: currentToolCall.args };
+        if (choice?.finish_reason) {
+          if (currentToolCall) {
+            let input = {};
+            if (currentToolCall.args) {
+              try {
+                input = JSON.parse(currentToolCall.args);
+              } catch {
+                input = { _raw_arguments: currentToolCall.args };
+              }
             }
+            yield { type: "tool_use_end", id: currentToolCall.id, name: currentToolCall.name, input };
+            currentToolCall = null;
           }
-          yield { type: "tool_use_end", id: currentToolCall.id, name: currentToolCall.name, input };
-          currentToolCall = null;
+          finishReason = choice.finish_reason;
         }
-        finishReason = choice.finish_reason;
+        if (chunk.usage)
+          usage = mapOpenAIUsage(chunk.usage);
+        if (signal?.aborted)
+          break;
       }
-      if (chunk.usage)
-        usage = mapOpenAIUsage(chunk.usage);
-      if (signal?.aborted)
-        break;
+    } catch (err) {
+      streamError = err;
+    }
+    if (streamError !== null) {
+      const partialBlocks = buildStreamContentBlocks(reasoningText, fullText, toolCalls);
+      if (partialBlocks.length === 0)
+        throw streamError;
+      yield {
+        type: "message_stop",
+        stopReason: "interrupted",
+        usage: usage ? {
+          input_tokens: usage.input_tokens ?? 0,
+          output_tokens: usage.output_tokens ?? 0,
+          cache_creation_input_tokens: usage.cache_creation_input_tokens ?? 0,
+          cache_read_input_tokens: usage.cache_read_input_tokens ?? 0
+        } : undefined
+      };
+      const emptyUsage = mapOpenAIUsage(null);
+      const partialMsg = {
+        uuid: randomUUID(),
+        timestamp: new Date().toISOString(),
+        message: {
+          id: randomUUID(),
+          container: null,
+          model: entry.modelId,
+          role: "assistant",
+          stop_reason: "interrupted",
+          stop_sequence: "",
+          type: "message",
+          usage: usage || emptyUsage,
+          content: partialBlocks
+        }
+      };
+      yield {
+        type: "assistant",
+        uuid: partialMsg.uuid,
+        timestamp: partialMsg.timestamp,
+        message: partialMsg.message,
+        interrupted: true
+      };
+      yield buildStreamErrorEvent(streamError, signal);
+      return { partialRetained: true };
     }
     yield {
       type: "message_stop",
@@ -27178,27 +27295,11 @@ class OpenAIProvider {
         cache_read_input_tokens: usage.cache_read_input_tokens ?? 0
       } : undefined
     };
-    const contentBlocks = [];
-    if (reasoningText)
-      contentBlocks.push({ type: "thinking", thinking: reasoningText, signature: "first-party" });
-    if (fullText)
-      contentBlocks.push({ type: "text", text: fullText });
-    const toolUseBlocks = [...toolCalls.values()].filter((t) => t.name).map((t) => {
-      let input = {};
-      if (t.args) {
-        try {
-          input = JSON.parse(t.args);
-        } catch {
-          input = { _raw_arguments: t.args };
-        }
-      }
-      return { type: "tool_use", id: t.id || `toolu_${randomUUID()}`, name: t.name, input };
-    });
-    contentBlocks.push(...toolUseBlocks);
+    const contentBlocks = buildStreamContentBlocks(reasoningText, fullText, toolCalls);
     if (contentBlocks.length === 0) {
       contentBlocks.push({ type: "text", text: PROVIDER_EMPTY_CONTENT_PLACEHOLDER });
     }
-    const stopReason = toolUseBlocks.length > 0 ? "tool_use" : finishReason === "length" ? "max_tokens" : "end_turn";
+    const stopReason = contentBlocks.some((b) => b.type === "tool_use") ? "tool_use" : finishReason === "length" ? "max_tokens" : "end_turn";
     const emptyUsage = mapOpenAIUsage(null);
     const finalMsg = {
       uuid: randomUUID(),
@@ -27216,6 +27317,7 @@ class OpenAIProvider {
       }
     };
     yield { type: "assistant", uuid: finalMsg.uuid, timestamp: finalMsg.timestamp, message: finalMsg.message };
+    return { partialRetained: false };
   }
   async healthCheck(role) {
     const refs = getRoleModels(role);
@@ -27332,7 +27434,7 @@ class OpenAIProvider {
     }
   }
 }
-var PROVIDER_EMPTY_CONTENT_PLACEHOLDER = "(provider: empty response)";
+var PROVIDER_EMPTY_CONTENT_PLACEHOLDER = "(provider: empty response)", MODEL_RETRY_BACKOFF_BASE_MS = 500, MODEL_RETRY_BACKOFF_CAP_MS = 8000;
 var init_modelprovider = __esm(() => {
   init_openai();
   init_clients();
@@ -27786,7 +27888,7 @@ function turnRecoveryBackoffMs(attempt, baseMs, capMs) {
     return Math.min(base, cap);
   return Math.min(base * 2 ** attempt, cap);
 }
-function sleepSignalAware(ms, signal) {
+function sleepSignalAware2(ms, signal) {
   if (ms <= 0)
     return Promise.resolve();
   return new Promise((resolve) => {
@@ -27829,7 +27931,7 @@ async function withTurnRecovery(attempt, options = {}) {
       if (i < cfg.maxRetries && shouldRetryModelError(err, options.signal)) {
         const backoff = turnRecoveryBackoffMs(i, cfg.backoffBaseMs, cfg.backoffCapMs);
         if (backoff > 0) {
-          await sleepSignalAware(backoff, options.signal);
+          await sleepSignalAware2(backoff, options.signal);
         }
         continue;
       }
@@ -430373,7 +430475,10 @@ async function streamCompactSummary({
           context.setResponseLength?.((length) => length + deltaEvent.text.length);
         }
         if (event.type === "assistant") {
-          response = event;
+          const assistantEvent = event;
+          if (!assistantEvent.interrupted) {
+            response = assistantEvent;
+          }
         }
       }
       if (response) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlasharness/atlascode",
-  "version": "0.1.57",
+  "version": "0.1.58",
   "description": "AtlasCode \u2014 Coding Agent for the domestic computing ecosystem (Ascend NPU + domestic LLM backends)",
   "bin": {
     "atlas": "dist/cli.js",