@gigaai/newton 0.4.0 → 0.4.1

package/README.md

@@ -61,7 +61,7 @@ script body. The body runs as an async function with these in scope:
 
 | Primitive | What it does |
 |---|---|
-| `agent(prompt, opts?)` | Run one agent turn; returns its final text, or a schema-validated object when `opts.schema` is set. Returns `null` on agent failure — filter with `.filter(Boolean)`. |
+| `agent(prompt, opts?)` | Run one agent turn; returns its final text, or a schema-validated object when `opts.schema` is set. Transient failures (provider 5xx/overload, rate limits, dropped connections) retry up to twice with backoff; returns `null` on lasting failure — filter with `.filter(Boolean)`. |
 | `parallel(thunks)` | Run `() => …` tasks concurrently; a failed task resolves to `null`. Barrier: waits for all. |
 | `pipeline(items, ...stages)` | Each item flows through the stages independently — no barrier between stages. Stage signature: `(prev, item, index)`. |
 | `phase(title)` | Group subsequent agents in progress output. |

package/dist/executor.js

@@ -9,6 +9,32 @@ import { checkCompile, createRealm } from "./sandbox.js";
 import { balancedSlice, extractJson, INVALID, structuredOutputInstruction, structuredOutputRetryPrompt, validateAgainstSchema, } from "./schema.js";
 import { createWorktree, finishWorktree } from "./worktree.js";
 const SCRIPT_PARAMS = ["agent", "parallel", "pipeline", "phase", "log", "args", "budget", "workflow"];
+const AGENT_MAX_ATTEMPTS = 3;
+const AGENT_RETRY_BASE_MS = 2_000;
+/**
+ * Failures worth a fresh attempt: provider 5xx/overload/rate-limit responses
+ * and dropped connections. Deterministic failures (auth, missing binaries,
+ * bad model ids, structured-output exhaustion) return null without retrying.
+ */
+const TRANSIENT_AGENT_ERROR = new RegExp([
+    "\\b(?:429|500|502|503|504|529)\\b",
+    "overloaded",
+    "rate.?limit",
+    "too many requests",
+    "internal server error",
+    "service unavailable",
+    "bad gateway",
+    "gateway timeout",
+    "econn(?:reset|refused|aborted)",
+    "etimedout",
+    "epipe",
+    "eai_again",
+    "socket hang.?up",
+    "connection (?:reset|refused|closed|error)",
+    "fetch failed",
+    "network error",
+    "stream (?:closed|disconnected)",
+].join("|"), "i");
 function errorMessage(error) {
     return typeof error === "object" &&
         error !== null &&
@@ -257,45 +283,64 @@ export async function runWorkflow(options) {
                 : callOptions.cwd
                     ? resolve(workspace, callOptions.cwd)
                     : workspace;
-            session = new AcpAgentSession({
-                spec,
-                prompt: fullPrompt,
-                cwd,
-                timeoutMs: callOptions.timeoutMs ?? agentTimeoutMs,
-                mcpServers,
-                config,
-                trace,
-            });
-            liveSessions.set(id, session);
-            let turn = await session.prompt();
-            let result = turn.text;
-            let failure = turn.error;
-            if (!failure && callOptions.schema) {
-                for (let attempt = 0;; attempt++) {
-                    const parsed = extractJson(turn.text);
-                    const errors = parsed === INVALID
-                        ? ["response contained no parseable JSON"]
-                        : validateAgainstSchema(parsed, callOptions.schema);
-                    if (errors.length === 0) {
-                        result = parsed;
-                        break;
-                    }
-                    if (attempt >= 2) {
-                        failure = `structured output failed after ${attempt + 1} attempts: ${errors.join("; ")}`;
-                        break;
-                    }
-                    turn = await session.promptAgain(structuredOutputRetryPrompt(errors, callOptions.schema));
-                    if (turn.error) {
-                        failure = turn.error;
-                        break;
+            let turn;
+            let result;
+            let failure;
+            for (let attempt = 1;; attempt++) {
+                session = new AcpAgentSession({
+                    spec,
+                    prompt: fullPrompt,
+                    cwd,
+                    timeoutMs: callOptions.timeoutMs ?? agentTimeoutMs,
+                    mcpServers,
+                    config,
+                    trace,
+                });
+                liveSessions.set(id, session);
+                turn = await session.prompt();
+                result = turn.text;
+                failure = turn.error;
+                if (!failure && callOptions.schema) {
+                    for (let retry = 0;; retry++) {
+                        const parsed = extractJson(turn.text);
+                        const errors = parsed === INVALID
+                            ? ["response contained no parseable JSON"]
+                            : validateAgainstSchema(parsed, callOptions.schema);
+                        if (errors.length === 0) {
+                            result = parsed;
+                            break;
+                        }
+                        if (retry >= 2) {
+                            failure = `structured output failed after ${retry + 1} attempts: ${errors.join("; ")}`;
+                            break;
+                        }
+                        turn = await session.promptAgain(structuredOutputRetryPrompt(errors, callOptions.schema));
+                        if (turn.error) {
+                            failure = turn.error;
+                            break;
+                        }
                     }
                 }
+                liveSessions.delete(id);
+                session.close();
+                outputTokens += turn.usage?.outputTokens ?? 0;
+                if (!failure ||
+                    attempt >= AGENT_MAX_ATTEMPTS ||
+                    turn.stopReason === "timeout" ||
+                    turn.stopReason === "cancelled" ||
+                    !TRANSIENT_AGENT_ERROR.test(failure)) {
+                    break;
+                }
+                const delayMs = AGENT_RETRY_BASE_MS * 4 ** (attempt - 1);
+                journal.append({ type: "agent_retry", id, key, label, phase, attempt, error: failure, delayMs });
+                reporter.log(`↻ agent #${id} transient error, retry ${attempt}/${AGENT_MAX_ATTEMPTS - 1} in ${delayMs / 1000}s: ${failure.split("\n")[0]}`);
+                await new Promise((resolveDelay) => setTimeout(resolveDelay, delayMs));
+                if (skipped.has(id))
+                    break;
             }
-            session.close();
             const worktree = await finishCreatedWorktree();
             const seconds = Math.round((Date.now() - agentStartedAt) / 1000);
             const turnTokens = turn.usage?.outputTokens ?? 0;
-            outputTokens += turnTokens;
             if (failure) {
                 journal.append({
                     type: "agent_end",

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.4.0";
+export const VERSION = "0.4.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gigaai/newton",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Deterministic multi-agent workflow executor. Write workflows in plain JavaScript; Newton drives coding agents over the Agent Client Protocol.",
   "license": "Apache-2.0",
   "repository": {