archymedes-cli 2.2.0 → 2.5.0

package/README.md

@@ -312,13 +312,23 @@ The startup geometry makes a brief rotation on roomy interactive terminals. Set
 
 ## Fixed workspace
 
-Start with `archymedes --layout fixed` for a persistent mode bar, an anchored composer, and menus
-that open inside the transcript area. `/layout` switches layouts during a session;
-`ARCHYMEDES_LAYOUT=fixed` makes the fixed workspace your launch preference.
-
-Use `/mode` to choose plan, build, auto, or defender with the arrow keys. Page Up / Page Down
-read retained transcript history; Escape returns to live output. Home and End still edit the
-composer. Each tab retains up to 5,000 output lines. Resize reflows the live transcript.
+Interactive sessions open in the fixed workspace: a persistent mode bar, an anchored composer, and
+menus that open inside the transcript area. `/layout` switches layouts during a session;
+`archymedes --layout scrollback` or `ARCHYMEDES_LAYOUT=scrollback` keeps the plain terminal log.
+
+Use `/mode` to choose plan, build, auto, or defender with the arrow keys. To read history, use the
+mouse wheel or Page Up / Page Down. Alt+Up / Alt+Down (or Ctrl) move one line, and Ctrl+Home jumps
+to the top. Escape, Ctrl+End, or scrolling back to the bottom returns to live output. History keeps
+its colours, a scrollbar shows your position, and the header counts output that arrived while you
+were reading. Arrow keys, Home and End still edit the composer. Wheel scrolling uses mouse
+reporting, so hold Shift to select text, or set `ARCHYMEDES_MOUSE=0` to keep the terminal's own
+selection. Each tab retains up to 5,000 output lines, and resizing reflows the transcript.
+
+`/find <text>` searches the tab's history and jumps to the first match; `/find` again moves to the
+next one, `/find prev` to the previous, and `/find off` or Escape returns to live output. `/pager`
+opens the whole transcript in `$PAGER` (`less -R` by default). `/cat image.png` draws a PNG in the
+transcript with coloured half-blocks; in the scrollback layout, `ARCHYMEDES_IMAGES=kitty` uses Kitty
+graphics for real pixels, and `/clear` removes them.
 
 The opening geometry rotates while the workspace is idle and settles as soon as you type.
 `ARCHYMEDES_NO_MOTION=1` disables this motion and menu focus animation. `--ascii`, `NO_COLOR`,

package/dist/{archymedes-76z6n643.mjs → archymedes-06fh0z84.mjs}

@@ -8530,10 +8530,82 @@ function toWireMessage(message) {
       tool_calls: message.toolCalls.map((call) => ({ id: call.id, type: "function", function: { name: call.name, arguments: JSON.stringify(call.arguments) } }))
     };
   }
+  if (message.role === "user" && "images" in message && message.images?.length) {
+    return {
+      role: "user",
+      content: [
+        { type: "text", text: message.content },
+        ...message.images.map((image) => ({ type: "image_url", image_url: { url: `data:${image.mediaType};base64,${image.data}` } }))
+      ]
+    };
+  }
   return { role: message.role, content: message.content };
 }
