@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-KJ5LWLOE.js

@@ -0,0 +1,1077 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  canonicalJson,
+  sha256
+} from "./chunk-6EJV5X2W.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  ceilChars,
+  extractReasoningTokens
+} from "./chunk-LZSJBIVT.js";
+import {
+  settingsPath
+} from "./chunk-A3CYT5EX.js";
+import {
+  expandConfigPath
+} from "./chunk-SST6Z5JA.js";
+import {
+  isEngineContextOverflow
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/steer-channel.ts
+init_esm_shims();
+import * as fs from "node:fs";
+import * as readline from "node:readline";
+function setupSteerChannel(filePath, onLine) {
+  let closed = false;
+  let watcher = null;
+  let stream = null;
+  let rl = null;
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.isFIFO()) {
+      stream = fs.createReadStream(filePath);
+      rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+      rl.on("line", (line) => {
+        if (closed) return;
+        const trimmed = line.trim();
+        if (trimmed.length > 0) {
+          onLine(trimmed);
+        }
+      });
+    } else {
+      let bytesRead = 0;
+      let leftover = "";
+      const readNewContent = () => {
+        if (closed) return;
+        try {
+          const currentStats = fs.statSync(filePath);
+          if (currentStats.size > bytesRead) {
+            let fd;
+            const buffer = Buffer.alloc(currentStats.size - bytesRead);
+            try {
+              fd = fs.openSync(filePath, "r");
+              fs.readSync(fd, buffer, 0, buffer.length, bytesRead);
+            } finally {
+              if (fd !== void 0) fs.closeSync(fd);
+            }
+            bytesRead = currentStats.size;
+            const text = `${leftover}${buffer.toString("utf-8")}`;
+            const lines = text.split(/\r?\n/);
+            leftover = lines.pop() ?? "";
+            for (const line of lines) {
+              if (closed) return;
+              const trimmed = line.trim();
+              if (trimmed.length > 0) {
+                onLine(trimmed);
+              }
+            }
+          }
+        } catch (_err) {
+        }
+      };
+      readNewContent();
+      watcher = fs.watch(filePath, (event) => {
+        if (event === "change") {
+          readNewContent();
+        }
+      });
+    }
+  } catch (err) {
+    process.stderr.write(
+      `clio-coder run: failed to setup steer channel: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  return () => {
+    closed = true;
+    if (watcher) {
+      watcher.close();
+    }
+    if (rl) {
+      rl.close();
+    }
+    if (stream) {
+      stream.destroy();
+    }
+  };
+}
+
+// src/cli/modes/json-stream.ts
+init_esm_shims();
+
+// src/interactive/chat-loop-messages.ts
+init_esm_shims();
+import { randomUUID } from "node:crypto";
+
+// src/domains/providers/errors.ts
+init_esm_shims();
+var ContextOverflowError = class extends Error {
+  kind = "context-overflow";
+  original;
+  constructor(message, original) {
+    super(message);
+    this.name = "ContextOverflowError";
+    this.original = original;
+  }
+};
+function isContextOverflowError(err) {
+  if (err instanceof ContextOverflowError) return true;
+  if (!err || typeof err !== "object") return false;
+  return err.kind === "context-overflow";
+}
+function toContextOverflowError(err) {
+  if (isContextOverflowError(err))
+    return err instanceof ContextOverflowError ? err : new ContextOverflowError(
+      typeof err.message === "string" ? err.message : "context overflow",
+      err
+    );
+  const message = extractMessage(err);
+  if (!message) return null;
+  if (isEngineContextOverflow(message)) return new ContextOverflowError(message, err);
+  return null;
+}
+function extractMessage(err) {
+  if (typeof err === "string") return err;
+  if (err instanceof Error) return err.message;
+  if (err && typeof err === "object") {
+    const m = err.message;
+    if (typeof m === "string") return m;
+  }
+  return "";
+}
+
+// src/interactive/chat-loop-messages.ts
+function notConfiguredNotice() {
+  return [
+    "[Clio Coder] orchestrator not configured. Set one up with:",
+    "  clio-coder configure --id <id> --runtime <runtime> --url <url> --model <model> --set-orchestrator",
+    "or, when targets already exist: clio-coder targets use <id> --model <model>",
+    `(orchestrator.target + orchestrator.model live in ${settingsPath()})`
+  ].join("\n");
+}
+function extractText(message) {
+  if (!message || typeof message !== "object" || message === null || !("role" in message) || message.role !== "assistant") {
+    return "";
+  }
+  const content = "content" in message && Array.isArray(message.content) ? message.content : [];
+  return content.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join("");
+}
+function extractUserText(message) {
+  if (!message || typeof message !== "object" || message === null || !("role" in message) || message.role !== "user") {
+    return "";
+  }
+  const content = "content" in message ? message.content : "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join("");
+}
+function extractThinking(message) {
+  if (!message || typeof message !== "object" || message === null || !("role" in message) || message.role !== "assistant") {
+    return "";
+  }
+  const content = "content" in message && Array.isArray(message.content) ? message.content : [];
+  return content.filter(
+    (item) => item?.type === "thinking" && typeof item.thinking === "string"
+  ).map((item) => item.thinking).join("");
+}
+function terminalFailureFromAssistantMessage(message) {
+  if (!message || typeof message !== "object" || message === null || !("role" in message) || message.role !== "assistant") {
+    return null;
+  }
+  const stopReason = message.stopReason;
+  if (stopReason !== "error" && stopReason !== "aborted") return null;
+  const rawError = message.errorMessage;
+  const errorMessage = typeof rawError === "string" && rawError.length > 0 ? rawError : stopReason === "aborted" ? "request aborted" : "model target returned an error";
+  return { stopReason, errorMessage, message };
+}
+function isSelfExplainingAbort(view) {
+  if (view.stopReason !== "aborted") return false;
+  if (typeof view.errorMessage === "string" && view.errorMessage.length > 0) return false;
+  return view.text.trim().length > 0;
+}
+function isLengthStopAssistantMessage(message) {
+  return !!message && typeof message === "object" && message !== null && "role" in message && message.role === "assistant" && message.stopReason === "length";
+}
+function isEmptyAbortedAssistantMessage(message) {
+  if (!message || typeof message !== "object" || message === null || !("role" in message) || message.role !== "assistant") {
+    return false;
+  }
+  if (message.stopReason !== "aborted") return false;
+  if (extractText(message).trim().length > 0) return false;
+  return !hasStructuredToolCall(message);
+}
+function lengthStopMetadata(message) {
+  const usage = message.usage;
+  const metadata = {
+    kind: "provider_length_stop",
+    stopReason: "length",
+    message: "Model target hit its generation/output limit before a complete assistant response. This is not a safety denial; compacting helps only when the prompt and tool observations are also near the context window."
+  };
+  if (usage && typeof usage === "object") {
+    const u = usage;
+    for (const [from, to] of [
+      ["input", "inputTokens"],
+      ["output", "outputTokens"],
+      ["totalTokens", "totalTokens"]
+    ]) {
+      const value = u[from];
+      if (typeof value === "number" && Number.isFinite(value)) metadata[to] = value;
+    }
+  }
+  return metadata;
+}
+function hasStructuredToolCall(message) {
+  if (!message || typeof message !== "object" || !("content" in message) || !Array.isArray(message.content))
+    return false;
+  return message.content.some((block) => block?.type === "toolCall");
+}
+function toolNamesFromAgentState(tools) {
+  const names = [];
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object") continue;
+    const name = tool.name;
+    if (typeof name === "string" && name.trim().length > 0) names.push(name);
+  }
+  return names;
+}
+function noticeMessage(text) {
+  return {
+    role: "assistant",
+    content: [{ type: "text", text }],
+    stopReason: "aborted",
+    timestamp: Date.now()
+  };
+}
+function pendingSkillRequestPreamble(requests) {
+  const named = requests.filter((request) => request.name.trim().length > 0);
+  if (named.length === 0) return "";
+  const allowed = [...new Set(named.map((request) => request.name.trim()))];
+  const lines = named.map((request) => {
+    const status = request.installed ? "installed" : "not-installed";
+    const args = request.args.trim();
+    return `- ${request.name} (${status}, source=${request.source})${args.length > 0 ? ` \u2014 task: ${args}` : ""}`;
+  });
+  return [
+    "[Skill request]",
+    ...lines,
+    `First call context with scope="skills" and name for: ${allowed.join(", ")}. Only these pending skill names are allowed this turn. After the skill loads, follow the loaded workflow.`
+  ].join("\n");
+}
+function toolSignatureFromState(tools) {
+  const schemas = [];
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object" || Array.isArray(tool)) continue;
+    const record = tool;
+    schemas.push({
+      name: typeof record.name === "string" ? record.name : "",
+      description: typeof record.description === "string" ? record.description : "",
+      parameters: record.parameters ?? null
+    });
+  }
+  schemas.sort((a, b) => a.name.localeCompare(b.name));
+  return sha256(canonicalJson(schemas));
+}
+function fallbackIdentityPrompt() {
+  return [
+    "You are Clio, the coding agent in IOWarp's CLIO ecosystem of agentic science (NSF-funded, iowarp.ai).",
+    "CLIO stands for Context Layer for Input/Output. Named after the Greek muse of history, you focus on HPC and scientific-software engineering.",
+    "Whichever weights run you, your name and persona are Clio. You are not Claude, GPT, Qwen, Gemini, Llama, Mistral, or any other vendor's assistant."
+  ].join(" ");
+}
+function createPendingSkillToolPolicy(requests) {
+  const allowedSkillNames = [
+    ...new Set(requests.map((request) => request.name.trim()).filter((name) => name.length > 0))
+  ];
+  if (allowedSkillNames.length === 0) return void 0;
+  return {
+    allowedSkillNames,
+    requests: [...requests],
+    loadedSkillNames: /* @__PURE__ */ new Set(),
+    loadedSkillPolicies: /* @__PURE__ */ new Map()
+  };
+}
+function createAskUserToolPolicy(activeTools) {
+  if (!activeTools.some((tool) => tool.name === ToolNames.AskUser)) return void 0;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: randomUUID(),
+    status: "idle",
+    startedAt: now,
+    updatedAt: now,
+    rounds: [],
+    decisions: [],
+    inFlight: false,
+    cancelled: false,
+    answerCount: 0,
+    callCount: 0,
+    maxCalls: 6,
+    askedQuestionKeys: /* @__PURE__ */ new Set()
+  };
+}
+function sumRunUsage(messages) {
+  const summary = {
+    tokens: 0,
+    costUsd: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    apiCalls: 0,
+    hadReasoning: false,
+    hadUsage: false
+  };
+  for (const raw of messages) {
+    const message = raw;
+    if (!message || typeof message !== "object") continue;
+    if (message.role !== "assistant") continue;
+    const usage = message.usage;
+    if (!usage || typeof usage !== "object") continue;
+    summary.hadUsage = true;
+    summary.apiCalls += 1;
+    const input = typeof usage.input === "number" ? usage.input : 0;
+    const output = typeof usage.output === "number" ? usage.output : 0;
+    const cacheRead = typeof usage.cacheRead === "number" ? usage.cacheRead : 0;
+    const cacheWrite = typeof usage.cacheWrite === "number" ? usage.cacheWrite : 0;
+    summary.input += input;
+    summary.output += output;
+    summary.cacheRead += cacheRead;
+    summary.cacheWrite += cacheWrite;
+    const reasoning = extractReasoningTokens(usage);
+    if (reasoning !== null) {
+      summary.reasoning += reasoning;
+      summary.hadReasoning = true;
+    }
+    if (typeof usage.totalTokens === "number" && usage.totalTokens > 0) {
+      summary.tokens += usage.totalTokens;
+    } else {
+      summary.tokens += input + output + cacheRead + cacheWrite;
+    }
+    const total = usage.cost?.total;
+    if (typeof total === "number") summary.costUsd += total;
+  }
+  return summary;
+}
+function backendCacheVerdict(input, cacheRead) {
+  if (cacheRead > 0) return input >= 2e3 ? "partial" : "hot";
+  return input >= 2e3 ? "cold" : "small";
+}
+function assistantSessionPayload(message, failure) {
+  const text = extractText(message).trim();
+  const thinking = extractThinking(message).trim();
+  const payload = { text };
+  const raw = message;
+  if (Array.isArray(raw.content)) payload.content = raw.content;
+  if (thinking.length > 0) payload.thinking = thinking;
+  for (const key of ["usage", "api", "provider", "model", "responseModel", "responseId", "diagnostics"]) {
+    if (raw[key] !== void 0) payload[key] = raw[key];
+  }
+  if (failure && !isSelfExplainingAbort({ stopReason: raw.stopReason, errorMessage: raw.errorMessage, text })) {
+    payload.stopReason = failure.stopReason;
+    payload.errorMessage = failure.errorMessage;
+  } else {
+    const stopReason = raw.stopReason;
+    if (stopReason !== void 0) payload.stopReason = stopReason;
+    if (stopReason === "length") payload.contextExhaustion = lengthStopMetadata(message);
+  }
+  return payload;
+}
+function estimatedUsageForInterruptedTurn(message, promptSideTokens) {
+  if (message.stopReason !== "aborted") return null;
+  const reported = message.usage;
+  if (reported && typeof reported === "object") {
+    for (const key of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"]) {
+      const value = reported[key];
+      if (typeof value === "number" && value > 0) return null;
+    }
+  }
+  const streamedChars = extractText(message).length + extractThinking(message).length;
+  if (streamedChars === 0 && promptSideTokens <= 0) return null;
+  const input = Math.max(0, Math.round(promptSideTokens));
+  const output = streamedChars > 0 ? Math.max(1, ceilChars(streamedChars)) : 0;
+  return {
+    input,
+    output,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    totalTokens: input + output,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    estimated: true
+  };
+}
+function hasPersistableAssistantContent(payload, failure) {
+  if (failure) return true;
+  if (payload.stopReason === "length") return true;
+  if (typeof payload.text === "string" && payload.text.trim().length > 0) return true;
+  if (typeof payload.thinking === "string" && payload.thinking.trim().length > 0) return true;
+  if (Array.isArray(payload.content) && payload.content.length > 0) return true;
+  return false;
+}
+function recordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function textFromToolResultContent(content) {
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => {
+    const item = recordValue(block);
+    if (item?.type !== "text" || typeof item?.text !== "string") return "";
+    return item.text;
+  }).join("");
+}
+function toolResultSummary(result2) {
+  const obj = recordValue(result2);
+  const text = textFromToolResultContent(obj?.content) || (typeof result2 === "string" ? result2 : "");
+  const bytes = Buffer.byteLength(text, "utf8");
+  const details = recordValue(obj?.details);
+  const size = recordValue(details?.resultSize);
+  const truncation = recordValue(details?.truncation);
+  const observation = recordValue(details?.observation);
+  const offloadPath = typeof observation?.offloadPath === "string" ? observation.offloadPath : typeof size?.offloadPath === "string" ? size.offloadPath : null;
+  return {
+    bytes,
+    truncated: size?.truncated === true || truncation?.truncated === true || observation?.truncated === true || text.includes("[tool result truncated]"),
+    ...typeof size?.policy === "string" ? { policy: size.policy } : {},
+    ...typeof size?.followUpHint === "string" ? { followUpHint: size.followUpHint } : {},
+    ...offloadPath !== null ? { offloadPath } : {},
+    // Observation envelope counts (OBSERVE plane): unit, shown/total counts
+    // and bytes, format, exact continuation, offload path. Persisted with
+    // the turn so the ledger line renders identically live and on replay.
+    ...observation !== null ? { observation } : {}
+  };
+}
+function runtimeSupportsTools(agentRuntime) {
+  return agentRuntime.runtimeResolution.capabilityDecisions.tools === true;
+}
+function detectTerminalFailureFromState(agent) {
+  const msgs = agent.state.messages;
+  const tail = Array.isArray(msgs) ? msgs[msgs.length - 1] : void 0;
+  const failure = terminalFailureFromAssistantMessage(tail);
+  if (failure) return failure;
+  return null;
+}
+function pruneFailedAssistantFromContext(agent) {
+  const messages = agent.state.messages;
+  const tail = Array.isArray(messages) ? messages[messages.length - 1] : void 0;
+  if (!terminalFailureFromAssistantMessage(tail)) return;
+  agent.state.messages = messages.slice(0, -1);
+}
+function detectOverflowFromState(agent) {
+  const direct = agent.state.errorMessage;
+  if (typeof direct === "string" && direct.length > 0) {
+    const match = toContextOverflowError(direct);
+    if (match) return match;
+  }
+  const msgs = agent.state.messages;
+  const tail = Array.isArray(msgs) ? msgs[msgs.length - 1] : void 0;
+  if (tail && typeof tail === "object" && tail.stopReason === "error") {
+    const em = tail.errorMessage;
+    if (typeof em === "string") {
+      const match = toContextOverflowError(em);
+      if (match) return match;
+    }
+  }
+  return null;
+}
+
+// src/cli/modes/json-stream.ts
+function projectHeadlessJsonEvent(event) {
+  if (event.type === "message_update") return null;
+  if (event.type === "text_delta") {
+    return { type: event.type, contentIndex: event.contentIndex, delta: event.delta };
+  }
+  if (event.type === "thinking_delta") {
+    return { type: event.type, contentIndex: event.contentIndex, delta: event.delta };
+  }
+  if (event.type === "message_end") {
+    return { ...event, message: withoutStreamedContent(event.message) };
+  }
+  if (event.type === "agent_end") return segmentSummary(event.type, event.messages);
+  if (event.type === "turn_end") {
+    return { type: event.type, message: withoutStreamedContent(event.message) };
+  }
+  return event;
+}
+function withoutStreamedContent(message) {
+  if (!isRecord(message) || message.role !== "assistant" || !Array.isArray(message.content)) return message;
+  const content = message.content.map((block) => {
+    if (!isRecord(block)) return block;
+    if (block.type === "text" && typeof block.text === "string") {
+      const { text: _text, ...rest } = block;
+      return { ...rest, streamed: true, textLength: block.text.length };
+    }
+    if (block.type === "thinking" && typeof block.thinking === "string") {
+      const { thinking: _thinking, ...rest } = block;
+      return { ...rest, streamed: true, thinkingLength: block.thinking.length };
+    }
+    return block;
+  });
+  return { ...message, content };
+}
+function projectDispatchJsonEvent(event) {
+  if (!isRecord(event) || event.type !== "agent_end" || !Array.isArray(event.messages)) return event;
+  const { messages: _messages, ...rest } = event;
+  return { ...rest, ...segmentSummary("agent_end", event.messages) };
+}
+function segmentSummary(type, messages) {
+  const usage = sumRunUsage(messages);
+  return {
+    type,
+    messageCount: messages.length,
+    usage: {
+      input: usage.input,
+      output: usage.output,
+      cacheRead: usage.cacheRead,
+      cacheWrite: usage.cacheWrite,
+      reasoning: usage.reasoning,
+      totalTokens: usage.tokens,
+      costUsd: usage.costUsd,
+      apiCalls: usage.apiCalls,
+      measured: usage.hadUsage
+    }
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/core/file-references.ts
+init_esm_shims();
+import { existsSync, readFileSync, statSync as statSync2 } from "node:fs";
+import path2 from "node:path";
+
+// src/utils/image-resize.ts
+init_esm_shims();
+
+// src/utils/exif-orientation.ts
+init_esm_shims();
+function byte(bytes, offset) {
+  return bytes[offset] ?? 0;
+}
+function readOrientationFromTiff(bytes, tiffStart) {
+  if (tiffStart + 8 > bytes.length) return 1;
+  const byteOrder = byte(bytes, tiffStart) << 8 | byte(bytes, tiffStart + 1);
+  const le = byteOrder === 18761;
+  const read16 = (pos) => {
+    if (le) return byte(bytes, pos) | byte(bytes, pos + 1) << 8;
+    return byte(bytes, pos) << 8 | byte(bytes, pos + 1);
+  };
+  const read32 = (pos) => {
+    if (le) {
+      return byte(bytes, pos) | byte(bytes, pos + 1) << 8 | byte(bytes, pos + 2) << 16 | byte(bytes, pos + 3) << 24;
+    }
+    return (byte(bytes, pos) << 24 | byte(bytes, pos + 1) << 16 | byte(bytes, pos + 2) << 8 | byte(bytes, pos + 3)) >>> 0;
+  };
+  const ifdOffset = read32(tiffStart + 4);
+  const ifdStart = tiffStart + ifdOffset;
+  if (ifdStart + 2 > bytes.length) return 1;
+  const entryCount = read16(ifdStart);
+  for (let i = 0; i < entryCount; i++) {
+    const entryPos = ifdStart + 2 + i * 12;
+    if (entryPos + 12 > bytes.length) return 1;
+    if (read16(entryPos) === 274) {
+      const value = read16(entryPos + 8);
+      return value >= 1 && value <= 8 ? value : 1;
+    }
+  }
+  return 1;
+}
+function hasExifHeader(bytes, offset) {
+  return byte(bytes, offset) === 69 && byte(bytes, offset + 1) === 120 && byte(bytes, offset + 2) === 105 && byte(bytes, offset + 3) === 102 && byte(bytes, offset + 4) === 0 && byte(bytes, offset + 5) === 0;
+}
+function findJpegTiffOffset(bytes) {
+  let offset = 2;
+  while (offset < bytes.length - 1) {
+    if (byte(bytes, offset) !== 255) return -1;
+    const marker = byte(bytes, offset + 1);
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    if (marker === 225) {
+      if (offset + 4 >= bytes.length) return -1;
+      const segmentStart = offset + 4;
+      if (segmentStart + 6 > bytes.length) return -1;
+      if (!hasExifHeader(bytes, segmentStart)) return -1;
+      return segmentStart + 6;
+    }
+    if (offset + 4 > bytes.length) return -1;
+    const length = byte(bytes, offset + 2) << 8 | byte(bytes, offset + 3);
+    offset += 2 + length;
+  }
+  return -1;
+}
+function findWebpTiffOffset(bytes) {
+  let offset = 12;
+  while (offset + 8 <= bytes.length) {
+    const chunkId = String.fromCharCode(
+      byte(bytes, offset),
+      byte(bytes, offset + 1),
+      byte(bytes, offset + 2),
+      byte(bytes, offset + 3)
+    );
+    const chunkSize = byte(bytes, offset + 4) | byte(bytes, offset + 5) << 8 | byte(bytes, offset + 6) << 16 | byte(bytes, offset + 7) << 24;
+    const dataStart = offset + 8;
+    if (chunkId === "EXIF") {
+      if (dataStart + chunkSize > bytes.length) return -1;
+      return chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
+    }
+    offset = dataStart + chunkSize + chunkSize % 2;
+  }
+  return -1;
+}
+function getExifOrientation(bytes) {
+  let tiffOffset = -1;
+  if (bytes.length >= 2 && byte(bytes, 0) === 255 && byte(bytes, 1) === 216) {
+    tiffOffset = findJpegTiffOffset(bytes);
+  } else if (bytes.length >= 12 && byte(bytes, 0) === 82 && byte(bytes, 1) === 73 && byte(bytes, 2) === 70 && byte(bytes, 3) === 70 && byte(bytes, 8) === 87 && byte(bytes, 9) === 69 && byte(bytes, 10) === 66 && byte(bytes, 11) === 80) {
+    tiffOffset = findWebpTiffOffset(bytes);
+  }
+  if (tiffOffset === -1) return 1;
+  return readOrientationFromTiff(bytes, tiffOffset);
+}
+function rotate90(photon, image, dstIndex) {
+  const w = image.get_width();
+  const h = image.get_height();
+  const src = image.get_raw_pixels();
+  const dst = new Uint8Array(src.length);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const srcIdx = (y * w + x) * 4;
+      const dstIdx = dstIndex(x, y, w, h) * 4;
+      dst[dstIdx] = src[srcIdx] ?? 0;
+      dst[dstIdx + 1] = src[srcIdx + 1] ?? 0;
+      dst[dstIdx + 2] = src[srcIdx + 2] ?? 0;
+      dst[dstIdx + 3] = src[srcIdx + 3] ?? 0;
+    }
+  }
+  return new photon.PhotonImage(dst, h, w);
+}
+function applyExifOrientation(photon, image, originalBytes) {
+  const orientation = getExifOrientation(originalBytes);
+  if (orientation === 1) return image;
+  switch (orientation) {
+    case 2:
+      photon.fliph(image);
+      return image;
+    case 3:
+      photon.fliph(image);
+      photon.flipv(image);
+      return image;
+    case 4:
+      photon.flipv(image);
+      return image;
+    case 5: {
+      const rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+      photon.fliph(rotated);
+      return rotated;
+    }
+    case 6:
+      return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+    case 7: {
+      const rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+      photon.fliph(rotated);
+      return rotated;
+    }
+    case 8:
+      return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+    default:
+      return image;
+  }
+}
+
+// src/utils/photon.ts
+init_esm_shims();
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+var fs2 = require2("node:fs");
+var WASM_FILENAME = "photon_rs_bg.wasm";
+var photonModule = null;
+var loadPromise = null;
+function pathOrNull(file) {
+  if (typeof file === "string") return file;
+  if (file instanceof URL) return fileURLToPath(file);
+  return null;
+}
+function getFallbackWasmPaths() {
+  const execDir = path.dirname(process.execPath);
+  return [
+    path.join(execDir, WASM_FILENAME),
+    path.join(execDir, "photon", WASM_FILENAME),
+    path.join(process.cwd(), WASM_FILENAME)
+  ];
+}
+function patchPhotonWasmRead() {
+  const originalReadFileSync = fs2.readFileSync.bind(fs2);
+  const fallbackPaths = getFallbackWasmPaths();
+  const mutableFs = fs2;
+  const patchedReadFileSync = ((...args) => {
+    const [file, options] = args;
+    const resolvedPath = pathOrNull(file);
+    if (resolvedPath?.endsWith(WASM_FILENAME)) {
+      try {
+        return originalReadFileSync(...args);
+      } catch (error) {
+        const err = error;
+        if (err?.code && err.code !== "ENOENT") throw error;
+        for (const fallbackPath of fallbackPaths) {
+          if (!fs2.existsSync(fallbackPath)) continue;
+          if (options === void 0) return originalReadFileSync(fallbackPath);
+          return originalReadFileSync(fallbackPath, options);
+        }
+        throw error;
+      }
+    }
+    return originalReadFileSync(...args);
+  });
+  try {
+    mutableFs.readFileSync = patchedReadFileSync;
+  } catch {
+    Object.defineProperty(fs2, "readFileSync", {
+      value: patchedReadFileSync,
+      writable: true,
+      configurable: true
+    });
+  }
+  return () => {
+    try {
+      mutableFs.readFileSync = originalReadFileSync;
+    } catch {
+      Object.defineProperty(fs2, "readFileSync", {
+        value: originalReadFileSync,
+        writable: true,
+        configurable: true
+      });
+    }
+  };
+}
+async function loadPhoton() {
+  if (photonModule) return photonModule;
+  if (loadPromise) return loadPromise;
+  loadPromise = (async () => {
+    const restoreReadFileSync = patchPhotonWasmRead();
+    try {
+      photonModule = await import("@silvia-odwyer/photon-node");
+      return photonModule;
+    } catch {
+      photonModule = null;
+      return photonModule;
+    } finally {
+      restoreReadFileSync();
+    }
+  })();
+  return loadPromise;
+}
+
+// src/utils/image-resize.ts
+var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
+var DEFAULT_OPTIONS = {
+  maxWidth: 2e3,
+  maxHeight: 2e3,
+  maxBytes: DEFAULT_MAX_BYTES,
+  jpegQuality: 80
+};
+function encodeCandidate(buffer, mimeType) {
+  const data = Buffer.from(buffer).toString("base64");
+  return {
+    data,
+    encodedSize: Buffer.byteLength(data, "utf-8"),
+    mimeType
+  };
+}
+async function resizeImage(img, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const inputBuffer = Buffer.from(img.data, "base64");
+  const inputBase64Size = Buffer.byteLength(img.data, "utf-8");
+  const photon = await loadPhoton();
+  if (!photon) return null;
+  const loadedPhoton = photon;
+  let image;
+  try {
+    let tryEncodings2 = function(width, height, jpegQualities) {
+      const resized = loadedPhoton.resize(loadedImage, width, height, loadedPhoton.SamplingFilter.Lanczos3);
+      try {
+        const candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
+        for (const quality of jpegQualities) {
+          candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
+        }
+        return candidates;
+      } finally {
+        resized.free();
+      }
+    };
+    var tryEncodings = tryEncodings2;
+    const inputBytes = new Uint8Array(inputBuffer);
+    const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
+    image = applyExifOrientation(photon, rawImage, inputBytes);
+    if (image !== rawImage) rawImage.free();
+    const originalWidth = image.get_width();
+    const originalHeight = image.get_height();
+    const format = img.mimeType?.split("/")[1] ?? "png";
+    if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes) {
+      return {
+        data: img.data,
+        mimeType: img.mimeType ?? `image/${format}`,
+        originalWidth,
+        originalHeight,
+        width: originalWidth,
+        height: originalHeight,
+        wasResized: false
+      };
+    }
+    let targetWidth = originalWidth;
+    let targetHeight = originalHeight;
+    if (targetWidth > opts.maxWidth) {
+      targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth);
+      targetWidth = opts.maxWidth;
+    }
+    if (targetHeight > opts.maxHeight) {
+      targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight);
+      targetHeight = opts.maxHeight;
+    }
+    const loadedImage = image;
+    const qualitySteps = Array.from(/* @__PURE__ */ new Set([opts.jpegQuality, 85, 70, 55, 40]));
+    let currentWidth = targetWidth;
+    let currentHeight = targetHeight;
+    while (true) {
+      const candidates = tryEncodings2(currentWidth, currentHeight, qualitySteps);
+      for (const candidate of candidates) {
+        if (candidate.encodedSize < opts.maxBytes) {
+          return {
+            data: candidate.data,
+            mimeType: candidate.mimeType,
+            originalWidth,
+            originalHeight,
+            width: currentWidth,
+            height: currentHeight,
+            wasResized: true
+          };
+        }
+      }
+      if (currentWidth === 1 && currentHeight === 1) break;
+      const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
+      const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
+      if (nextWidth === currentWidth && nextHeight === currentHeight) break;
+      currentWidth = nextWidth;
+      currentHeight = nextHeight;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (image) image.free();
+  }
+}
+function formatDimensionNote(result2) {
+  if (!result2.wasResized) return void 0;
+  const scale = result2.originalWidth / result2.width;
+  return `[Image: original ${result2.originalWidth}x${result2.originalHeight}, displayed at ${result2.width}x${result2.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}
+
+// src/core/file-references.ts
+var FILE_REF = /(^|\s)@(\S+)/g;
+var DEFAULT_IMAGE_MAX_BASE64_BYTES = 4.5 * 1024 * 1024;
+function renderTextFile(filePath, content) {
+  return `<file name="${filePath}">
+${content}
+</file>
+`;
+}
+function renderImageFile(filePath, content = "") {
+  return `<file name="${filePath}">${content}</file>
+`;
+}
+function result(text, diagnostics = [], images = [], referencedPaths = []) {
+  return { text, diagnostics, images, referencedPaths };
+}
+function detectSupportedImageMimeType(bytes) {
+  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  const signature = bytes.subarray(0, 6).toString("ascii");
+  if (signature === "GIF87a" || signature === "GIF89a") return "image/gif";
+  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return null;
+}
+async function readFileReferenceAsync(fileArg, options) {
+  const filePath = expandConfigPath(fileArg, options.cwd === void 0 ? void 0 : { cwd: options.cwd });
+  if (!existsSync(filePath)) {
+    if (options.missing === "leave") return result(`@${fileArg}`);
+    return result("", [{ type: "error", message: `file not found: ${filePath}`, path: filePath }]);
+  }
+  let stat;
+  try {
+    stat = statSync2(filePath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return result("", [{ type: "error", message: `file could not be stat'ed: ${reason}`, path: filePath }]);
+  }
+  if (!stat.isFile()) {
+    return result("", [{ type: "error", message: `not a file: ${filePath}`, path: filePath }]);
+  }
+  if (stat.size === 0) return result("", [], [], [filePath]);
+  try {
+    const bytes = readFileSync(filePath);
+    const imageMimeType = detectSupportedImageMimeType(bytes);
+    if (imageMimeType) {
+      if (options.includeImages !== true) return result(`@${fileArg}`);
+      const originalImage = {
+        type: "image",
+        mimeType: imageMimeType,
+        data: bytes.toString("base64")
+      };
+      if (options.autoResizeImages === false) {
+        return result(renderImageFile(filePath), [], [originalImage], [filePath]);
+      }
+      const resized = await resizeImage(originalImage);
+      if (!resized) {
+        if (Buffer.byteLength(originalImage.data, "utf-8") < DEFAULT_IMAGE_MAX_BASE64_BYTES) {
+          return result(renderImageFile(filePath), [], [originalImage], [filePath]);
+        }
+        return result(
+          renderImageFile(filePath, "[Image omitted: could not be resized below the inline image size limit.]"),
+          [],
+          [],
+          [filePath]
+        );
+      }
+      return result(
+        renderImageFile(filePath, formatDimensionNote(resized)),
+        [],
+        [{ type: "image", mimeType: resized.mimeType, data: resized.data }],
+        [filePath]
+      );
+    }
+    return result(renderTextFile(filePath, bytes.toString("utf8")), [], [], [filePath]);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return result("", [{ type: "error", message: `file could not be read: ${reason}`, path: filePath }]);
+  }
+}
+async function readFileArgsAsync(fileArgs, options = {}) {
+  const diagnostics = [];
+  const images = [];
+  const referencedPaths = [];
+  let text = "";
+  for (const fileArg of fileArgs) {
+    const ref = await readFileReferenceAsync(fileArg, {
+      ...options,
+      missing: options.missing ?? "error",
+      includeImages: true
+    });
+    text += ref.text;
+    images.push(...ref.images);
+    diagnostics.push(...ref.diagnostics);
+    referencedPaths.push(...ref.referencedPaths);
+  }
+  return { text, images, diagnostics, referencedPaths };
+}
+function splitTrailingPunctuation(token) {
+  const match = token.match(/^(.+?)([),.;:!?]+)$/);
+  if (!match?.[1] || !match[2]) return { fileArg: token, suffix: "" };
+  const candidate = match[1];
+  const suffix = match[2];
+  const ext = path2.extname(candidate);
+  if (ext.length === 0 && suffix.startsWith(".")) return { fileArg: token, suffix: "" };
+  return { fileArg: candidate, suffix };
+}
+async function expandInlineFileReferencesAsync(input, options = {}) {
+  const diagnostics = [];
+  const images = [];
+  const referencedPaths = [];
+  let text = "";
+  let lastIndex = 0;
+  for (const match of input.matchAll(FILE_REF)) {
+    const index = match.index ?? 0;
+    const full = match[0] ?? "";
+    const prefix = match[1] ?? "";
+    const token = match[2] ?? "";
+    text += input.slice(lastIndex, index);
+    const direct = await readFileReferenceAsync(token, {
+      ...options,
+      missing: "leave",
+      includeImages: options.includeImages === true
+    });
+    if (direct.text !== `@${token}`) {
+      diagnostics.push(...direct.diagnostics);
+      images.push(...direct.images);
+      referencedPaths.push(...direct.referencedPaths);
+      text += `${prefix}${direct.text}`;
+      lastIndex = index + full.length;
+      continue;
+    }
+    const { fileArg, suffix } = splitTrailingPunctuation(token);
+    if (fileArg === token) {
+      text += full;
+      lastIndex = index + full.length;
+      continue;
+    }
+    const stripped = await readFileReferenceAsync(fileArg, {
+      ...options,
+      missing: "leave",
+      includeImages: options.includeImages === true
+    });
+    if (stripped.text === `@${fileArg}`) {
+      text += full;
+      lastIndex = index + full.length;
+      continue;
+    }
+    diagnostics.push(...stripped.diagnostics);
+    images.push(...stripped.images);
+    referencedPaths.push(...stripped.referencedPaths);
+    text += `${prefix}${stripped.text}${suffix}`;
+    lastIndex = index + full.length;
+  }
+  text += input.slice(lastIndex);
+  return { text, images, diagnostics, referencedPaths };
+}
+
+export {
+  toContextOverflowError,
+  notConfiguredNotice,
+  extractText,
+  extractUserText,
+  extractThinking,
+  terminalFailureFromAssistantMessage,
+  isSelfExplainingAbort,
+  isLengthStopAssistantMessage,
+  isEmptyAbortedAssistantMessage,
+  hasStructuredToolCall,
+  toolNamesFromAgentState,
+  noticeMessage,
+  pendingSkillRequestPreamble,
+  toolSignatureFromState,
+  fallbackIdentityPrompt,
+  createPendingSkillToolPolicy,
+  createAskUserToolPolicy,
+  sumRunUsage,
+  backendCacheVerdict,
+  assistantSessionPayload,
+  estimatedUsageForInterruptedTurn,
+  hasPersistableAssistantContent,
+  recordValue,
+  toolResultSummary,
+  runtimeSupportsTools,
+  detectTerminalFailureFromState,
+  pruneFailedAssistantFromContext,
+  detectOverflowFromState,
+  setupSteerChannel,
+  projectHeadlessJsonEvent,
+  projectDispatchJsonEvent,
+  readFileArgsAsync,
+  expandInlineFileReferencesAsync
+};
+//# sourceMappingURL=chunk-KJ5LWLOE.js.map