@namzu/cli 35.0.0 → 36.1.0

package/dist/chunks/chunk-C5XYHYMX.js

@@ -0,0 +1,675 @@
+import { createRequire as __namzuCreateRequire } from 'node:module';
+const require = __namzuCreateRequire(import.meta.url);
+import {
+  visibleProjectInstructionPath
+} from "./chunk-SGS435PR.js";
+import {
+  debugRequested
+} from "./chunk-GNBMKISG.js";
+import {
+  localEndpoint,
+  productName
+} from "./chunk-US5ZFPAU.js";
+import {
+  terminalDisplayText
+} from "./chunk-EEDZOGV4.js";
+import {
+  openConversationLog,
+  readConversationFacts
+} from "./chunk-TIGWWAJI.js";
+import {
+  __name
+} from "./chunk-76FLAFCG.js";
+
+// src/context/runtime-message.ts
+function runtimeContextLabel(kind) {
+  switch (kind) {
+    case "step-context":
+      return "Step context";
+    case "advisory":
+      return "Advisor context";
+    case "answer-review":
+      return "Answer review feedback";
+    case "auto-continuation":
+      return "Automatic continuation";
+    case "job-exit":
+      return "Background job exit";
+    case "limit-finalization":
+      return "Limit finalization request";
+    case "peer-message":
+      return "Message from another session";
+    case "host-observation":
+      return "Observed Pal activity";
+    case "channel-message":
+      return "Message from a connected channel";
+    case "peer-notice":
+      return "Notice from another session";
+    case "repeat-call":
+      return "Repeat-call advisory";
+    case "steering":
+      return "Runtime steering";
+    case "structured-output":
+      return "Structured-output retry";
+    case "task-completion":
+      return "Task completion context";
+  }
+}
+__name(runtimeContextLabel, "runtimeContextLabel");
+
+// src/tui/capability-notice.ts
+function describeCapabilityNotice(input) {
+  const name = productName(input.providerId) ?? "This provider";
+  if (input.contentSource === "tool-result") {
+    return input.capability === "documents" ? `${name} can\u2019t read documents, so Namzu gave it a text note in place of a document a tool returned. Switch to a provider that reads documents to include it.` : `${name} can\u2019t see images, so Namzu gave it a text note in place of a picture a tool returned. Switch to a provider that reads images to include it.`;
+  }
+  switch (input.capability) {
+    case "tools":
+      return `${name} can\u2019t use tools, so Namzu will only chat while you use it. Switch to another provider to let Namzu work with files and commands.`;
+    case "vision":
+      return `${name} can\u2019t see images, so it won\u2019t see the picture you attached. Switch to a provider that reads images to include it.`;
+    case "documents":
+      return `${name} can\u2019t read documents, so it won\u2019t see the file you attached. Switch to a provider that reads documents to include it.`;
+  }
+}
+__name(describeCapabilityNotice, "describeCapabilityNotice");
+function describeHistoryRepairNotice(input) {
+  if (input.source === "provider-rejected-image") {
+    const count = input.rejectedImages ?? 0;
+    const what = count > 1 ? `${count.toLocaleString("en-US")} pictures you attached` : "a picture you attached";
+    const name = productName(input.providerId);
+    return name ? `${name} didn\u2019t accept ${what}. Namzu kept the file but will leave it out of later messages. Attach a corrected copy to try again.` : `${what.charAt(0).toUpperCase()}${what.slice(1)} wasn\u2019t accepted. Namzu kept the file but will leave it out of later messages. Attach a corrected copy to try again.`;
+  }
+  if ((input.interruptedCalls ?? 0) > 0) {
+    return input.source === "abandoned-checkpoint" ? "Your last reply was cut off before its steps finished, so Namzu marked them as unfinished. Check any files or commands they touched before asking again." : "Some steps in this conversation never finished, so Namzu marked them as unfinished. Check any files or commands they touched before asking again.";
+  }
+  return "Namzu cleaned up some leftover steps from earlier in this conversation. Nothing you need to do.";
+}
+__name(describeHistoryRepairNotice, "describeHistoryRepairNotice");
+var FALLBACK_WHY = {
+  rate_limit: "was too busy",
+  overloaded: "was too busy",
+  server_error: "kept failing",
+  timeout: "did not answer in time",
+  network: "could not be reached",
+  auth: "did not accept the sign-in",
+  not_found: "does not have that model"
+};
+function describeProviderFallbackNotice(input) {
+  const from = productName(input.fromProviderId) ?? "The first provider";
+  const to = productName(input.toProviderId) ?? "another provider";
+  const why = FALLBACK_WHY[input.reason] ?? "could not answer";
+  return `${from} ${why}, so Namzu used ${to} for the rest of that reply.`;
+}
+__name(describeProviderFallbackNotice, "describeProviderFallbackNotice");
+function withDebugDetail(plain, raw, debug) {
+  return debug && raw.trim() !== "" ? `${plain}
+${raw}` : plain;
+}
+__name(withDebugDetail, "withDebugDetail");
+
+// src/integrations/sessions/transcript-export.ts
+import { randomUUID } from "node:crypto";
+import { link, open, stat, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+var ConversationTranscriptUnavailableError = class extends Error {
+  static {
+    __name(this, "ConversationTranscriptUnavailableError");
+  }
+  reason;
+  constructor(reason, detail) {
+    super(`Complete conversation export unavailable: ${detail}`);
+    this.name = "ConversationTranscriptUnavailableError";
+    this.reason = reason;
+  }
+};
+async function conversationMarkdown(sessions, sessionId) {
+  let facts;
+  try {
+    facts = await readConversationFacts(sessions, sessionId);
+  } catch (error) {
+    throw unavailable(
+      "log-unreadable",
+      `conversation ${sessionId} cannot be read strictly: ${messageOf(error)}`
+    );
+  }
+  if (!facts || facts.started.projectId !== sessions.projectId) {
+    throw unavailable("not-found", `conversation ${sessionId} is not in this workspace`);
+  }
+  const log = openConversationLog(sessions, sessionId);
+  const content = /* @__PURE__ */ __name(async (record) => {
+    const spill = record.spill;
+    return spill ? JSON.parse(await log.readSpill(spill)) : record.content;
+  }, "content");
+  const replacements = /* @__PURE__ */ new Map();
+  for (const record of facts.records) {
+    if (record.type === "message_replaced") {
+      replacements.set(record.targetMessageId, await content(record));
+    }
+  }
+  const lines = ["# Namzu conversation", "", `Conversation: \`${sessionId}\``, ""];
+  let turns = 0;
+  let current;
+  let produced = [];
+  const flush = /* @__PURE__ */ __name(() => {
+    if (produced.length > 0) lines.push(...renderProducedMessages(produced));
+    produced = [];
+  }, "flush");
+  for (const record of facts.records) {
+    switch (record.type) {
+      case "compaction":
+        flush();
+        if (record.strategy === "fork" && Array.isArray(record.summary)) {
+          turns += record.summary.filter(
+            (message) => message.role === "user" && (message.source === void 0 || message.source.type === "goal-round")
+          ).length;
+          lines.push(
+            "## Copied history",
+            "",
+            "_Copied from the conversation this one was forked from._",
+            ""
+          );
+          lines.push(...renderProducedMessages(record.summary));
+        } else {
+          lines.push(
+            "## Activity",
+            "",
+            `Context compacted (${record.trigger}): ${record.tokensBefore.toLocaleString()} \u2192 ${record.tokensAfter.toLocaleString()} tokens.`,
+            ""
+          );
+        }
+        break;
+      case "turn_started":
+        flush();
+        current = record.turnId;
+        turns += 1;
+        break;
+      case "message": {
+        const message = replacements.get(record.messageId) ?? await content(record);
+        if (record.kind === "prompt" && message.role === "user") {
+          flush();
+          lines.push(...renderUser(message), "");
+        } else produced.push(message);
+        break;
+      }
+      case "turn_completed":
+        flush();
+        if (record.stopReason && record.stopReason !== "end_turn") {
+          lines.push("## Activity", "", `Turn stopped: ${record.stopReason}.`, "");
+        }
+        current = void 0;
+        break;
+      case "turn_failed":
+        flush();
+        lines.push(
+          "## Activity",
+          "",
+          `Turn failed${record.failure ? ` [${record.failure.code}]` : ""}: ${record.error}`,
+          ""
+        );
+        current = void 0;
+        break;
+      case "turn_paused":
+        flush();
+        lines.push("## Activity", "", `Turn paused: ${record.reason}`, "");
+        break;
+      default: {
+        const activity = renderRecordedActivity(record, produced);
+        if (activity.length > 0) {
+          flush();
+          lines.push(...activity);
+        }
+      }
+    }
+  }
+  flush();
+  if (current !== void 0 && facts.activeTurn && !facts.activeTurn.paused) {
+    lines.push(
+      "## Activity",
+      "",
+      "This turn has not settled: it is still running, or its process stopped before it finished.",
+      ""
+    );
+  }
+  if (turns === 0 && !facts.records.some((record) => record.type === "compaction")) {
+    throw unavailable("nothing-to-export", `conversation ${sessionId} has no recorded turns`);
+  }
+  return { sessionId, turns, markdown: `${trimBlankTail(lines).join("\n")}
+` };
+}
+__name(conversationMarkdown, "conversationMarkdown");
+async function writeConversationExport(markdown, destination, cwd) {
+  const target = resolveExportPath(destination, cwd);
+  const parent = dirname(target);
+  let parentStat;
+  try {
+    parentStat = await stat(parent);
+  } catch (error) {
+    throw new Error(`Export directory is unavailable: ${parent} (${messageOf(error)})`);
+  }
+  if (!parentStat.isDirectory()) throw new Error(`Export parent is not a directory: ${parent}`);
+  const temporary = join(parent, `.${basename(target)}.tmp-${randomUUID()}`);
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 384);
+    await handle.writeFile(markdown, "utf-8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    try {
+      await link(temporary, target);
+    } catch (error) {
+      if (isCode(error, "EEXIST")) {
+        throw new Error(`Export target already exists; nothing was overwritten: ${target}`);
+      }
+      throw error;
+    }
+    return { path: target, bytes: Buffer.byteLength(markdown, "utf-8") };
+  } finally {
+    await handle?.close();
+    await unlink(temporary).catch((error) => {
+      if (!isCode(error, "ENOENT")) throw error;
+    });
+  }
+}
+__name(writeConversationExport, "writeConversationExport");
+function renderUser(user) {
+  if (user.source?.type === "goal-round") {
+    const source = user.source;
+    return [
+      `## Goal round ${source.round} / ${source.maxGoalRounds}`,
+      "",
+      `Objective: ${source.objective}`,
+      "",
+      "Model-visible continuation prompt:",
+      "",
+      user.content
+    ];
+  }
+  const lines = ["## User", "", user.content];
+  const attachments = user.attachments ?? [];
+  if (attachments.length > 0) {
+    lines.push(
+      "",
+      "Attachments:",
+      ...attachments.map((attachment) => `- ${attachmentLabel(attachment)}`)
+    );
+  }
+  return lines;
+}
+__name(renderUser, "renderUser");
+function renderProducedMessages(messages) {
+  const lines = [];
+  for (const message of messages) {
+    switch (message.role) {
+      case "assistant": {
+        if (typeof message.content === "string" && message.content.length > 0) {
+          lines.push("## Assistant", "", message.content, "");
+        }
+        if (message.citations && message.citations.length > 0) {
+          lines.push(
+            "### Citations",
+            "",
+            ...message.citations.flatMap((citation) => [
+              `- ${citation.documentTitle ?? `Document ${citation.documentIndex + 1}`} \u2014 ${citationLocation(citation.location)}`,
+              ...indentQuote(citation.citedText)
+            ]),
+            ""
+          );
+        }
+        for (const call of message.toolCalls ?? []) {
+          lines.push(
+            "## Activity",
+            "",
+            `Tool started: \`${call.function.name}\``,
+            "",
+            ...fence(call.function.arguments, "json"),
+            ""
+          );
+        }
+        break;
+      }
+      case "tool":
+        lines.push(
+          "## Activity",
+          "",
+          `Tool result for \`${message.toolCallId}\``,
+          "",
+          ...renderToolContent(message),
+          ""
+        );
+        break;
+      case "user":
+        if (message.source?.type === "project-instructions") {
+          lines.push(
+            "## Project instructions",
+            "",
+            ...message.source.files.map((file) => `- ${visibleProjectInstructionPath(file)}`),
+            "",
+            message.content,
+            ""
+          );
+        } else if (message.source?.type === "goal-round") {
+          lines.push(...renderUser(message), "");
+        } else if (message.source?.type === "runtime-context") {
+          lines.push(
+            `## Runtime context \u2014 ${runtimeContextLabel(message.source.kind)}`,
+            "",
+            message.content,
+            ""
+          );
+        } else lines.push("## User", "", message.content, "");
+        break;
+      case "system":
+        break;
+    }
+  }
+  return lines;
+}
+__name(renderProducedMessages, "renderProducedMessages");
+function renderRecordedActivity(record, produced) {
+  const represented = /* @__PURE__ */ __name((toolUseId) => produced.some(
+    (message) => message.role === "assistant" && (message.toolCalls ?? []).some((call) => call.id === toolUseId) || message.role === "tool" && message.toolCallId === toolUseId
+  ), "represented");
+  const lines = [];
+  const activity = /* @__PURE__ */ __name((text, detail, language = "") => {
+    lines.push("## Activity", "", text);
+    if (detail !== void 0 && detail.length > 0) lines.push("", ...fence(detail, language));
+    lines.push("");
+  }, "activity");
+  switch (record.type) {
+    case "tool_executing":
+      if (record.via || !represented(record.toolUseId)) {
+        activity(
+          `Nested tool started: \`${record.toolName}\`${record.via ? ` via \`${record.via.tool}\`` : ""}`,
+          jsonText(record.input),
+          "json"
+        );
+      }
+      break;
+    case "tool_completed":
+      if (record.via || !represented(record.toolUseId)) {
+        activity(
+          `Nested tool ${record.isError ? "failed" : "completed"}: \`${record.toolName}\`${record.outputTruncated ? " (output preview; full output was spilled)" : ""}`,
+          record.result
+        );
+      }
+      break;
+    case "provider_fallback":
+      activity(
+        describeProviderFallbackNotice({
+          fromProviderId: record.fromProviderId,
+          toProviderId: record.toProviderId,
+          reason: record.reason
+        })
+      );
+      break;
+    case "capability_warning":
+      activity(
+        describeCapabilityNotice({
+          capability: record.capability,
+          ...record.contentSource ? { contentSource: record.contentSource } : {},
+          providerId: record.providerId
+        })
+      );
+      break;
+    case "message_history_repaired":
+      activity(
+        describeHistoryRepairNotice({
+          source: record.source,
+          duplicateResults: record.duplicateToolResultsRemoved,
+          orphanedResults: record.orphanedToolResultsRemoved,
+          interruptedCalls: record.syntheticToolResultsInserted,
+          ...record.providerRejectedImagesSuppressed !== void 0 ? { rejectedImages: record.providerRejectedImagesSuppressed } : {}
+        })
+      );
+      break;
+    case "compaction_tool_results_cleared":
+      activity(
+        `Context relief cleared ${record.clearedCount} oversized tool result${record.clearedCount === 1 ? "" : "s"} (~${record.reclaimedTokens.toLocaleString()} tokens).`
+      );
+      break;
+    case "compaction_failed":
+      activity(`Context compaction did not change history (${record.cause}).`);
+      break;
+    case "guardrail_triggered":
+      activity(
+        `${record.stage === "input" ? "Input" : "Output"} guardrail ${record.action}${record.guardrail ? ` (${record.guardrail})` : ""}${record.reason ? `: ${record.reason}` : "."}`
+      );
+      break;
+    case "task_created":
+      activity(`Task ${record.status}: ${record.subject}`);
+      break;
+    case "task_updated":
+      if (record.deleted) activity(`Task removed: ${record.subject}`);
+      else if (record.status === "completed") activity(`Task completed: ${record.subject}`);
+      break;
+  }
+  return lines;
+}
+__name(renderRecordedActivity, "renderRecordedActivity");
+function renderToolContent(message) {
+  if (typeof message.content === "string") return fence(message.content);
+  const rendered = message.content.map((block) => {
+    if (block.type === "text") return block.text;
+    if (block.type === "image") return `[Image result: ${block.mediaType}; binary data omitted]`;
+    return `[Document result: ${block.name ?? "unnamed"} \xB7 ${block.mediaType}; binary data omitted]`;
+  });
+  return fence(rendered.join("\n"));
+}
+__name(renderToolContent, "renderToolContent");
+function attachmentLabel(attachment) {
+  if (attachment.type === "stored") {
+    return `${attachment.kind === "image" ? "Image" : "Document"}: ${attachment.name ?? "unnamed"} \xB7 ${attachment.mediaType} (stored reference; binary data omitted)`;
+  }
+  if (attachment.type === "document") {
+    return `Document: ${attachment.name ?? "unnamed"} \xB7 ${attachment.mediaType} (binary data omitted)`;
+  }
+  return `Image: ${attachment.mediaType} (binary data omitted)`;
+}
+__name(attachmentLabel, "attachmentLabel");
+function citationLocation(location) {
+  return `${location.kind} ${location.start}${location.end === location.start ? "" : `\u2013${location.end}`}`;
+}
+__name(citationLocation, "citationLocation");
+function indentQuote(text) {
+  return text.split("\n").map((line) => `  > ${line}`);
+}
+__name(indentQuote, "indentQuote");
+function fence(content, language = "") {
+  const longest = Math.max(0, ...[...content.matchAll(/`+/g)].map((match) => match[0].length));
+  const marker = "`".repeat(Math.max(3, longest + 1));
+  return [`${marker}${language}`, content, marker];
+}
+__name(fence, "fence");
+function jsonText(value) {
+  const encoded = JSON.stringify(value, null, 2);
+  return encoded === void 0 ? String(value) : encoded;
+}
+__name(jsonText, "jsonText");
+function trimBlankTail(lines) {
+  while (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+__name(trimBlankTail, "trimBlankTail");
+function resolveExportPath(destination, cwd) {
+  const expanded = destination === "~" ? homedir() : destination.startsWith("~/") ? join(homedir(), destination.slice(2)) : destination;
+  return resolve(cwd, expanded);
+}
+__name(resolveExportPath, "resolveExportPath");
+function unavailable(reason, detail) {
+  return new ConversationTranscriptUnavailableError(reason, detail);
+}
+__name(unavailable, "unavailable");
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+__name(messageOf, "messageOf");
+function isCode(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+__name(isCode, "isCode");
+
+// src/tui/model-choices.ts
+function isKnownFree(model) {
+  return model.inputPrice === 0 && model.outputPrice === 0;
+}
+__name(isKnownFree, "isKnownFree");
+function labelAlreadySaysFree(label) {
+  return /\bfree\b/i.test(label);
+}
+__name(labelAlreadySaysFree, "labelAlreadySaysFree");
+function modelStep(defaultModel, suppliedListing, suppliedCurrentModel, options = {}) {
+  const defaultAllowed = options.allowModel?.(defaultModel) !== false;
+  const currentModel = suppliedCurrentModel && options.allowModel?.(suppliedCurrentModel) === false ? void 0 : suppliedCurrentModel;
+  const listing = suppliedListing.kind === "ok" && options.allowModel ? {
+    ...suppliedListing,
+    models: suppliedListing.models.filter((model) => options.allowModel?.(model.id))
+  } : suppliedListing;
+  const fallback = /* @__PURE__ */ __name((notice) => {
+    const choices2 = defaultAllowed ? [{ id: defaultModel, label: defaultModel, note: "(namzu default)" }] : [];
+    if (currentModel && currentModel !== defaultModel) {
+      choices2.push({
+        id: currentModel,
+        label: currentModel,
+        note: "(current)"
+      });
+    }
+    return {
+      choices: choices2,
+      notice: choices2.length === 0 ? `${notice} No selectable models are available for this access path; choose another provider or enter a credential.` : notice,
+      initialIndex: Math.max(0, choices2.length - 1)
+    };
+  }, "fallback");
+  if (listing.kind === "unsupported") {
+    return fallback("This provider does not publish a model list. Showing namzu\u2019s pick for it.");
+  }
+  if (listing.kind === "timeout") {
+    const who = productName(options.providerId) ?? "The provider";
+    return fallback(
+      `${who} did not answer in time. Showing namzu\u2019s pick for it \u2014 try again to list.`
+    );
+  }
+  if (listing.kind === "failed") {
+    const localAt = localEndpoint(options.providerId, options.baseUrl);
+    const sentence = plainListingFailure(listing.cause ?? "unknown", {
+      name: productName(options.providerId) ?? "The provider",
+      keyEntryReachable: options.keyEntryReachable === true,
+      credentialGone: listing.failure === "credential-unavailable",
+      ...localAt !== void 0 ? { localAt } : {}
+    });
+    const raw = options.debug ?? debugRequested() ? ` Details: ${rawDetail(listing.reason)}` : "";
+    return fallback(`${sentence}${raw} Showing namzu\u2019s pick for it.`);
+  }
+  if (listing.models.length === 0) {
+    return fallback("The provider returned no models. Showing namzu\u2019s pick for it.");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const choices = [];
+  for (const m of listing.models) {
+    if (seen.has(m.id)) continue;
+    seen.add(m.id);
+    const notes = [];
+    if (m.id === defaultModel) notes.push("namzu default");
+    if (m.inputModalities?.includes("image")) notes.push("image input");
+    if (isKnownFree(m) && !labelAlreadySaysFree(m.name)) notes.push("free");
+    if (m.limitsVerified === false) notes.push("Limits not published yet");
+    choices.push({
+      id: m.id,
+      label: m.name,
+      ...notes.length > 0 ? { note: `(${notes.join(" \xB7 ")})` } : {},
+      ...m.group ? { group: m.group } : {}
+    });
+  }
+  if (!hasBothGroups(choices)) {
+    for (let i = 0; i < choices.length; i++) {
+      const c = choices[i];
+      if (c?.group !== "key") continue;
+      choices[i] = { ...c, note: withKeyNote(c.note) };
+    }
+  }
+  if (defaultAllowed && !seen.has(defaultModel)) {
+    choices.unshift({
+      id: defaultModel,
+      label: defaultModel,
+      note: "(namzu default)"
+    });
+  }
+  if (currentModel && currentModel !== defaultModel && !seen.has(currentModel)) {
+    choices.push({ id: currentModel, label: currentModel, note: "(current)" });
+  }
+  const wanted = currentModel ?? (defaultAllowed ? defaultModel : void 0);
+  const idx = choices.findIndex((c) => c.id === wanted);
+  return { choices, notice: null, initialIndex: idx >= 0 ? idx : 0 };
+}
+__name(modelStep, "modelStep");
+function hasBothGroups(choices) {
+  return choices.some((c) => c.group === "free") && choices.some((c) => c.group === "key");
+}
+__name(hasBothGroups, "hasBothGroups");
+function rowSection(choices, index) {
+  const group = choices[index]?.group;
+  if (group) return group;
+  for (let i = 0; i < index; i++) if (choices[i]?.group) return "other";
+  return void 0;
+}
+__name(rowSection, "rowSection");
+function sectionHeading(section) {
+  return section === "free" ? "Free" : section === "key" ? "API key" : "Other models";
+}
+__name(sectionHeading, "sectionHeading");
+function withKeyNote(note) {
+  const parts = note ? note.slice(1, -1).split(" \xB7 ") : [];
+  const at = parts.indexOf("Limits not published yet");
+  parts.splice(at < 0 ? parts.length : at, 0, "API key");
+  return `(${parts.join(" \xB7 ")})`;
+}
+__name(withKeyNote, "withKeyNote");
+function rawDetail(reason) {
+  const flat = terminalSafe(reason).replace(/\s*\(?\brequest[_ -]?id[:=]?\s*([\w.-]+)\)?/gi, " Request ID: $1").replace(/\s+/g, " ").trim();
+  const cut = flat.length > 300 ? `${flat.slice(0, 299)}\u2026` : flat;
+  return /[.!?…]$/.test(cut) ? cut : `${cut}.`;
+}
+__name(rawDetail, "rawDetail");
+function terminalSafe(text) {
+  return terminalDisplayText(text).replace(/\s+/g, " ").trim();
+}
+__name(terminalSafe, "terminalSafe");
+function plainListingFailure(cause, context) {
+  const { name } = context;
+  const newKey = context.keyEntryReachable ? "Press Esc, then k to enter a new key." : "Check the key in /setup.";
+  if (context.credentialGone) {
+    return `Namzu can no longer read the saved ${name} key. ${newKey}`;
+  }
+  switch (cause) {
+    case "rejected":
+      return `${name} rejected the saved API key. ${newKey}`;
+    case "forbidden":
+      return `${name} does not let this key list models. ${newKey}`;
+    case "limited":
+      return `${name} is limiting requests right now. Wait a moment, then open the list again.`;
+    case "server":
+      return `${name} is having problems on its side. Try again in a minute.`;
+    case "network":
+      return context.localAt ? `Namzu could not reach ${name} at ${context.localAt}. Start it, then try again.` : `Namzu could not reach ${name}. Check your internet connection, then try again.`;
+    case "unknown":
+      return `Namzu could not list models from ${name}. Run with --debug for details.`;
+  }
+}
+__name(plainListingFailure, "plainListingFailure");
+
+export {
+  runtimeContextLabel,
+  describeCapabilityNotice,
+  describeHistoryRepairNotice,
+  withDebugDetail,
+  conversationMarkdown,
+  writeConversationExport,
+  modelStep,
+  hasBothGroups,
+  rowSection,
+  sectionHeading,
+  withKeyNote,
+  rawDetail
+};
+//# sourceMappingURL=chunk-C5XYHYMX.js.map