-function toWireMessages(messages) {
-  return messages.map(toWireMessage);
+function toWireMessages(messages, options = {}) {
+  const vision = options.vision ?? true;
+  const wire = [];
+  let pending = [];
+  const flush = () => {
+    if (pending.length === 0)
+      return;
+    wire.push({
+      role: "user",
+      content: [
+        { type: "text", text: `Image${pending.reduce((sum, entry) => sum + entry.images.length, 0) === 1 ? "" : "s"} returned by the ${[...new Set(pending.map((entry) => entry.name))].join(", ")} tool call${pending.length === 1 ? "" : "s"} above: ${pending.flatMap((entry) => entry.images.map((image) => image.path)).join(", ")}` },
+        ...pending.flatMap((entry) => entry.images.map((image) => ({ type: "image_url", image_url: { url: `data:${image.mediaType};base64,${image.data}` } })))
+      ]
+    });
+    pending = [];
+  };
+  for (const message of messages) {
+    if (message.role !== "tool")
+      flush();
+    if (message.role === "tool" && message.images?.length) {
+      if (vision) {
+        wire.push(toWireMessage(message));
+        pending.push({ name: message.name, images: message.images });
+      } else {
+        const note = `[${message.images.length === 1 ? "image" : "images"} not shown: this model cannot view images (${message.images.map((image) => image.path).join(", ")})]`;
+        wire.push(toWireMessage({ ...message, content: `${message.content}
+${note}` }));
+      }
+      continue;
+    }
+    wire.push(toWireMessage(message));
+  }
+  flush();
+  return wire;
+}
+var EPHEMERAL = { type: "ephemeral" };
+function usesOpenRouterCacheControl(model) {
+  return model.startsWith("anthropic/") || model.startsWith("google/");
+}
+function isOpenRouterBaseUrl(baseURL) {
+  if (!baseURL)
+    return false;
+  try {
+    return new URL(baseURL).hostname.endsWith("openrouter.ai");
+  } catch {
+    return false;
+  }
+}
+function withPartBreakpoint(message) {
+  if (typeof message.content === "string") {
+    return message.content ? { ...message, content: [{ type: "text", text: message.content, cache_control: EPHEMERAL }] } : message;
+  }
+  if (!Array.isArray(message.content))
+    return message;
+  const parts = message.content;
+  const last = parts.map((part) => part.type).lastIndexOf("text");
+  if (last < 0)
+    return message;
+  return { ...message, content: parts.map((part, index) => index === last ? { ...part, cache_control: EPHEMERAL } : part) };
+}
+function withOpenRouterCacheControl(messages, model) {
+  if (!usesOpenRouterCacheControl(model))
+    return messages;
+  const lastUser = messages.map((message) => message.role).lastIndexOf("user");
+  return messages.map((message, index) => message.role === "system" || index === lastUser ? withPartBreakpoint(message) : message);
 }
 function parseArguments(value) {
   try {
@@ -8584,7 +8656,7 @@ function turnFromChatResponse(response) {
     ...routingReceipt ? { routingReceipt } : {}
   };
 }
-async function collectChatStream(stream, onTextDelta) {
+async function collectChatStream(stream, onTextDelta, onOutputProgress) {
   let id = "";
   let model = "";
   let content = "";
@@ -8606,10 +8678,15 @@ async function collectChatStream(stream, onTextDelta) {
       finishReason = choice.finish_reason;
     if (choice.delta?.refusal)
       refusal += choice.delta.refusal;
+    if (choice.delta?.reasoning || choice.delta?.reasoning_content)
+      onOutputProgress?.("reasoning");
     if (choice.delta?.content) {
       content += choice.delta.content;
+      onOutputProgress?.("text");
       onTextDelta?.(choice.delta.content);
     }
+    if (choice.delta?.tool_calls?.length)
+      onOutputProgress?.("tool_call");
     for (const fragment of choice.delta?.tool_calls ?? []) {
       const existing = calls.get(fragment.index) ?? { id: "", name: "", args: "" };
       calls.set(fragment.index, {
@@ -8637,6 +8714,7 @@ function exactCapabilities(models, contextWindow, maxOutputTokens, supportsEffor
   return models.map((prefix) => ({ prefix, match: "exact", capabilities: { contextWindow, maxOutputTokens, supportsEffort } }));
 }
 var KNOWN_CAPABILITIES = [
+  { prefix: "openrouter/free", match: "exact", capabilities: { contextWindow: 32768, maxOutputTokens: 4096, supportsEffort: false } },
   { prefix: "auto", match: "exact", capabilities: { ...CONSERVATIVE_CAPABILITIES } },
   { prefix: "gemini-2.5-pro", match: "prefix", capabilities: { contextWindow: 1048576, maxOutputTokens: 65536, supportsEffort: true } },
   { prefix: "gemini-2.5-flash", match: "prefix", capabilities: { contextWindow: 1048576, maxOutputTokens: 65536, supportsEffort: true } },
@@ -8687,6 +8765,142 @@ function capabilitiesFor(modelId) {
 var DEFAULT_OUTPUT_CEILING = 64000;
 var PROTOCOL_MAX_OUTPUT_TOKENS = 128000;
 
+// packages/core/src/providers/stream-deadline.ts
+var DEFAULT_FIRST_BYTE_TIMEOUT_MS = 300000;
+var DEFAULT_IDLE_TIMEOUT_MS = 90000;
+var DEFAULT_TOTAL_TIMEOUT_MS = 30 * 60000;
+
+class StreamTimeoutError extends Error {
+  phase;
+  timeoutMs;
+  name = "TimeoutError";
+  code = "ETIMEDOUT";
+  constructor(phase, timeoutMs) {
+    const seconds = Math.round(timeoutMs / 1000);
+    super(phase === "first_byte" ? `Model request timed out: no response within ${seconds}s.` : phase === "idle" ? `Model stream timed out: no data received for ${seconds}s.` : `Model request timed out: exceeded the ${seconds}s overall limit.`);
+    this.phase = phase;
+    this.timeoutMs = timeoutMs;
+  }
+}
+function streamTimeoutsFor(timeoutMs, overrides = {}) {
+  const legacy = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined;
+  return {
+    firstByteMs: overrides.firstByteMs ?? Math.max(DEFAULT_FIRST_BYTE_TIMEOUT_MS, legacy ?? 0),
+    idleMs: overrides.idleMs ?? legacy ?? DEFAULT_IDLE_TIMEOUT_MS,
+    totalMs: overrides.totalMs ?? Math.max(DEFAULT_TOTAL_TIMEOUT_MS, legacy ?? 0)
+  };
+}
+function createStreamDeadline(options = {}) {
+  const timeouts = {
+    firstByteMs: options.firstByteMs ?? DEFAULT_FIRST_BYTE_TIMEOUT_MS,
+    idleMs: options.idleMs ?? DEFAULT_IDLE_TIMEOUT_MS,
+    totalMs: options.totalMs ?? DEFAULT_TOTAL_TIMEOUT_MS
+  };
+  const controller = new AbortController;
+  const signal = options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+  let timedOut;
+  let started = false;
+  let disposed = false;
+  let phaseTimer;
+  let totalTimer;
+  const waiters = new Set;
+  const schedule = (ms, fire) => {
+    const timer = setTimeout(fire, ms);
+    timer.unref?.();
+    return timer;
+  };
+  const clear = () => {
+    if (phaseTimer !== undefined)
+      clearTimeout(phaseTimer);
+    if (totalTimer !== undefined)
+      clearTimeout(totalTimer);
+    phaseTimer = totalTimer = undefined;
+  };
+  const expire = (phase, ms) => {
+    if (disposed || timedOut || options.signal?.aborted)
+      return;
+    timedOut = new StreamTimeoutError(phase, ms);
+    clear();
+    controller.abort(timedOut);
+    for (const reject of waiters)
+      reject(timedOut);
+    waiters.clear();
+  };
+  if (!options.signal?.aborted) {
+    phaseTimer = schedule(timeouts.firstByteMs, () => expire("first_byte", timeouts.firstByteMs));
+    totalTimer = schedule(timeouts.totalMs, () => expire("total", timeouts.totalMs));
+  }
+  const touch = () => {
+    if (disposed || timedOut)
+      return;
+    started = true;
+    if (phaseTimer !== undefined)
+      clearTimeout(phaseTimer);
+    phaseTimer = schedule(timeouts.idleMs, () => expire("idle", timeouts.idleMs));
+  };
+  const race = (promise) => {
+    if (timedOut) {
+      promise.catch(() => {
+        return;
+      });
+      return Promise.reject(timedOut);
+    }
+    return new Promise((resolve, reject) => {
+      const onTimeout = (error2) => {
+        promise.catch(() => {
+          return;
+        });
+        reject(error2);
+      };
+      waiters.add(onTimeout);
+      promise.then((value) => {
+        waiters.delete(onTimeout);
+        resolve(value);
+      }, (error2) => {
+        waiters.delete(onTimeout);
+        reject(error2);
+      });
+    });
+  };
+  async function* wrap(stream) {
+    const iterator = stream[Symbol.asyncIterator]();
+    let finished = false;
+    try {
+      while (true) {
+        const next = await race(iterator.next());
+        if (next.done) {
+          finished = true;
+          return;
+        }
+        touch();
+        yield next.value;
+      }
+    } finally {
+      if (!finished)
+        Promise.resolve().then(() => iterator.return?.()).catch(() => {
+          return;
+        });
+    }
+  }
+  return {
+    signal,
+    get timedOut() {
+      return timedOut;
+    },
+    get started() {
+      return started;
+    },
+    touch,
+    race,
+    wrap,
+    dispose() {
+      disposed = true;
+      clear();
+      waiters.clear();
+    }
+  };
+}
+
 // packages/core/src/providers/openai-agent.ts
 function usesInklingToolContract(model) {
   return model === "thinkingmachines/inkling:free" || model === "thinkingmachines/inkling-small:free";
@@ -8706,7 +8920,7 @@ class OpenAIAgentTurnProvider {
     if (call)
       this.call = call;
     else {
-      const client = new OpenAI({ apiKey: options.apiKey, ...options.baseURL ? { baseURL: options.baseURL } : {}, maxRetries: 0 });
+      const client = new OpenAI({ apiKey: options.apiKey, ...options.baseURL ? { baseURL: options.baseURL } : {}, ...options.defaultHeaders ? { defaultHeaders: options.defaultHeaders } : {}, maxRetries: 0 });
       this.call = async (body, signal) => await client.chat.completions.create(body, { signal });
     }
   }
@@ -8714,9 +8928,9 @@ class OpenAIAgentTurnProvider {
     if (!request.safetyIdentifier.trim())
       throw new Error("safetyIdentifier is required");
     const inkling = usesInklingToolContract(this.options.model);
-    const response = await this.call({
+    const body = {
       model: this.options.model,
-      messages: toWireMessages(request.messages),
+      messages: isOpenRouterBaseUrl(this.options.baseURL) ? withOpenRouterCacheControl(toWireMessages(request.messages), this.options.model) : toWireMessages(request.messages),
       ...request.tools.length > 0 ? {
         tools: request.tools.map((tool) => ({ type: "function", function: { name: tool.name, description: tool.description, parameters: tool.inputSchema } }))
       } : {},
@@ -8727,11 +8941,18 @@ class OpenAIAgentTurnProvider {
       ...request.effort && this.capabilities.supportsEffort ? { reasoning_effort: request.effort } : {},
       stream: true,
       stream_options: { include_usage: true }
-    }, AbortSignal.any([
-      AbortSignal.timeout(this.options.timeoutMs ?? 180000),
-      ...request.signal ? [request.signal] : []
-    ]));
-    return turnFromChatResponse(Symbol.asyncIterator in Object(response) ? await collectChatStream(response, request.onTextDelta) : response);
+    };
+    const deadline = createStreamDeadline({ ...streamTimeoutsFor(this.options.timeoutMs), signal: request.signal });
+    try {
+      const response = await deadline.race(this.call(body, deadline.signal));
+      return turnFromChatResponse(Symbol.asyncIterator in Object(response) ? await collectChatStream(deadline.wrap(response), request.onTextDelta, request.onOutputProgress) : response);
+    } catch (error2) {
+      if (deadline.timedOut)
+        throw deadline.timedOut;
+      throw error2;
+    } finally {
+      deadline.dispose();
+    }
   }
 }
 
@@ -8850,4 +9071,4 @@ function wanderGradeCounts(results) {
   return WANDER_GRADES.map((grade) => ({ grade, count: results.claims.filter((claim) => claim.grade === grade).length }));
 }
 
-export { approximateInputTokens, newPartTotals, addPart, tokenEstimateFrom, affordableOutputTokensFor, affordableOutputTokens, priceActualModelUsage, modelPricesFromEnvironment, TASK_KINDS, buildTaskProfile, mergeRoutingReceipts, capabilitiesFor, DEFAULT_OUTPUT_CEILING, PROTOCOL_MAX_OUTPUT_TOKENS, makeParseableTextFormat, OpenAI, toWireMessages, turnFromChatResponse, OpenAIAgentTurnProvider, WANDER_MARKER, WANDER_LAB_FILES, isWanderObjective, isWanderRandomScheduleObjective, buildWanderScheduleObjective, pickWanderTopic, buildWanderObjective, wanderPlannerInstructions, WANDER_GRADES, parseWanderResults, wanderGradeCounts };
+export { approximateInputTokens, newPartTotals, addPart, tokenEstimateFrom, affordableOutputTokensFor, affordableOutputTokens, priceActualModelUsage, modelPricesFromEnvironment, TASK_KINDS, buildTaskProfile, mergeRoutingReceipts, capabilitiesFor, DEFAULT_OUTPUT_CEILING, PROTOCOL_MAX_OUTPUT_TOKENS, DEFAULT_TOTAL_TIMEOUT_MS, StreamTimeoutError, streamTimeoutsFor, createStreamDeadline, APIConnectionError, makeParseableTextFormat, OpenAI, toWireMessages, withOpenRouterCacheControl, turnFromChatResponse, collectChatStream, OpenAIAgentTurnProvider, WANDER_MARKER, WANDER_LAB_FILES, isWanderObjective, isWanderRandomScheduleObjective, buildWanderScheduleObjective, pickWanderTopic, buildWanderObjective, wanderPlannerInstructions, WANDER_GRADES, parseWanderResults, wanderGradeCounts };