spacecode 2.2.0 → 2.2.2

package/dist/repl.mjs

@@ -1396,7 +1396,7 @@ var require_react_development = __commonJS({
           }
           return dispatcher.useContext(Context);
         }
-        function useState10(initialState) {
+        function useState9(initialState) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useState(initialState);
         }
@@ -1404,11 +1404,11 @@ var require_react_development = __commonJS({
           var dispatcher = resolveDispatcher();
           return dispatcher.useReducer(reducer, initialArg, init);
         }
-        function useRef5(initialValue) {
+        function useRef6(initialValue) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useRef(initialValue);
         }
-        function useEffect9(create2, deps) {
+        function useEffect8(create2, deps) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useEffect(create2, deps);
         }
@@ -1420,7 +1420,7 @@ var require_react_development = __commonJS({
           var dispatcher = resolveDispatcher();
           return dispatcher.useLayoutEffect(create2, deps);
         }
-        function useCallback4(callback, deps) {
+        function useCallback5(callback, deps) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useCallback(callback, deps);
         }
@@ -1450,7 +1450,7 @@ var require_react_development = __commonJS({
           var dispatcher = resolveDispatcher();
           return dispatcher.useId();
         }
-        function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+        function useSyncExternalStore2(subscribe, getSnapshot, getServerSnapshot) {
           var dispatcher = resolveDispatcher();
           return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
         }
@@ -2187,20 +2187,20 @@ var require_react_development = __commonJS({
         exports.memo = memo;
         exports.startTransition = startTransition;
         exports.unstable_act = act;
-        exports.useCallback = useCallback4;
+        exports.useCallback = useCallback5;
         exports.useContext = useContext7;
         exports.useDebugValue = useDebugValue;
         exports.useDeferredValue = useDeferredValue;
-        exports.useEffect = useEffect9;
+        exports.useEffect = useEffect8;
         exports.useId = useId;
         exports.useImperativeHandle = useImperativeHandle;
         exports.useInsertionEffect = useInsertionEffect;
         exports.useLayoutEffect = useLayoutEffect3;
         exports.useMemo = useMemo8;
         exports.useReducer = useReducer;
-        exports.useRef = useRef5;
-        exports.useState = useState10;
-        exports.useSyncExternalStore = useSyncExternalStore;
+        exports.useRef = useRef6;
+        exports.useState = useState9;
+        exports.useSyncExternalStore = useSyncExternalStore2;
         exports.useTransition = useTransition;
         exports.version = ReactVersion;
         if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") {
@@ -16072,11 +16072,11 @@ var require_react_reconciler_development = __commonJS({
             currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
             componentUpdateQueue.stores = [check];
           } else {
-            var stores = componentUpdateQueue.stores;
-            if (stores === null) {
+            var stores2 = componentUpdateQueue.stores;
+            if (stores2 === null) {
               componentUpdateQueue.stores = [check];
             } else {
-              stores.push(check);
+              stores2.push(check);
             }
           }
         }
@@ -34899,7 +34899,18 @@ var init_mode_line = __esm({
 });
 
 // src/components/useEventAccumulator.ts
-function processEvents(events) {
+function dropDiscardedEvents(events) {
+  const ranges = [];
+  for (const e of events) {
+    if (e.type === "status" && e.discardFromSeq !== void 0) ranges.push({ from: e.discardFromSeq, to: e.seq });
+  }
+  if (ranges.length === 0) return events;
+  return events.filter(
+    (e) => !((e.type === "text" || e.type === "text_delta") && ranges.some((r) => e.seq >= r.from && e.seq < r.to))
+  );
+}
+function processEvents(rawEvents) {
+  const events = dropDiscardedEvents(rawEvents);
   const renderOrder = [];
   const toolMap = /* @__PURE__ */ new Map();
   let statusMessage = null;
@@ -94306,26 +94317,57 @@ var init_markdown = __esm({
 });
 
 // src/useTerminalSize.ts
+function readSize(stdout, fallback) {
+  return { columns: stdout?.columns || fallback.columns, rows: stdout?.rows || fallback.rows };
+}
+function storeFor(stdout, fallback) {
+  let store = stores.get(stdout);
+  if (!store) {
+    const created = {
+      size: readSize(stdout, fallback),
+      listeners: /* @__PURE__ */ new Set(),
+      onResize: () => {
+        const next = readSize(stdout, fallback);
+        if (next.columns === created.size.columns && next.rows === created.size.rows) return;
+        created.size = next;
+        for (const l of created.listeners) l();
+      }
+    };
+    store = created;
+    stores.set(stdout, store);
+  }
+  return store;
+}
 function useTerminalSize(fallback = { columns: 80, rows: 24 }) {
   const { stdout } = use_stdout_default();
-  const [size, setSize] = (0, import_react24.useState)({ columns: stdout?.columns || fallback.columns, rows: stdout?.rows || fallback.rows });
-  (0, import_react24.useEffect)(() => {
-    if (!stdout) return;
-    const update = () => setSize({ columns: stdout.columns || fallback.columns, rows: stdout.rows || fallback.rows });
-    update();
-    stdout.on("resize", update);
-    return () => {
-      stdout.off("resize", update);
-    };
-  }, [stdout, fallback.columns, fallback.rows]);
-  return size;
+  const fallbackRef = (0, import_react24.useRef)(fallback);
+  fallbackRef.current = fallback;
+  const fixed = (0, import_react24.useRef)(readSize(void 0, fallback));
+  const subscribe = (0, import_react24.useCallback)(
+    (listener) => {
+      if (!stdout) return () => {
+      };
+      const store = storeFor(stdout, fallbackRef.current);
+      store.onResize();
+      if (store.listeners.size === 0) stdout.on("resize", store.onResize);
+      store.listeners.add(listener);
+      return () => {
+        store.listeners.delete(listener);
+        if (store.listeners.size === 0) stdout.off("resize", store.onResize);
+      };
+    },
+    [stdout]
+  );
+  const getSnapshot = (0, import_react24.useCallback)(() => stdout ? storeFor(stdout, fallbackRef.current).size : fixed.current, [stdout]);
+  return (0, import_react24.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
 }
-var import_react24;
+var import_react24, stores;
 var init_useTerminalSize = __esm({
   async "src/useTerminalSize.ts"() {
     "use strict";
     import_react24 = __toESM(require_react(), 1);
     await init_build2();
+    stores = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -97735,7 +97777,8 @@ async function parseStreamResponse(body, emit, signal) {
   let buffer = "";
   const content = [];
   let stopReason = "end_turn";
-  let inputTokens = 0;
+  let inputFromStart = 0;
+  let inputFromDelta = 0;
   let outputTokens = 0;
   let cacheCreationInputTokens = 0;
   let cacheReadInputTokens = 0;
@@ -97744,6 +97787,8 @@ async function parseStreamResponse(body, emit, signal) {
   let currentText = "";
   let currentThinking = "";
   let currentToolInput = "";
+  let sawMessageStop = false;
+  let thinkingStatusShown = false;
   try {
     while (true) {
       if (signal?.aborted) break;
@@ -97766,7 +97811,7 @@ async function parseStreamResponse(body, emit, signal) {
         switch (event.type) {
           case "message_start": {
             if (event.message?.usage) {
-              inputTokens += event.message.usage.input_tokens ?? 0;
+              inputFromStart += event.message.usage.input_tokens ?? 0;
               cacheCreationInputTokens += event.message.usage.cache_creation_input_tokens ?? 0;
               cacheReadInputTokens += event.message.usage.cache_read_input_tokens ?? 0;
             }
@@ -97778,6 +97823,7 @@ async function parseStreamResponse(body, emit, signal) {
             if (block?.type === "thinking") {
               currentBlockType = "thinking";
               currentThinking = "";
+              thinkingStatusShown = false;
             } else if (block?.type === "text") {
               currentBlockType = "text";
               currentText = "";
@@ -97797,6 +97843,10 @@ async function parseStreamResponse(body, emit, signal) {
             const delta = event.delta;
             if (delta?.type === "thinking_delta" && delta.thinking) {
               currentThinking += delta.thinking;
+              if (!thinkingStatusShown) {
+                thinkingStatusShown = true;
+                emitStatus(emit, { type: "status", phase: "thinking" });
+              }
             } else if (delta?.type === "text_delta" && delta.text) {
               currentText += delta.text;
               emitTextDelta(emit, { type: "text_delta", text: delta.text });
@@ -97820,7 +97870,10 @@ async function parseStreamResponse(body, emit, signal) {
                 try {
                   toolBlock.input = JSON.parse(currentToolInput);
                 } catch {
-                  toolBlock.input = {};
+                  throw new StreamIncompleteError(
+                    "invalid_tool_json",
+                    `Tool call "${toolBlock.name}" arrived with invalid JSON arguments`
+                  );
                 }
               }
               currentToolInput = "";
@@ -97835,10 +97888,12 @@ async function parseStreamResponse(body, emit, signal) {
             }
             if (event.usage) {
               outputTokens += event.usage.output_tokens ?? 0;
+              inputFromDelta = Math.max(inputFromDelta, event.usage.input_tokens ?? 0);
             }
             break;
           }
           case "message_stop": {
+            sawMessageStop = true;
             break;
           }
           case "error": {
@@ -97850,22 +97905,37 @@ async function parseStreamResponse(body, emit, signal) {
   } finally {
     reader.releaseLock();
   }
+  if (!signal?.aborted) {
+    if (currentBlockType === "tool_use") {
+      throw new StreamIncompleteError("incomplete_tool_block", "Stream ended inside a tool call");
+    }
+    if (!sawMessageStop) {
+      throw new StreamIncompleteError("missing_message_stop", "Stream ended without message_stop");
+    }
+  }
   return {
     content,
     stop_reason: stopReason,
     usage: {
-      input_tokens: inputTokens,
+      input_tokens: Math.max(inputFromStart, inputFromDelta),
       output_tokens: outputTokens,
       cache_creation_input_tokens: cacheCreationInputTokens,
       cache_read_input_tokens: cacheReadInputTokens
     }
   };
 }
-var seqCounter;
+var seqCounter, StreamIncompleteError;
 var init_stream = __esm({
   "../agent/src/stream.ts"() {
     "use strict";
     seqCounter = 0;
+    StreamIncompleteError = class extends Error {
+      constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = "StreamIncompleteError";
+      }
+    };
   }
 });
 
@@ -97966,7 +98036,30 @@ var init_retry = __esm({
     "use strict";
     MAX_RETRIES = 3;
     INITIAL_RETRY_DELAY_MS = 1e3;
-    RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 529]);
+    RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504, 529]);
+  }
+});
+
+// ../agent/src/request-headers.ts
+function buildRequestHeaders(i) {
+  const headers = {
+    "Content-Type": "application/json",
+    "x-api-key": i.apiKey,
+    "anthropic-version": "2023-06-01",
+    "x-spacecode-session": i.sessionId,
+    "x-spacecode-run": i.runId
+  };
+  if (i.isToolFollowUp && i.lastTier) headers["x-spacecode-tier"] = i.lastTier;
+  return headers;
+}
+function isToolFollowUp(messages) {
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "user" || !Array.isArray(last.content)) return false;
+  return last.content.length > 0 && last.content.every((b2) => b2?.type === "tool_result");
+}
+var init_request_headers = __esm({
+  "../agent/src/request-headers.ts"() {
+    "use strict";
   }
 });
 
@@ -98003,6 +98096,9 @@ async function runAgentLoop(prompt, config, executor, emit, signal, existingMess
   let truncationCount = 0;
   let toolExecutionMs = 0;
   let toolCount = 0;
+  const runId = crypto.randomUUID();
+  const sessionId = config.sessionId ?? runId;
+  let lastTier;
   resetSeq();
   while (turns < maxTurns) {
     if (signal?.aborted) {
@@ -98051,74 +98147,103 @@ async function runAgentLoop(prompt, config, executor, emit, signal, existingMess
     }
     let response;
     let retryCount = 0;
+    let data;
     while (true) {
-      try {
-        response = await fetch(url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "x-api-key": config.apiKey,
-            "anthropic-version": "2023-06-01"
-          },
-          body: JSON.stringify(body),
-          signal
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Unknown fetch error";
+      while (true) {
+        try {
+          response = await fetch(url, {
+            method: "POST",
+            headers: buildRequestHeaders({
+              apiKey: config.apiKey,
+              sessionId,
+              runId,
+              lastTier,
+              isToolFollowUp: isToolFollowUp(messages)
+            }),
+            body: JSON.stringify(body),
+            signal
+          });
+        } catch (err) {
+          const message = err instanceof Error ? err.message : "Unknown fetch error";
+          emitError(emit, { type: "error", message });
+          return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
+        }
+        if (isRetryableStatus(response.status) && retryCount < MAX_RETRIES) {
+          retryCount++;
+          totalRetryCount++;
+          const delayMs = computeRetryDelayMs(response.headers.get("retry-after"), retryCount);
+          emitStatus(emit, {
+            type: "status",
+            phase: "retrying",
+            message: `API returned ${response.status}, retrying in ${Math.round(delayMs / 1e3)}s (attempt ${retryCount}/${MAX_RETRIES})`
+          });
+          try {
+            await sleep(delayMs, signal);
+          } catch {
+            emitError(emit, { type: "error", message: "Aborted" });
+            return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
+          }
+          continue;
+        }
+        break;
+      }
+      if (!response.ok) {
+        let errorBody;
+        try {
+          errorBody = await response.text();
+        } catch {
+          errorBody = response.statusText;
+        }
+        const message = `API error ${response.status}: ${errorBody}`;
         emitError(emit, { type: "error", message });
         return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
       }
-      if (isRetryableStatus(response.status) && retryCount < MAX_RETRIES) {
-        retryCount++;
-        const delayMs = computeRetryDelayMs(response.headers.get("retry-after"), retryCount);
-        emitStatus(emit, {
-          type: "status",
-          phase: "retrying",
-          message: `API returned ${response.status}, retrying in ${Math.round(delayMs / 1e3)}s (attempt ${retryCount}/${MAX_RETRIES})`
-        });
+      lastTier = response.headers.get("x-spacecode-tier") ?? lastTier;
+      if (!response.body) {
         try {
-          await sleep(delayMs, signal);
+          data = await response.json();
         } catch {
-          emitError(emit, { type: "error", message: "Aborted" });
+          emitError(emit, { type: "error", message: "Failed to parse API response" });
           return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
         }
-        continue;
-      }
-      break;
-    }
-    totalRetryCount += retryCount;
-    if (!response.ok) {
-      let errorBody;
-      try {
-        errorBody = await response.text();
-      } catch {
-        errorBody = response.statusText;
+        for (const block of data.content) {
+          if (block.type === "text" && block.text !== void 0) {
+            emitText(emit, { type: "text", content: block.text });
+          }
+        }
+        break;
       }
-      const message = `API error ${response.status}: ${errorBody}`;
-      emitError(emit, { type: "error", message });
-      return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
-    }
-    let data;
-    if (response.body) {
+      let attemptFirstSeq;
+      const attemptEmit = (event) => {
+        if (attemptFirstSeq === void 0) attemptFirstSeq = event.seq;
+        emit(event);
+      };
       try {
-        data = await parseStreamResponse(response.body, emit, signal);
+        data = await parseStreamResponse(response.body, attemptEmit, signal);
+        break;
       } catch (err) {
+        if (err instanceof StreamIncompleteError && retryCount < MAX_RETRIES) {
+          retryCount++;
+          totalRetryCount++;
+          const delayMs = computeRetryDelayMs(null, retryCount);
+          emitStatus(emit, {
+            type: "status",
+            phase: "retrying",
+            message: `Stream ended early (${err.reason}), retrying (attempt ${retryCount}/${MAX_RETRIES})`,
+            ...attemptFirstSeq !== void 0 ? { discardFromSeq: attemptFirstSeq } : {}
+          });
+          try {
+            await sleep(delayMs, signal);
+          } catch {
+            emitError(emit, { type: "error", message: "Aborted" });
+            return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
+          }
+          continue;
+        }
         const message = err instanceof Error ? err.message : "Stream parse error";
         emitError(emit, { type: "error", message });
         return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
       }
-    } else {
-      try {
-        data = await response.json();
-      } catch {
-        emitError(emit, { type: "error", message: "Failed to parse API response" });
-        return { success: false, text: lastText, totalInputTokens, totalOutputTokens, cacheCreationTokens, cacheReadTokens, turns, messages, retryCount: totalRetryCount, truncationCount, toolExecutionMs, toolCount };
-      }
-      for (const block of data.content) {
-        if (block.type === "text" && block.text !== void 0) {
-          emitText(emit, { type: "text", content: block.text });
-        }
-      }
     }
     totalInputTokens += data.usage.input_tokens;
     totalOutputTokens += data.usage.output_tokens;
@@ -98211,6 +98336,7 @@ var init_loop = __esm({
     init_stream();
     init_context_window();
     init_retry();
+    init_request_headers();
     init_context_window();
     DEFAULT_MODEL = "claude-sonnet-4-6";
     DEFAULT_MAX_TURNS = 100;
@@ -100351,7 +100477,10 @@ ${tools.map((t) => `  ${t.name}`).join("\n")}`);
           hasGitHubTools: toolset.hasGitHubTools
         }),
         tools: toolset.tools,
-        maxTurns: 100
+        maxTurns: 100,
+        // One conversation key for the whole saved session (also after --continue), so the gateway can keep a
+        // conversation on one model. The id is only reserved here; nothing is saved until a turn commits.
+        ...sessions ? { sessionId: sessionIdRef.current ??= sessions.newId() } : {}
       };
       const emit = (event) => {
         if (event.type === "error" && controller.signal.aborted) return;
@@ -100401,7 +100530,7 @@ ${tools.map((t) => `  ${t.name}`).join("\n")}`);
     }
   }, [repoName2, history, exit, permissions, notice, refuseAllConfirms, commitTurn, mentions, createToolset, sessions, projectRoot, persist, applySession, model, onViewTurns, onViewResume, setTodos]);
   const approxTokens = (0, import_react30.useMemo)(
-    () => events.reduce((n, e) => n + (e.type === "text" ? estimateTokens(e.content) : e.type === "text_delta" ? estimateTokens(e.text) : 0), 0),
+    () => dropDiscardedEvents(events).reduce((n, e) => n + (e.type === "text" ? estimateTokens(e.content) : e.type === "text_delta" ? estimateTokens(e.text) : 0), 0),
     [events]
   );
   const stats = {
@@ -100460,6 +100589,7 @@ var init_useReplController = __esm({
     init_node_mentions();
     init_api_key();
     init_slash_commands();
+    init_useEventAccumulator();
     apiUrl = () => process.env.API_PROXY_URL || "https://api.spacecode.app";
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacecode",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "SpaceCode - launch cloud dev environments with AI coding agents",
   "license": "MIT",
   "type": "commonjs",