@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-MATCRH3M.js

@@ -0,0 +1,667 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  canonicalJson,
+  sha256
+} from "./chunk-FB3KTE2J.js";
+import {
+  addResponseModelIdObservationCount,
+  emptyResponseModelIdObservationCounts,
+  responseModelIdObservationFromRecord
+} from "./chunk-BIY22UUK.js";
+import {
+  uncachedPrefillTokens
+} from "./chunk-QH3ZTUOA.js";
+import {
+  ceilChars,
+  extractReasoningTokens
+} from "./chunk-OPC4DQD6.js";
+import {
+  isEngineContextOverflow
+} from "./chunk-QLAGXTTV.js";
+import {
+  settingsPath
+} from "./chunk-PGEFOTJB.js";
+import {
+  ToolNames
+} from "./chunk-WLHX3MM5.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/steer-channel.ts
+init_esm_shims();
+import * as fs from "node:fs";
+import { Socket } from "node:net";
+import * as readline from "node:readline";
+function setupSteerChannel(filePath, onLine) {
+  let closed = false;
+  let watcher = null;
+  let stream = null;
+  let rl = null;
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    watcher?.close();
+    rl?.close();
+    stream?.destroy();
+  };
+  const reportError = (err) => {
+    if (closed) return;
+    process.stderr.write(
+      `clio-coder run: failed to setup steer channel: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    cleanup();
+  };
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.isFIFO()) {
+      const fd = fs.openSync(filePath, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+      try {
+        stream = new Socket({ fd, readable: true, writable: false });
+      } catch (err) {
+        fs.closeSync(fd);
+        throw err;
+      }
+      stream.on("error", reportError);
+      rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+      rl.on("error", reportError);
+      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) {
+    reportError(err);
+  }
+  return cleanup;
+}
+
+// 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/prompt-cache-identity.ts
+init_esm_shims();
+function attachedToolSchemasFromState(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
+    });
+  }
+  return schemas;
+}
+function attachedToolSchemaBytes(schemas) {
+  try {
+    const bytes = JSON.stringify(schemas);
+    if (bytes === void 0) throw new Error("JSON.stringify returned undefined");
+    return bytes;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`attached tool schemas are not JSON-serializable: ${reason}`, { cause: err });
+  }
+}
+function mainPromptCacheIdentity(input) {
+  return sha256(
+    canonicalJson({
+      version: 2,
+      targetId: input.targetId,
+      runtimeId: input.runtimeId,
+      wireModelId: input.wireModelId,
+      autonomy: input.autonomy,
+      sessionId: input.sessionId,
+      cwd: input.cwd,
+      workingContextPaths: [...input.workingContextPaths].sort((a, b) => a.localeCompare(b)),
+      contextWindowSource: input.contextWindowSource,
+      promptInputEpoch: input.promptInputEpoch,
+      sessionInputs: input.sessionInputs,
+      attachedToolSchemaBytes: attachedToolSchemaBytes(input.attachedToolSchemas)
+    })
+  );
+}
+
+// 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;
+  if (extractThinking(message).trim().length > 0) return false;
+  return !hasStructuredToolCall(message);
+}
+function explainInterruptedAssistant(message, reason) {
+  if (reason === null || message.role !== "assistant" || message.stopReason !== "aborted") return false;
+  message.errorMessage = reason;
+  return true;
+}
+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) {
+  return sha256(attachedToolSchemaBytes(attachedToolSchemasFromState(tools)));
+}
+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,
+    exposure: "local",
+    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,
+    responseModelIdObservationCounts: emptyResponseModelIdObservationCounts(),
+    lastResponseModelIdObservation: { state: "not-observed" },
+    lastDifferingResponseModelId: null
+  };
+  for (const raw of messages) {
+    const message = raw;
+    if (!message || typeof message !== "object") continue;
+    if (message.role !== "assistant") continue;
+    const record = message;
+    const usage = message.usage;
+    if (!usage || typeof usage !== "object") continue;
+    summary.lastResponseModelIdObservation = responseModelIdObservationFromRecord(record, "not-observed");
+    addResponseModelIdObservationCount(summary.responseModelIdObservationCounts, summary.lastResponseModelIdObservation);
+    summary.lastDifferingResponseModelId = typeof record.responseModel === "string" && record.responseModel.trim().length > 0 ? record.responseModel.trim() : null;
+    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;
+    if (typeof usage.cacheWrite1h === "number") summary.cacheWrite1h = (summary.cacheWrite1h ?? 0) + usage.cacheWrite1h;
+    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 classifyCacheUsage(input, cacheRead) {
+  if (cacheRead > 0) return input >= 2e3 ? "partial" : "hot";
+  return input >= 2e3 ? "cold" : "small";
+}
+function backendCacheVerdict(input, cacheRead, backend) {
+  if (cacheRead === 0 && backend?.cachedTokens !== null && backend?.cachedTokens !== void 0) {
+    const backendInput = uncachedPrefillTokens(backend);
+    if (backendInput !== null) return classifyCacheUsage(backendInput, backend.cachedTokens);
+  }
+  return classifyCacheUsage(input, cacheRead);
+}
+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;
+  payload.responseModelIdObservation = responseModelIdObservationFromRecord(raw, "not-observed");
+  for (const key of [
+    "usage",
+    "api",
+    "provider",
+    "model",
+    "responseModel",
+    "responseId",
+    "providerThinkingLevel",
+    "gatewayRouting",
+    "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(result) {
+  const obj = recordValue(result);
+  const text = textFromToolResultContent(obj?.content) || (typeof result === "string" ? result : "");
+  const bytes = Buffer.byteLength(text, "utf8");
+  const details = recordValue(obj?.details);
+  const size = recordValue(details?.resultSize);
+  const disposition = recordValue(details?.resultDisposition);
+  const truncation = recordValue(details?.truncation);
+  const observation = recordValue(details?.observation);
+  const offloadPath = typeof disposition?.offloadPath === "string" ? disposition.offloadPath : typeof observation?.offloadPath === "string" ? observation.offloadPath : typeof size?.offloadPath === "string" ? size.offloadPath : null;
+  const displayedBytes = typeof disposition?.displayedBytes === "number" && Number.isFinite(disposition.displayedBytes) ? disposition.displayedBytes : bytes;
+  return {
+    bytes: displayedBytes,
+    truncated: disposition?.presentationTruncated === true || size?.truncated === true || truncation?.truncated === true || observation?.truncated === true || text.includes("[tool result truncated]"),
+    ...typeof disposition?.capturedBytes === "number" ? { capturedBytes: disposition.capturedBytes } : {},
+    ...typeof disposition?.displayedBytes === "number" ? { displayedBytes: disposition.displayedBytes } : {},
+    ...typeof disposition?.contextBytes === "number" ? { contextBytes: disposition.contextBytes } : {},
+    ...disposition?.contextTruncated === true ? { contextTruncated: true } : {},
+    ...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);
+}
+
+export {
+  toContextOverflowError,
+  attachedToolSchemasFromState,
+  mainPromptCacheIdentity,
+  notConfiguredNotice,
+  extractText,
+  extractUserText,
+  extractThinking,
+  terminalFailureFromAssistantMessage,
+  isSelfExplainingAbort,
+  isLengthStopAssistantMessage,
+  isEmptyAbortedAssistantMessage,
+  explainInterruptedAssistant,
+  hasStructuredToolCall,
+  toolNamesFromAgentState,
+  noticeMessage,
+  pendingSkillRequestPreamble,
+  toolSignatureFromState,
+  fallbackIdentityPrompt,
+  createPendingSkillToolPolicy,
+  createAskUserToolPolicy,
+  sumRunUsage,
+  backendCacheVerdict,
+  assistantSessionPayload,
+  estimatedUsageForInterruptedTurn,
+  hasPersistableAssistantContent,
+  recordValue,
+  toolResultSummary,
+  runtimeSupportsTools,
+  detectTerminalFailureFromState,
+  pruneFailedAssistantFromContext,
+  detectOverflowFromState,
+  setupSteerChannel,
+  projectHeadlessJsonEvent,
+  projectDispatchJsonEvent
+};
+//# sourceMappingURL=chunk-MATCRH3M.js.map