arcie 0.1.4 → 0.1.5

package/dist/dev-ZZDVOWUZ.js

@@ -0,0 +1,1967 @@
+import {
+  EMPTY_LINE,
+  LiveRegion,
+  PromptHistory,
+  applyLineEditorKey,
+  attachKeyStream,
+  createTheme,
+  detectUnicode,
+  inputTextWidth,
+  sliceVisible,
+  stripTerminalControls,
+  visibleLength,
+  visibleLine,
+  wrapVisibleLine
+} from "./chunk-HWD2Z2CH.js";
+import {
+  dimmed,
+  grey
+} from "./chunk-N5R3TEEZ.js";
+import {
+  showHeader
+} from "./chunk-XOFWQUOO.js";
+import {
+  streamAgent
+} from "./chunk-4WSILP75.js";
+import {
+  loadAgent
+} from "./chunk-KVSX4MLK.js";
+import {
+  discoverAgent
+} from "./chunk-6XETPLIF.js";
+import "./chunk-QE46QFID.js";
+import "./chunk-PHTJLJOV.js";
+
+// src/cli/dev.ts
+import { createServer } from "http";
+import { resolve } from "path";
+
+// src/cli/tui/renderer/start-block-chat.ts
+import { watch } from "fs";
+
+// src/cli/tui/prompt-commands.ts
+var PROMPT_COMMAND_DEFINITIONS = [
+  {
+    name: "help",
+    aliases: [],
+    description: "Show available commands",
+    takesArgument: false,
+    build: () => ({ type: "help" })
+  },
+  {
+    name: "new",
+    aliases: [],
+    description: "Start a fresh session",
+    takesArgument: false,
+    build: () => ({ type: "new" })
+  },
+  {
+    name: "clear",
+    aliases: [],
+    description: "Clear the screen",
+    takesArgument: false,
+    build: () => ({ type: "clear" })
+  },
+  {
+    name: "model",
+    aliases: [],
+    description: "Configure the agent's model and provider",
+    argumentHint: "[provider/model]",
+    takesArgument: true,
+    build: (argument) => ({ type: "extension", name: "model", argument })
+  },
+  {
+    name: "provider",
+    aliases: [],
+    description: "Configure provider API keys",
+    takesArgument: false,
+    build: () => ({ type: "extension", name: "provider", argument: "" })
+  },
+  {
+    name: "channels",
+    aliases: [],
+    description: "Add chat channels to the agent",
+    takesArgument: false,
+    build: () => ({ type: "extension", name: "channels", argument: "" })
+  },
+  {
+    name: "loglevel",
+    aliases: [],
+    description: "Show or hide captured stdout/stderr logs",
+    argumentHint: "[all|stderr|none]",
+    takesArgument: true,
+    build: (argument) => ({ type: "loglevel", argument })
+  },
+  {
+    name: "exit",
+    aliases: ["quit"],
+    description: "Quit the TUI",
+    takesArgument: false,
+    build: () => ({ type: "exit" })
+  }
+];
+var PROMPT_COMMANDS = PROMPT_COMMAND_DEFINITIONS;
+function parsePromptCommand(prompt) {
+  const trimmed = prompt.trim();
+  if (!trimmed.startsWith("/")) return null;
+  for (const spec of PROMPT_COMMANDS) {
+    for (const alias of [spec.name, ...spec.aliases]) {
+      const token = `/${alias}`;
+      if (trimmed === token) return spec.build("");
+      if (spec.takesArgument && trimmed.startsWith(`${token} `)) {
+        return spec.build(trimmed.slice(token.length).trim());
+      }
+    }
+  }
+  return null;
+}
+function isPromptControlCommand(prompt) {
+  return parsePromptCommand(prompt) !== null;
+}
+function formatPromptCommandHelp(commands = PROMPT_COMMANDS) {
+  const entries = commands.map((spec) => {
+    const hint = spec.argumentHint === void 0 ? "" : ` ${spec.argumentHint}`;
+    const aliases = spec.aliases.map((alias) => ` (/${alias})`).join("");
+    return { invocation: `/${spec.name}${hint}${aliases}`, description: spec.description };
+  });
+  const column = Math.max(...entries.map((entry) => entry.invocation.length)) + 2;
+  return entries.map((entry) => entry.invocation.padEnd(column) + entry.description).join("\n");
+}
+function matchingCommands(commands, text) {
+  if (!text.startsWith("/") || /\s/.test(text)) return [];
+  const rest = text.slice(1);
+  return commands.filter(
+    (spec) => [spec.name, ...spec.aliases].some((token) => token.startsWith(rest))
+  );
+}
+
+// src/cli/tui/tool-format.ts
+var ELLIPSIS = "\u2026";
+function summarizeToolArgs(input, maxLength = 80) {
+  if (input === void 0 || input === null) return "";
+  if (typeof input !== "object") return truncate(formatScalar(input), maxLength);
+  if (Array.isArray(input)) return truncate(`[${input.length}]`, maxLength);
+  const entries = Object.entries(input);
+  if (entries.length === 0) return "";
+  const parts = [];
+  for (const [key, value] of entries) {
+    parts.push(`${stripTerminalControls(key)}=${formatInlineValue(value)}`);
+  }
+  return truncate(parts.join("  "), maxLength);
+}
+function summarizeToolResult(output, maxLength = 80) {
+  if (output === void 0 || output === null) return "";
+  if (typeof output === "string") {
+    const firstLine = output.split("\n").find((line) => line.trim().length > 0) ?? "";
+    return truncate(firstLine.trim(), maxLength);
+  }
+  if (typeof output !== "object") return truncate(formatScalar(output), maxLength);
+  if (Array.isArray(output)) {
+    return truncate(`${output.length} ${output.length === 1 ? "item" : "items"}`, maxLength);
+  }
+  const record = output;
+  for (const key of ["result", "text", "message", "summary", "value", "output"]) {
+    const value = record[key];
+    if (value !== void 0 && typeof value !== "object") {
+      return truncate(`${formatScalar(value)}`, maxLength);
+    }
+  }
+  const keys = Object.keys(record);
+  if (keys.length === 0) return "{}";
+  const inline = keys.slice(0, 3).map((key) => `${key}=${formatInlineValue(record[key])}`).join("  ");
+  return truncate(keys.length > 3 ? `${inline}  ${ELLIPSIS}` : inline, maxLength);
+}
+function formatValuePretty(value) {
+  if (typeof value === "string") return stripTerminalControls(value);
+  try {
+    return stripTerminalControls(JSON.stringify(value, null, 2) ?? String(value));
+  } catch {
+    return stripTerminalControls(String(value));
+  }
+}
+function formatInlineValue(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "string") return `"${truncate(value, 32)}"`;
+  if (typeof value === "object") {
+    return Array.isArray(value) ? `[${value.length}]` : "{\u2026}";
+  }
+  return formatScalar(value);
+}
+function formatScalar(value) {
+  if (typeof value === "string") return stripTerminalControls(value);
+  return stripTerminalControls(String(value));
+}
+function truncate(text, maxLength) {
+  const collapsed = stripTerminalControls(text).replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxLength) return collapsed;
+  return `${collapsed.slice(0, Math.max(0, maxLength - 1)).trimEnd()}${ELLIPSIS}`;
+}
+
+// src/cli/tui/renderer/event-to-blocks.ts
+var EventTranslator = class {
+  #autoCollapseReasoning;
+  #nextId = 0;
+  #currentAssistantId;
+  #currentReasoningId;
+  #toolIds = /* @__PURE__ */ new Map();
+  #subagentStack = [];
+  constructor(options = {}) {
+    this.#autoCollapseReasoning = options.autoCollapseReasoning ?? true;
+  }
+  get depth() {
+    return this.#subagentStack.length;
+  }
+  reset() {
+    const ops = [];
+    if (this.#currentAssistantId !== void 0) {
+      ops.push({ type: "end-live", id: this.#currentAssistantId });
+    }
+    if (this.#currentReasoningId !== void 0) {
+      ops.push({ type: "end-live", id: this.#currentReasoningId });
+    }
+    for (const [, id] of this.#toolIds) ops.push({ type: "end-live", id });
+    for (const id of this.#subagentStack) ops.push({ type: "end-live", id });
+    this.#currentAssistantId = void 0;
+    this.#currentReasoningId = void 0;
+    this.#toolIds.clear();
+    this.#subagentStack = [];
+    return ops;
+  }
+  feed(event) {
+    switch (event.type) {
+      case "session.started":
+      case "session.waiting":
+      case "session.completed":
+      case "turn.started":
+      case "turn.completed":
+      case "step.started":
+      case "step.completed":
+        return [];
+      case "message.received":
+        return this.#onUserMessage(event.data.message);
+      case "message.appended":
+        return this.#onAssistantDelta(event.data.delta);
+      case "message.completed":
+        return this.#endAssistant(event.data.text ?? void 0);
+      case "reasoning.appended":
+        return this.#onReasoningDelta(event.data.delta);
+      case "reasoning.completed":
+        return this.#endReasoning(event.data.text);
+      case "tool.started":
+        return this.#onToolStarted(event.data.name, event.data.callId, event.data.input);
+      case "tool.completed":
+        return this.#onToolCompleted(
+          event.data.callId,
+          event.data.status,
+          event.data.output,
+          event.data.error?.message,
+          event.data.error?.code
+        );
+      case "subagent.called":
+        return this.#onSubagentCalled(event.data.name, event.data.callId);
+      case "subagent.completed":
+        return this.#onSubagentCompleted(event.data.callId, event.data.output);
+      case "step.failed":
+      case "turn.failed":
+      case "session.failed":
+        return this.#onFailure(event.data.code, event.data.message);
+    }
+  }
+  #id(prefix) {
+    this.#nextId += 1;
+    return `${prefix}-${this.#nextId}`;
+  }
+  #onUserMessage(message) {
+    const ops = this.#closeReasoningIfLive();
+    ops.push({
+      type: "commit",
+      block: { kind: "user", body: message, depth: this.depth }
+    });
+    return ops;
+  }
+  #onAssistantDelta(delta) {
+    const ops = this.#closeReasoningIfLive();
+    if (this.#currentAssistantId === void 0) {
+      const id = this.#id("assistant");
+      this.#currentAssistantId = id;
+      ops.push({
+        type: "start-live",
+        block: this.#assistantKind({ kind: "assistant", id, body: delta, live: true, depth: this.depth })
+      });
+    } else {
+      ops.push({
+        type: "update-live",
+        id: this.#currentAssistantId,
+        patch: withDelta(delta)
+      });
+    }
+    return ops;
+  }
+  #endAssistant(text) {
+    const ops = [];
+    if (this.#currentAssistantId === void 0) return ops;
+    if (text !== void 0 && text.length > 0) {
+      ops.push({
+        type: "update-live",
+        id: this.#currentAssistantId,
+        patch: { body: text, live: false }
+      });
+    } else {
+      ops.push({
+        type: "update-live",
+        id: this.#currentAssistantId,
+        patch: { live: false }
+      });
+    }
+    ops.push({ type: "end-live", id: this.#currentAssistantId });
+    this.#currentAssistantId = void 0;
+    return ops;
+  }
+  #onReasoningDelta(delta) {
+    const ops = [];
+    if (this.#currentReasoningId === void 0) {
+      const id = this.#id("reasoning");
+      this.#currentReasoningId = id;
+      ops.push({
+        type: "start-live",
+        block: this.#assistantKind({
+          kind: "reasoning",
+          id,
+          body: delta,
+          live: true,
+          collapsed: false,
+          depth: this.depth
+        })
+      });
+    } else {
+      ops.push({
+        type: "update-live",
+        id: this.#currentReasoningId,
+        patch: withDelta(delta)
+      });
+    }
+    return ops;
+  }
+  #endReasoning(text) {
+    const ops = [];
+    if (this.#currentReasoningId === void 0) return ops;
+    ops.push({
+      type: "update-live",
+      id: this.#currentReasoningId,
+      patch: { body: text, live: false, collapsed: this.#autoCollapseReasoning }
+    });
+    ops.push({ type: "end-live", id: this.#currentReasoningId });
+    this.#currentReasoningId = void 0;
+    return ops;
+  }
+  #closeReasoningIfLive() {
+    if (this.#currentReasoningId === void 0 || !this.#autoCollapseReasoning) return [];
+    const id = this.#currentReasoningId;
+    this.#currentReasoningId = void 0;
+    return [
+      { type: "update-live", id, patch: { collapsed: true, live: false } },
+      { type: "end-live", id }
+    ];
+  }
+  #onToolStarted(name, callId, input) {
+    const id = this.#id("tool");
+    this.#toolIds.set(callId, id);
+    const inSubagent = this.depth > 0;
+    const args = summarizeToolArgs(input, 80);
+    return [
+      {
+        type: "start-live",
+        block: {
+          kind: inSubagent ? "subagent-tool" : "tool",
+          id,
+          title: name,
+          subtitle: args,
+          toolInput: input,
+          status: "running",
+          live: true,
+          depth: this.depth
+        }
+      }
+    ];
+  }
+  #onToolCompleted(callId, status, output, errorMessage, errorCode) {
+    const id = this.#toolIds.get(callId);
+    if (id === void 0) return [];
+    const isApproval = status === "pending" && errorCode === "needs_approval";
+    if (isApproval) {
+      return [
+        {
+          type: "update-live",
+          id,
+          patch: {
+            status: "approval",
+            result: errorMessage ?? "awaiting approval"
+          }
+        }
+      ];
+    }
+    this.#toolIds.delete(callId);
+    const ok = status === "completed";
+    const patch = {
+      status: ok ? "done" : "error",
+      toolOutput: ok ? output : void 0,
+      result: ok ? summarizeToolResult(output, 80) : errorMessage ?? "failed",
+      live: false
+    };
+    return [
+      { type: "update-live", id, patch },
+      { type: "end-live", id }
+    ];
+  }
+  #onSubagentCalled(name, callId) {
+    const id = this.#id("subagent");
+    this.#subagentStack.push(id);
+    return [
+      {
+        type: "commit",
+        block: {
+          kind: "subagent",
+          id,
+          title: name,
+          depth: this.depth - 1
+        }
+      }
+    ];
+  }
+  #onSubagentCompleted(_callId, output) {
+    if (this.#subagentStack.length === 0) return [];
+    this.#subagentStack.pop();
+    if (output && output.length > 0) {
+      return [
+        {
+          type: "commit",
+          block: {
+            kind: "subagent-step",
+            body: output,
+            depth: this.depth
+          }
+        }
+      ];
+    }
+    return [];
+  }
+  #onFailure(code, message) {
+    return [
+      {
+        type: "commit",
+        block: {
+          kind: "error",
+          title: code,
+          body: message,
+          depth: this.depth
+        }
+      }
+    ];
+  }
+  #assistantKind(block) {
+    return this.depth > 0 && block.kind === "assistant" ? { ...block, kind: "subagent-step" } : block;
+  }
+};
+var DELTA_KEY = "__delta";
+function withDelta(delta) {
+  return { [DELTA_KEY]: delta };
+}
+function createBlockStore() {
+  const live = /* @__PURE__ */ new Map();
+  let justCommitted = [];
+  return {
+    get live() {
+      return live;
+    },
+    get justCommitted() {
+      return justCommitted;
+    },
+    apply(op) {
+      switch (op.type) {
+        case "commit":
+          justCommitted.push(op.block);
+          return;
+        case "start-live":
+          if (op.block.id === void 0) return;
+          live.set(op.block.id, op.block);
+          return;
+        case "update-live": {
+          const existing = live.get(op.id);
+          if (existing === void 0) return;
+          const patch = op.patch;
+          const delta = patch[DELTA_KEY];
+          const rest = { ...patch };
+          delete rest[DELTA_KEY];
+          const merged = { ...existing, ...rest };
+          if (delta !== void 0) merged.body = `${existing.body ?? ""}${delta}`;
+          live.set(op.id, merged);
+          return;
+        }
+        case "end-live": {
+          const existing = live.get(op.id);
+          if (existing === void 0) return;
+          live.delete(op.id);
+          justCommitted.push({ ...existing, live: false });
+          return;
+        }
+        case "clear-live":
+          live.delete(op.id);
+          return;
+      }
+    },
+    drainCommitted() {
+      const out = justCommitted;
+      justCommitted = [];
+      return out;
+    }
+  };
+}
+
+// src/cli/tui/markdown.ts
+var ansi = {
+  bold: "\x1B[1m",
+  boldOff: "\x1B[22m",
+  italic: "\x1B[3m",
+  italicOff: "\x1B[23m"
+};
+var tableSeparator = "\u2500";
+function renderMarkdown(input) {
+  const lines = input.split("\n");
+  const output = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const table = parseTable(lines, index);
+    if (table != null) {
+      output.push(...renderTable(table));
+      index = table.endIndex - 1;
+      continue;
+    }
+    output.push(renderMarkdownLine(lines[index] ?? ""));
+  }
+  return output.join("\n");
+}
+function renderMarkdownLine(line) {
+  if (line.startsWith("### ")) return renderInlineMarkdown(`\u25B6 ${line.slice(4)}`);
+  if (line.startsWith("## ")) return renderInlineMarkdown(`\u25A0 ${line.slice(3)}`);
+  if (line.startsWith("# ")) return renderInlineMarkdown(`\u2588 ${line.slice(2)}`);
+  const unorderedListItem = line.match(/^(\s*)[-+*]\s+(.*)$/);
+  if (unorderedListItem) {
+    const [, indentation, text = ""] = unorderedListItem;
+    return renderInlineMarkdown(`${indentation}\u2022${text.length > 0 ? ` ${text}` : ""}`);
+  }
+  if (/^\d+\. /.test(line)) return renderInlineMarkdown(line.replace(/^(\d+)\. /, "$1. "));
+  if (line.startsWith("> ")) return renderInlineMarkdown(`\u2502 ${line.slice(2)}`);
+  return renderInlineMarkdown(line);
+}
+function renderInlineMarkdown(input) {
+  const urls = [];
+  const shielded = input.replaceAll(/https?:\/\/\S+/g, (match) => {
+    const token = `${urls.length}`;
+    urls.push(match);
+    return token;
+  });
+  const styled = shielded.replaceAll(/`([^`]+)`/g, "$1").replaceAll(/\*\*([^*\n]+)\*\*/g, `${ansi.bold}$1${ansi.boldOff}`).replaceAll(/__([^_\n]+)__/g, `${ansi.bold}$1${ansi.boldOff}`).replaceAll(/\*([^*\n]+)\*/g, `${ansi.italic}$1${ansi.italicOff}`).replaceAll(/_([^_\n]+)_/g, `${ansi.italic}$1${ansi.italicOff}`);
+  return styled.replaceAll(/(\d+)/g, (_match, index) => urls[Number(index)] ?? "");
+}
+function parseTable(lines, startIndex) {
+  const header = parseTableCells(lines[startIndex] ?? "");
+  if (header == null || header.length < 2) return void 0;
+  const separatorCells = parseTableCells(lines[startIndex + 1] ?? "");
+  if (separatorCells == null || separatorCells.length !== header.length) return void 0;
+  const alignments = parseTableAlignments(separatorCells);
+  if (alignments == null) return void 0;
+  const rows = [];
+  let endIndex = startIndex + 2;
+  while (endIndex < lines.length) {
+    const row = parseTableCells(lines[endIndex] ?? "");
+    if (row == null) break;
+    rows.push(normalizeTableRow(row, header.length));
+    endIndex += 1;
+  }
+  return { alignments, endIndex, header, rows };
+}
+function parseTableCells(line) {
+  if (!line.includes("|")) return void 0;
+  let tableLine = line.trim();
+  if (tableLine.startsWith("|")) tableLine = tableLine.slice(1);
+  if (tableLine.endsWith("|") && !tableLine.endsWith("\\|")) {
+    tableLine = tableLine.slice(0, -1);
+  }
+  const cells = [];
+  let cell = "";
+  for (let index = 0; index < tableLine.length; index += 1) {
+    const character = tableLine[index];
+    const nextCharacter = tableLine[index + 1];
+    if (character === "\\" && nextCharacter === "|") {
+      cell += "|";
+      index += 1;
+      continue;
+    }
+    if (character === "|") {
+      cells.push(cell.trim());
+      cell = "";
+      continue;
+    }
+    cell += character;
+  }
+  cells.push(cell.trim());
+  return cells;
+}
+function parseTableAlignments(cells) {
+  const alignments = [];
+  for (const cell of cells) {
+    const match = cell.match(/^(:)?-{3,}(:)?$/);
+    if (match == null) return void 0;
+    const [, left, right] = match;
+    alignments.push(left != null && right != null ? "center" : right != null ? "right" : "left");
+  }
+  return alignments;
+}
+function normalizeTableRow(row, length) {
+  return Array.from({ length }, (_, index) => row[index] ?? "");
+}
+function renderTable(table) {
+  const header = table.header.map(
+    (cell) => `${ansi.bold}${renderInlineMarkdown(cell)}${ansi.boldOff}`
+  );
+  const rows = table.rows.map((row) => row.map(renderInlineMarkdown));
+  const tableRows = [header, ...rows];
+  const widths = table.alignments.map(
+    (_, columnIndex) => Math.max(3, ...tableRows.map((row) => visibleLength(row[columnIndex] ?? "")))
+  );
+  return [
+    formatTableRow(header, widths, table.alignments),
+    widths.map((width) => tableSeparator.repeat(width)).join("  "),
+    ...rows.map((row) => formatTableRow(row, widths, table.alignments))
+  ];
+}
+function formatTableRow(row, widths, alignments) {
+  return row.map((cell, index) => alignTableCell(cell, widths[index] ?? 0, alignments[index] ?? "left")).join("  ");
+}
+function alignTableCell(cell, width, alignment) {
+  const paddingWidth = Math.max(0, width - visibleLength(cell));
+  if (alignment === "right") return `${" ".repeat(paddingWidth)}${cell}`;
+  if (alignment === "center") {
+    const leftPadding = Math.floor(paddingWidth / 2);
+    const rightPadding = paddingWidth - leftPadding;
+    return `${" ".repeat(leftPadding)}${cell}${" ".repeat(rightPadding)}`;
+  }
+  return `${cell}${" ".repeat(paddingWidth)}`;
+}
+
+// src/cli/tui/renderer/blocks.ts
+function renderBlockLines(block, width, theme, context) {
+  const depth = block.depth ?? 0;
+  const prefix = nestingPrefix(depth, theme);
+  const avail = Math.max(8, width - visibleLength(prefix));
+  const rows = renderBody(block, avail, theme, context);
+  return rows.map((row) => `${prefix}${row}`);
+}
+function nestingPrefix(depth, theme) {
+  if (depth <= 0) return "";
+  const rule = `${theme.colors.orange(theme.glyph.rule)} `;
+  return rule.repeat(depth);
+}
+function renderBody(block, width, theme, context) {
+  switch (block.kind) {
+    case "user":
+      return renderUser(block, width, theme);
+    case "assistant":
+    case "subagent-step":
+      return renderProse(block, width, theme);
+    case "reasoning":
+      return renderReasoning(block, width, theme);
+    case "tool":
+    case "subagent-tool":
+      return renderTool(block, width, theme, context);
+    case "error":
+      return renderError(block, width, theme);
+    case "notice":
+      return renderNotice(block, width, theme);
+    case "warning":
+      return renderWarning(block, width, theme);
+    case "result":
+      return renderResult(block, width, theme);
+    case "subagent":
+      return renderSubagentHeader(block, width, theme);
+    case "agent-header":
+      return (block.body ?? "").split("\n");
+  }
+}
+function renderUser(block, width, theme) {
+  const bar = theme.colors.cyan(theme.glyph.user);
+  const lines = wrap(block.body ?? "", width - 2);
+  return lines.map((line) => `${bar} ${line}`);
+}
+function renderProse(block, width, theme) {
+  const rows = [];
+  const isSubagent = block.kind === "subagent-step";
+  const glyph = isSubagent ? "" : `${theme.colors.bold(theme.colors.white(theme.glyph.brand))} `;
+  const indent = isSubagent ? "" : "  ";
+  if (block.reasoning && block.reasoning.trim().length > 0) {
+    rows.push(...renderReasoningLines(block.reasoning, width, theme));
+  }
+  const body = (block.body ?? "").trim();
+  if (body.length === 0 && rows.length === 0) {
+    return [`${glyph}${theme.colors.dim(`thinking${theme.glyph.ellipsis}`)}`];
+  }
+  if (body.length > 0) {
+    const rendered = renderMarkdown(body).split("\n").flatMap((line) => wrapVisibleLine(line, width - indent.length));
+    rendered.forEach((line, index) => {
+      if (index === 0 && !isSubagent && rows.length === 0) {
+        rows.push(`${glyph}${line}`);
+      } else {
+        rows.push(`${indent}${line}`);
+      }
+    });
+  }
+  return rows.length > 0 ? rows : [`${glyph}`];
+}
+function renderReasoning(block, width, theme) {
+  if (block.collapsed) {
+    return [`${theme.colors.gray(theme.glyph.reasoning)} ${theme.colors.dim("thinking")}`];
+  }
+  return renderReasoningLines(block.body ?? "", width, theme, theme.glyph.reasoning);
+}
+function renderReasoningLines(text, width, theme, glyph) {
+  const pad = glyph ? 2 : 0;
+  const lines = wrap(text.trim(), width - pad);
+  if (lines.length === 0) return [];
+  return lines.map((line, index) => {
+    const prefix = glyph ? index === 0 ? `${theme.colors.gray(glyph)} ` : "  " : "";
+    return `${prefix}${theme.colors.dim(theme.colors.italic(line))}`;
+  });
+}
+function renderTool(block, width, theme, context) {
+  const { icon, accent } = toolGlyph(block.status ?? "running", theme, context);
+  const name = block.title ?? "tool";
+  const headerWidth = width - 2;
+  const namePlain = truncatePlain(name, headerWidth);
+  let header = `${icon} ${theme.colors.bold(namePlain)}`;
+  const argsBudget = headerWidth - namePlain.length - 2;
+  const args = block.subtitle ?? "";
+  if (args.length > 0 && argsBudget >= 6) {
+    header += `  ${theme.colors.gray(truncate(args, argsBudget))}`;
+  }
+  const rows = [header];
+  if (block.expanded) {
+    rows.push(...renderToolExpanded(block, width, theme));
+  } else if (block.status === "done" && block.result && block.result.length > 0) {
+    rows.push(resultLine(theme.glyph.arrow, block.result, width, theme, accent));
+  } else if (block.status === "error" && block.result) {
+    rows.push(resultLine(theme.glyph.arrow, block.result, width, theme, theme.colors.red));
+  } else if (block.status === "denied") {
+    rows.push(resultLine(theme.glyph.arrow, "denied", width, theme, theme.colors.yellow));
+  }
+  return rows;
+}
+function renderToolExpanded(block, width, theme) {
+  const rows = [];
+  const push = (label, value, color) => {
+    if (value === void 0) return;
+    rows.push(`  ${theme.colors.dim(label)}`);
+    for (const line of wrap(formatValuePretty(value), width - 4)) {
+      rows.push(`    ${color(line)}`);
+    }
+  };
+  push("input", block.toolInput, theme.colors.gray);
+  if (block.status === "error" && block.result) {
+    push("error", block.result, theme.colors.red);
+  } else {
+    push("output", block.toolOutput, theme.colors.gray);
+  }
+  return rows;
+}
+function resultLine(marker, text, width, theme, color) {
+  const budget = width - 4;
+  return `  ${theme.colors.dim(marker)} ${color(truncate(text, budget))}`;
+}
+function toolGlyph(status, theme, context) {
+  switch (status) {
+    case "done":
+      return { icon: theme.colors.green(theme.glyph.success), accent: theme.colors.gray };
+    case "error":
+      return { icon: theme.colors.red(theme.glyph.error), accent: theme.colors.red };
+    case "denied":
+      return { icon: theme.colors.yellow(theme.glyph.warning), accent: theme.colors.yellow };
+    case "approval":
+      return { icon: theme.colors.yellow(theme.glyph.question), accent: theme.colors.yellow };
+    case "running":
+    default:
+      return { icon: theme.colors.yellow(context.spinner), accent: theme.colors.gray };
+  }
+}
+var ERROR_DETAIL_MAX_LINES = 12;
+function renderError(block, width, theme) {
+  const icon = theme.colors.red(theme.colors.bold(theme.glyph.error));
+  const title = block.title ?? "Error";
+  const rows = [`${icon} ${theme.colors.red(theme.colors.bold(title))}`];
+  for (const line of wrap(block.body ?? "", width - 2)) {
+    rows.push(`  ${colorizeError(line, theme)}`);
+  }
+  rows.push(...renderErrorDetail(block.detail, width, theme));
+  return rows;
+}
+function renderErrorDetail(detail, width, theme) {
+  if (detail === void 0 || detail.trim().length === 0) return [];
+  const lines = detail.split("\n");
+  const visible = lines.slice(0, ERROR_DETAIL_MAX_LINES);
+  const rows = visible.map(
+    (line) => `  ${theme.colors.dim(truncatePlain(line, Math.max(1, width - 2)))}`
+  );
+  const hidden = lines.length - visible.length;
+  if (hidden > 0) {
+    rows.push(
+      `  ${theme.colors.dim(`${theme.glyph.ellipsis} +${hidden} more line${hidden === 1 ? "" : "s"}`)}`
+    );
+  }
+  return rows;
+}
+var URL_PATTERN = /(https?:\/\/\S+)/u;
+function colorizeError(line, theme) {
+  if (!URL_PATTERN.test(line)) return theme.colors.red(line);
+  return line.split(URL_PATTERN).map(
+    (segment, index) => index % 2 === 1 ? theme.colors.cyan(segment) : theme.colors.red(segment)
+  ).join("");
+}
+function renderNotice(block, width, theme) {
+  const marker = theme.colors.dim(theme.glyph.dot);
+  const lines = wrap(block.body ?? "", width - 2);
+  if (lines.length === 0) return [marker];
+  return lines.map((line) => `${marker} ${theme.colors.dim(line)}`);
+}
+function renderAttentionRows(body, width, theme) {
+  const marker = theme.colors.yellow(theme.glyph.warning);
+  const lines = wrap(body, width - 2);
+  return lines.map((line, index) => `${index === 0 ? marker : " "} ${paintCommands(line, theme)}`);
+}
+function renderWarning(block, width, theme) {
+  return renderAttentionRows(block.body ?? "", width, theme);
+}
+function paintCommands(line, theme) {
+  return line.replace(
+    /\/[a-z:-]+/g,
+    (token) => isPromptControlCommand(token) ? theme.colors.blue(token) : token
+  );
+}
+function renderResult(block, width, theme) {
+  const marker = theme.colors.dim(theme.glyph.elbow);
+  const lines = wrap(block.body ?? "", width - 7);
+  if (lines.length === 0) return [`   ${marker}`];
+  const dim = (line) => theme.colors.dim(line.replaceAll("\x1B[22m", "\x1B[22m\x1B[2m"));
+  return lines.map(
+    (line, index) => index === 0 ? `   ${marker}  ${dim(line)}` : `      ${dim(line)}`
+  );
+}
+function renderSubagentHeader(block, width, theme) {
+  const name = truncatePlain(block.title ?? "subagent", Math.max(8, width - 14));
+  return [
+    `${theme.colors.orange(theme.glyph.subagent)} ${theme.colors.bold(name)} ${theme.colors.dim("subagent")}`
+  ];
+}
+function wrap(text, width) {
+  if (text.trim().length === 0) return [];
+  return text.split("\n").flatMap((line) => wrapVisibleLine(line, Math.max(1, width)));
+}
+function truncatePlain(text, maxWidth) {
+  if (visibleLength(text) <= maxWidth) return text;
+  return sliceVisible(text, maxWidth);
+}
+
+// src/cli/tui/renderer/terminal-renderer.ts
+var EMPTY_TYPEAHEAD = {
+  matches: [],
+  selectedIndex: 0,
+  dismissed: false
+};
+var TerminalRenderer = class {
+  #output;
+  #theme;
+  #commands;
+  #store;
+  #region;
+  #history = new PromptHistory();
+  #spinnerIntervalMs;
+  #line = EMPTY_LINE;
+  #typeahead = EMPTY_TYPEAHEAD;
+  #pendingResolve;
+  #spinnerFrame = 0;
+  #spinnerTimer;
+  #stopped = false;
+  #firstPaintDone = false;
+  constructor(options = {}) {
+    this.#output = options.output ?? process.stdout;
+    this.#theme = options.theme ?? createTheme({ unicode: detectUnicode() });
+    this.#commands = options.commands ?? PROMPT_COMMANDS;
+    this.#spinnerIntervalMs = options.spinnerIntervalMs ?? 90;
+    this.#store = createBlockStore();
+    this.#region = new LiveRegion({
+      output: this.#output,
+      onResize: () => this.#paint()
+    });
+  }
+  apply(ops) {
+    if (ops.length === 0) return;
+    for (const op of ops) this.#store.apply(op);
+    this.#flushCommitted();
+    this.#syncSpinner();
+    this.#paint();
+  }
+  writeNotice(text) {
+    this.apply([{ type: "commit", block: { kind: "notice", body: text } }]);
+  }
+  writeError(title, message) {
+    this.apply([
+      { type: "commit", block: { kind: "error", title, body: message } }
+    ]);
+  }
+  writeAgentHeader(body) {
+    this.apply([{ type: "commit", block: { kind: "agent-header", body } }]);
+  }
+  readPrompt() {
+    return new Promise((resolve2) => {
+      this.#pendingResolve = resolve2;
+      this.#line = EMPTY_LINE;
+      this.#typeahead = EMPTY_TYPEAHEAD;
+      this.#history.begin(this.#line.text);
+      this.#paint();
+    });
+  }
+  handleKey(key) {
+    if (this.#pendingResolve === void 0) return;
+    if (key.type === "ctrl-c") {
+      const resolve2 = this.#pendingResolve;
+      this.#pendingResolve = void 0;
+      this.stop();
+      resolve2(void 0);
+      return;
+    }
+    if (this.#isTypeaheadOpen() && (key.type === "up" || key.type === "down")) {
+      const delta = key.type === "up" ? -1 : 1;
+      this.#moveTypeahead(delta);
+      this.#paint();
+      return;
+    }
+    if (this.#isTypeaheadOpen() && (key.type === "tab" || key.type === "enter")) {
+      this.#acceptTypeahead(key.type === "enter");
+      return;
+    }
+    if (key.type === "escape" && this.#isTypeaheadOpen()) {
+      this.#typeahead = { ...this.#typeahead, dismissed: true };
+      this.#paint();
+      return;
+    }
+    if (key.type === "enter") {
+      this.#submit();
+      return;
+    }
+    if (key.type === "up" || key.type === "ctrl-p") {
+      const previous = this.#history.previous(this.#line.text);
+      if (previous !== void 0) {
+        this.#line = { text: previous, cursor: previous.length };
+        this.#refreshTypeahead();
+        this.#paint();
+      }
+      return;
+    }
+    if (key.type === "down" || key.type === "ctrl-n") {
+      const next = this.#history.next();
+      if (next !== void 0) {
+        this.#line = { text: next, cursor: next.length };
+        this.#refreshTypeahead();
+        this.#paint();
+      }
+      return;
+    }
+    const nextLine = applyLineEditorKey(this.#line, key, { multiline: false });
+    if (nextLine !== void 0) {
+      this.#line = nextLine;
+      this.#refreshTypeahead();
+      this.#paint();
+    }
+  }
+  stop() {
+    if (this.#stopped) return;
+    this.#stopped = true;
+    if (this.#spinnerTimer !== void 0) clearInterval(this.#spinnerTimer);
+    this.#region.stop();
+  }
+  #submit() {
+    if (this.#pendingResolve === void 0) return;
+    const text = this.#line.text;
+    this.#history.add(text);
+    const resolve2 = this.#pendingResolve;
+    this.#pendingResolve = void 0;
+    this.#line = EMPTY_LINE;
+    this.#typeahead = EMPTY_TYPEAHEAD;
+    this.#region.paint([], { row: 1, col: 1 });
+    resolve2(text);
+  }
+  #refreshTypeahead() {
+    const matches = matchingCommands(this.#commands, this.#line.text);
+    this.#typeahead = { matches, selectedIndex: 0, dismissed: false };
+  }
+  #isTypeaheadOpen() {
+    return this.#typeahead.matches.length > 0 && !this.#typeahead.dismissed;
+  }
+  #moveTypeahead(delta) {
+    const count = this.#typeahead.matches.length;
+    if (count === 0) return;
+    const selectedIndex = (this.#typeahead.selectedIndex + delta + count) % count;
+    this.#typeahead = { ...this.#typeahead, selectedIndex };
+  }
+  #acceptTypeahead(submitAfter) {
+    const spec = this.#typeahead.matches[this.#typeahead.selectedIndex];
+    if (spec === void 0) return;
+    const text = `/${spec.name}${spec.takesArgument ? " " : ""}`;
+    this.#line = { text, cursor: text.length };
+    this.#typeahead = EMPTY_TYPEAHEAD;
+    if (submitAfter && !spec.takesArgument) {
+      this.#submit();
+    } else {
+      this.#paint();
+    }
+  }
+  #flushCommitted() {
+    const drained = this.#store.drainCommitted();
+    if (drained.length === 0) return;
+    const rows = [];
+    let previous;
+    const ctx = { spinner: this.#currentSpinner(), previous };
+    for (const block of drained) {
+      const blockCtx = { spinner: this.#currentSpinner(), previous };
+      rows.push(...renderBlockLines(block, this.columns, this.#theme, blockCtx));
+      previous = { kind: block.kind, title: block.title };
+    }
+    if (rows.length > 0 && this.#firstPaintDone) rows.unshift("");
+    if (!this.#firstPaintDone && rows.length > 0) this.#firstPaintDone = true;
+    this.#region.commit(rows);
+  }
+  #paint() {
+    if (this.#stopped) return;
+    if (this.#pendingResolve === void 0 && this.#store.live.size === 0) {
+      this.#region.paint([], { row: 1, col: 1 });
+      return;
+    }
+    const rows = [];
+    const ctx = { spinner: this.#currentSpinner() };
+    for (const block of this.#store.live.values()) {
+      rows.push(...renderBlockLines(block, this.columns, this.#theme, ctx));
+    }
+    if (this.#pendingResolve !== void 0) {
+      if (rows.length > 0) rows.push("");
+      const inputRow = this.#renderInputRow();
+      const caretCol = this.#caretColumn();
+      rows.push(inputRow);
+      this.#region.paint(rows, { row: rows.length, col: caretCol });
+      return;
+    }
+    this.#region.paint(rows, { row: rows.length, col: 1 });
+  }
+  #renderInputRow() {
+    const c = this.#theme.colors;
+    const promptGlyph = c.cyan(this.#theme.glyph.prompt);
+    const promptWidth = visibleLength(`${this.#theme.glyph.prompt} `);
+    const budget = Math.max(1, this.columns - promptWidth);
+    const view = visibleLine(this.#line, budget);
+    const before = view.before;
+    const under = view.under.length === 0 ? " " : view.under;
+    const after = view.after;
+    return `${promptGlyph} ${before}${c.inverse(under)}${after}`;
+  }
+  #caretColumn() {
+    const promptWidth = visibleLength(`${this.#theme.glyph.prompt} `);
+    const view = visibleLine(this.#line, Math.max(1, this.columns - promptWidth));
+    return 1 + promptWidth + inputTextWidth(view.before);
+  }
+  #currentSpinner() {
+    return this.#theme.spinner[this.#spinnerFrame % this.#theme.spinner.length] ?? "-";
+  }
+  #syncSpinner() {
+    const hasLive = [...this.#store.live.values()].some((b) => b.live === true);
+    if (hasLive && this.#spinnerTimer === void 0) {
+      this.#spinnerTimer = setInterval(() => {
+        this.#spinnerFrame += 1;
+        this.#paint();
+      }, this.#spinnerIntervalMs);
+      this.#spinnerTimer.unref?.();
+    }
+    if (!hasLive && this.#spinnerTimer !== void 0) {
+      clearInterval(this.#spinnerTimer);
+      this.#spinnerTimer = void 0;
+    }
+  }
+  get columns() {
+    return this.#region.columns;
+  }
+};
+
+// src/cli/tui/renderer/start-block-chat.ts
+async function startBlockChat(options) {
+  const { agentDir } = options;
+  const renderer = new TerminalRenderer();
+  const translator = new EventTranslator();
+  const commitHeader = async () => {
+    try {
+      const agent = await loadAgent(agentDir);
+      const model = agent.manifest.config.model;
+      renderer.writeAgentHeader(`arcie \xB7 ${agentDir.split("/").pop() ?? "agent"} \xB7 ${model}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      renderer.writeError("Agent load failed", message);
+    }
+  };
+  const { diagnostics } = discoverAgent(agentDir);
+  const errorDiags = diagnostics.filter((d) => d.severity === "error");
+  if (errorDiags.length > 0) {
+    for (const d of errorDiags) renderer.writeError(d.code, d.message);
+    renderer.stop();
+    return;
+  }
+  await commitHeader();
+  let watcher;
+  try {
+    let reprobeTimer;
+    watcher = watch(agentDir, { recursive: true }, () => {
+      if (reprobeTimer !== void 0) clearTimeout(reprobeTimer);
+      reprobeTimer = setTimeout(() => {
+        void commitHeader();
+      }, 250);
+    });
+  } catch {
+  }
+  const detachKeys = attachKeyStream((key) => renderer.handleKey(key));
+  try {
+    if (options.initialInput !== void 0 && options.initialInput.length > 0) {
+      await streamOneTurn(renderer, translator, agentDir, options.initialInput);
+    }
+    while (true) {
+      const text = await renderer.readPrompt();
+      if (text === void 0) return;
+      const trimmed = text.trim();
+      if (trimmed.length === 0) continue;
+      if (trimmed.startsWith("/")) {
+        const command = parsePromptCommand(trimmed);
+        if (command === null) {
+          renderer.writeError("Unknown command", `${trimmed} \u2014 try /help`);
+          continue;
+        }
+        switch (command.type) {
+          case "exit":
+            return;
+          case "help":
+            for (const line of formatPromptCommandHelp().split("\n")) {
+              renderer.writeNotice(line);
+            }
+            continue;
+          case "clear":
+          case "new":
+            for (const op of translator.reset()) renderer.apply([op]);
+            await commitHeader();
+            continue;
+          case "extension":
+            renderer.writeNotice(`/${command.name} not yet implemented`);
+            continue;
+          case "loglevel":
+            renderer.writeNotice("logs not yet implemented");
+            continue;
+        }
+        continue;
+      }
+      await streamOneTurn(renderer, translator, agentDir, trimmed);
+    }
+  } finally {
+    detachKeys();
+    watcher?.close();
+    renderer.stop();
+  }
+}
+async function streamOneTurn(renderer, translator, agentDir, message) {
+  let sawApproval = false;
+  try {
+    for await (const event of streamAgent(agentDir, message)) {
+      const ops = translator.feed(event);
+      renderer.apply(ops);
+      if (event.type === "tool.completed" && event.data.status === "pending" && event.data.error?.code === "needs_approval") {
+        sawApproval = true;
+      }
+    }
+    if (sawApproval) {
+      renderer.writeNotice(
+        "Tool call awaiting approval \u2014 approve via the Cencori sessions API to continue."
+      );
+    }
+  } catch (err) {
+    const detail = err instanceof Error ? err.stack : void 0;
+    renderer.apply([
+      {
+        type: "commit",
+        block: {
+          kind: "error",
+          title: "Stream error",
+          body: err instanceof Error ? err.message : String(err),
+          detail
+        }
+      }
+    ]);
+  }
+}
+
+// src/server/llm.ts
+var PROVIDERS = {
+  openai: {
+    baseUrl: "https://api.openai.com/v1",
+    apiKey: () => process.env.OPENAI_API_KEY
+  },
+  anthropic: {
+    baseUrl: "https://api.anthropic.com/v1",
+    apiKey: () => process.env.ANTHROPIC_API_KEY
+  },
+  groq: {
+    baseUrl: "https://api.groq.com/openai/v1",
+    apiKey: () => process.env.GROQ_API_KEY
+  },
+  deepseek: {
+    baseUrl: "https://api.deepseek.com/v1",
+    apiKey: () => process.env.DEEPSEEK_API_KEY
+  },
+  mistral: {
+    baseUrl: "https://api.mistral.ai/v1",
+    apiKey: () => process.env.MISTRAL_API_KEY
+  },
+  google: {
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    apiKey: () => process.env.GOOGLE_API_KEY
+  },
+  meta: {
+    baseUrl: "https://api.together.xyz/v1",
+    apiKey: () => process.env.TOGETHER_API_KEY || process.env.OPENAI_API_KEY
+  }
+};
+function parseModelId(modelId) {
+  const slash = modelId.indexOf("/");
+  if (slash === -1) return { provider: "", model: modelId };
+  return { provider: modelId.slice(0, slash), model: modelId.slice(slash + 1) };
+}
+function getProviderApiKey(provider) {
+  const cfg = PROVIDERS[provider];
+  return cfg?.apiKey?.();
+}
+async function* streamLlm(modelId, messages, tools, toolResults) {
+  const { provider, model } = parseModelId(modelId);
+  const cfg = PROVIDERS[provider];
+  if (!cfg) {
+    yield { type: "error", error: `Unknown provider: ${provider}` };
+    return;
+  }
+  const apiKey = cfg.apiKey();
+  if (!apiKey) {
+    yield { type: "error", error: `Missing API key for provider: ${provider}. Set ${provider.toUpperCase()}_API_KEY` };
+    return;
+  }
+  if (provider === "anthropic") {
+    yield* streamAnthropic(cfg.baseUrl, apiKey, model, messages, tools, toolResults);
+  } else if (provider === "google") {
+    yield* streamGoogle(cfg.baseUrl, apiKey, model, messages, tools, toolResults);
+  } else {
+    yield* streamOpenAICompatible(cfg.baseUrl, apiKey, model, messages, tools, toolResults);
+  }
+}
+async function* streamOpenAICompatible(baseUrl, apiKey, model, messages, tools, toolResults) {
+  const body = {
+    model,
+    messages,
+    stream: true,
+    stream_options: { include_usage: false }
+  };
+  if (tools && tools.length > 0) {
+    body.tools = tools;
+  }
+  const res = await fetch(`${baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    yield { type: "error", error: `LLM API error (${res.status}): ${err.slice(0, 300)}` };
+    return;
+  }
+  const reader = res.body?.getReader();
+  if (!reader) {
+    yield { type: "error", error: "No response body" };
+    return;
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let accumulatedToolCalls = /* @__PURE__ */ new Map();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const payload = line.slice(6).trim();
+      if (payload === "[DONE]") {
+        if (accumulatedToolCalls.size > 0) {
+          const calls = Array.from(accumulatedToolCalls.values()).map((c) => ({
+            id: c.id,
+            name: c.name,
+            arguments: c.args
+          }));
+          yield { type: "tool_call", toolCalls: calls };
+        }
+        yield { type: "done", finishReason: "stop" };
+        return;
+      }
+      try {
+        const parsed = JSON.parse(payload);
+        const choice = parsed.choices?.[0];
+        if (choice?.finish_reason) {
+          if (choice.finish_reason === "tool_calls" && accumulatedToolCalls.size > 0) {
+            const calls = Array.from(accumulatedToolCalls.values()).map((c) => ({
+              id: c.id,
+              name: c.name,
+              arguments: c.args
+            }));
+            yield { type: "tool_call", toolCalls: calls };
+          }
+          yield { type: "done", finishReason: choice.finish_reason };
+          return;
+        }
+        const delta = choice?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          yield { type: "delta", delta: delta.content };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index ?? 0;
+            let existing = accumulatedToolCalls.get(idx);
+            if (!existing) {
+              if (!tc.function?.name) continue;
+              existing = { id: tc.id ?? "", name: tc.function.name, args: "" };
+              accumulatedToolCalls.set(idx, existing);
+            }
+            if (tc.id) existing.id = tc.id;
+            if (tc.function?.name) existing.name = tc.function.name;
+            if (tc.function?.arguments) existing.args += tc.function.arguments;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (accumulatedToolCalls.size > 0) {
+    const calls = Array.from(accumulatedToolCalls.values()).map((c) => ({
+      id: c.id,
+      name: c.name,
+      arguments: c.args
+    }));
+    yield { type: "tool_call", toolCalls: calls };
+  }
+  yield { type: "done", finishReason: "stop" };
+}
+async function* streamAnthropic(baseUrl, apiKey, model, messages, tools, toolResults) {
+  const systemMsgs = messages.filter((m) => m.role === "system");
+  const chatMsgs = messages.filter((m) => m.role !== "system").map((m) => {
+    if (m.role === "tool") {
+      return {
+        role: "user",
+        content: [{ type: "tool_result", tool_use_id: m.tool_call_id, content: m.content }]
+      };
+    }
+    if (m.tool_calls) {
+      return {
+        role: "assistant",
+        content: m.tool_calls.map((tc) => ({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments || "{}")
+        }))
+      };
+    }
+    return { role: m.role, content: m.content };
+  });
+  const body = {
+    model,
+    max_tokens: 4096,
+    messages: chatMsgs,
+    stream: true
+  };
+  if (systemMsgs.length > 0) {
+    body.system = systemMsgs.map((m) => ({ type: "text", text: m.content }));
+  }
+  if (tools && tools.length > 0) {
+    body.tools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.input_schema || { type: "object", properties: {} }
+    }));
+  }
+  const res = await fetch(`${baseUrl}/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    yield { type: "error", error: `Anthropic API error (${res.status}): ${err.slice(0, 300)}` };
+    return;
+  }
+  const reader = res.body?.getReader();
+  if (!reader) {
+    yield { type: "error", error: "No response body" };
+    return;
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let currentEvent = "";
+  let accumulatedToolCalls = /* @__PURE__ */ new Map();
+  let inputJsonBuffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.startsWith("event: ")) {
+        currentEvent = line.slice(7);
+        if (currentEvent === "content_block_start" || currentEvent === "content_block_delta") {
+          inputJsonBuffer = "";
+        }
+      } else if (line.startsWith("data: ")) {
+        const payload = line.slice(6).trim();
+        if (!payload) continue;
+        try {
+          const parsed = JSON.parse(payload);
+          if (currentEvent === "content_block_start" && parsed.content_block) {
+            if (parsed.content_block.type === "tool_use") {
+              accumulatedToolCalls.set(parsed.index, {
+                id: parsed.content_block.id,
+                name: parsed.content_block.name,
+                args: ""
+              });
+            }
+          } else if (currentEvent === "content_block_delta" && parsed.delta) {
+            if (parsed.delta.type === "text_delta" && parsed.delta.text) {
+              yield { type: "delta", delta: parsed.delta.text };
+            } else if (parsed.delta.type === "input_json_delta" && parsed.delta.partial_json) {
+              for (const [idx, tc] of accumulatedToolCalls) {
+                if (String(parsed.index) === String(idx)) {
+                  tc.args += parsed.delta.partial_json;
+                }
+              }
+            }
+          } else if (currentEvent === "message_start") {
+          } else if (currentEvent === "message_delta") {
+            if (parsed.delta?.stop_reason === "tool_use" || parsed.delta?.stop_reason === "end_turn") {
+            }
+            if (parsed.delta?.stop_reason === "end_turn" && accumulatedToolCalls.size > 0) {
+              const calls = Array.from(accumulatedToolCalls.values()).map((c) => ({
+                id: c.id,
+                name: c.name,
+                arguments: c.args
+              }));
+              yield { type: "tool_call", toolCalls: calls };
+              accumulatedToolCalls.clear();
+            }
+          } else if (currentEvent === "message_stop") {
+            if (accumulatedToolCalls.size > 0) {
+              const calls = Array.from(accumulatedToolCalls.values()).map((c) => ({
+                id: c.id,
+                name: c.name,
+                arguments: c.args
+              }));
+              yield { type: "tool_call", toolCalls: calls };
+              accumulatedToolCalls.clear();
+            }
+            yield { type: "done", finishReason: "stop" };
+            return;
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  yield { type: "done", finishReason: "stop" };
+}
+async function* streamGoogle(baseUrl, apiKey, model, messages, tools, toolResults) {
+  const contents = messages.filter((m) => m.role !== "system").map((m) => {
+    const role = m.role === "assistant" ? "model" : m.role === "tool" ? "user" : m.role;
+    return {
+      role,
+      parts: [{ text: m.content }]
+    };
+  });
+  const body = {
+    contents,
+    generationConfig: { temperature: 0.7 }
+  };
+  if (tools && tools.length > 0) {
+    body.tools = tools.map((t) => ({
+      functionDeclarations: [{
+        name: t.name,
+        description: t.description,
+        parameters: t.input_schema || {}
+      }]
+    }));
+  }
+  const res = await fetch(
+    `${baseUrl}/models/${model}:streamGenerateContent?key=${apiKey}&alt=sse`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    }
+  );
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    yield { type: "error", error: `Google API error (${res.status}): ${err.slice(0, 300)}` };
+    return;
+  }
+  const reader = res.body?.getReader();
+  if (!reader) {
+    yield { type: "error", error: "No response body" };
+    return;
+  }
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.startsWith("data: ")) continue;
+      const payload = line.slice(6).trim();
+      if (!payload) continue;
+      try {
+        const parsed = JSON.parse(payload);
+        const candidate = parsed.candidates?.[0];
+        if (!candidate) continue;
+        const part = candidate.content?.parts?.[0];
+        if (part?.text) {
+          yield { type: "delta", delta: part.text };
+        }
+        if (candidate.finishReason) {
+          yield { type: "done", finishReason: candidate.finishReason.toLowerCase() };
+          return;
+        }
+      } catch {
+      }
+    }
+  }
+  yield { type: "done", finishReason: "stop" };
+}
+
+// src/server/index.ts
+var sessions = /* @__PURE__ */ new Map();
+var sessionCounter = 0;
+function nextId() {
+  return `local-${++sessionCounter}-${Date.now().toString(36)}`;
+}
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString()));
+    req.on("error", reject);
+  });
+}
+function writeSSE(res, event, data) {
+  res.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+}
+function parseUrl(url) {
+  const idx = url.indexOf("?");
+  return { pathname: idx === -1 ? url : url.slice(0, idx) };
+}
+async function handleSessionsRequest(req, res) {
+  const { pathname } = parseUrl(req.url ?? "/");
+  const sessionMatch = pathname.match(/^\/v1\/sessions\/([^/]+)\/turns$/);
+  const approveMatch = pathname.match(/^\/v1\/sessions\/([^/]+)\/approve$/);
+  const createMatch = pathname === "/v1/sessions" && req.method === "POST";
+  if (createMatch) {
+    return handleCreateSession(req, res);
+  }
+  if (sessionMatch && req.method === "POST") {
+    return handleTurn(req, res, sessionMatch[1]);
+  }
+  if (approveMatch && req.method === "POST") {
+    return handleApprove(req, res, approveMatch[1]);
+  }
+  return false;
+}
+async function handleCreateSession(req, res) {
+  const body = JSON.parse(await readBody(req));
+  const id = nextId();
+  const session = {
+    id,
+    agentId: body.agent_id ?? "unnamed",
+    model: body.metadata?.model ?? "",
+    instructions: body.metadata?.instructions ?? "",
+    messages: []
+  };
+  sessions.set(id, session);
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ id }));
+  return true;
+}
+async function handleTurn(req, res, sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Session not found" }));
+    return true;
+  }
+  const body = JSON.parse(await readBody(req));
+  const model = body.model || session.model;
+  const input = body.input ?? "";
+  const instructions = body.instructions || session.instructions;
+  const stream = body.stream !== false;
+  const pauseOnTools = body.pause_on_tool_calls !== false;
+  const tools = body.tools ?? [];
+  session.model = model;
+  session.instructions = instructions;
+  if (tools.length > 0) session.tools = tools;
+  const messages = [];
+  if (instructions) {
+    messages.push({ role: "system", content: instructions });
+  }
+  for (const msg of session.messages) {
+    messages.push(msg);
+  }
+  const turnNumber = session.messages.filter((m) => m.role === "user").length + 1;
+  const userMsg = { role: "user", content: input };
+  messages.push(userMsg);
+  if (stream) {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no"
+    });
+    writeSSE(res, "turn.started", { turn_number: turnNumber, input_text: input });
+    writeSSE(res, "message.received", { input_text: input, turn_number: turnNumber });
+    writeSSE(res, "step.started", { step_number: 1, turn_number: turnNumber });
+    let textSoFar = "";
+    let hadToolCalls = false;
+    let messagePushed = false;
+    try {
+      for await (const event of streamLlm(model, messages, tools.length > 0 ? tools : void 0)) {
+        if (event.type === "delta" && event.delta) {
+          textSoFar += event.delta;
+          writeSSE(res, "output_text.delta", { delta: event.delta, text: textSoFar });
+        }
+        if (event.type === "tool_call" && event.toolCalls) {
+          hadToolCalls = true;
+          session.pendingToolCalls = event.toolCalls;
+          for (const tc of event.toolCalls) {
+            writeSSE(res, "tool_call.started", {
+              tool: tc.name,
+              arguments: JSON.parse(tc.arguments || "{}"),
+              action_id: tc.id
+            });
+          }
+          const toolCallMsg = {
+            role: "assistant",
+            content: textSoFar,
+            tool_calls: event.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: { name: tc.name, arguments: tc.arguments }
+            }))
+          };
+          if (pauseOnTools) {
+            session.messages.push(toolCallMsg);
+            messagePushed = true;
+            writeSSE(res, "turn.paused", { text: textSoFar });
+            res.end();
+            return true;
+          }
+          session.messages.push(toolCallMsg);
+          messagePushed = true;
+        }
+        if (event.type === "done") {
+          if (!messagePushed) {
+            session.messages.push({ role: "assistant", content: textSoFar });
+            messagePushed = true;
+          }
+          writeSSE(res, "message.completed", {
+            text: textSoFar,
+            finish_reason: event.finishReason ?? "stop",
+            step_number: 1,
+            turn_number: turnNumber
+          });
+          writeSSE(res, "step.completed", {
+            finish_reason: event.finishReason ?? "stop",
+            step_number: 1,
+            turn_number: turnNumber
+          });
+          writeSSE(res, "turn.completed", { turn_number: turnNumber, turn_id: sessionId });
+        }
+        if (event.type === "error") {
+          writeSSE(res, "turn.completed", { turn_number: turnNumber, turn_id: sessionId });
+          writeSSE(res, "error", { message: event.error });
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      writeSSE(res, "error", { message: msg });
+    }
+    res.end();
+  } else {
+    let fullText = "";
+    let messagePushed = false;
+    try {
+      for await (const event of streamLlm(model, messages, tools.length > 0 ? tools : void 0)) {
+        if (event.type === "delta" && event.delta) {
+          fullText += event.delta;
+        }
+        if (event.type === "tool_call" && event.toolCalls) {
+          session.pendingToolCalls = event.toolCalls;
+        }
+      }
+    } catch {
+    }
+    if (!messagePushed) {
+      session.messages.push({ role: "assistant", content: fullText });
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ output: fullText, turn_id: sessionId }));
+  }
+  return true;
+}
+async function handleApprove(req, res, sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Session not found" }));
+    return true;
+  }
+  const body = JSON.parse(await readBody(req));
+  const toolResults = body.tool_results ?? [];
+  const actionId = body.action_id ?? toolResults[0]?.action_id ?? "";
+  if (!session.pendingToolCalls || session.pendingToolCalls.length === 0) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "No pending tool calls" }));
+    return true;
+  }
+  const toolResultMessages = toolResults.map((r) => ({
+    role: "tool",
+    tool_call_id: r.action_id,
+    content: r.output
+  }));
+  for (const msg of toolResultMessages) {
+    session.messages.push(msg);
+  }
+  session.pendingToolCalls = void 0;
+  const turnNumber = session.messages.filter((m) => m.role === "user").length;
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  writeSSE(res, "turn.resumed", {});
+  let textSoFar = "";
+  let hadToolCalls = false;
+  let messagePushed = false;
+  try {
+    for await (const event of streamLlm(
+      session.model,
+      session.messages,
+      session.tools,
+      toolResults
+    )) {
+      if (event.type === "delta" && event.delta) {
+        textSoFar += event.delta;
+        writeSSE(res, "output_text.delta", { delta: event.delta, text: textSoFar });
+      }
+      if (event.type === "tool_call" && event.toolCalls) {
+        hadToolCalls = true;
+        session.pendingToolCalls = event.toolCalls;
+        for (const tc of event.toolCalls) {
+          writeSSE(res, "tool_call.started", {
+            tool: tc.name,
+            arguments: JSON.parse(tc.arguments || "{}"),
+            action_id: tc.id
+          });
+        }
+        session.messages.push({
+          role: "assistant",
+          content: textSoFar,
+          tool_calls: event.toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: tc.arguments }
+          }))
+        });
+        messagePushed = true;
+        writeSSE(res, "turn.paused", { text: textSoFar });
+        res.end();
+        return true;
+      }
+      if (event.type === "done") {
+        if (!messagePushed) {
+          session.messages.push({ role: "assistant", content: textSoFar });
+          messagePushed = true;
+        }
+        writeSSE(res, "message.completed", {
+          text: textSoFar,
+          finish_reason: event.finishReason ?? "stop"
+        });
+        writeSSE(res, "turn.completed", { turn_number: turnNumber, turn_id: sessionId });
+      }
+      if (event.type === "error") {
+        writeSSE(res, "error", { message: event.error });
+      }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    writeSSE(res, "error", { message: msg });
+  }
+  res.end();
+  return true;
+}
+
+// src/cli/dev.ts
+function checkProviderKeys(modelId) {
+  const provider = modelId.split("/")[0];
+  const missing = [];
+  const keyMap = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    groq: "GROQ_API_KEY",
+    deepseek: "DEEPSEEK_API_KEY",
+    mistral: "MISTRAL_API_KEY",
+    google: "GOOGLE_API_KEY",
+    meta: "TOGETHER_API_KEY"
+  };
+  const envVar = keyMap[provider];
+  if (envVar && !process.env[envVar] && !getProviderApiKey(provider)) {
+    missing.push(envVar);
+  }
+  return missing;
+}
+async function devCommand(options) {
+  const agentDirPath = resolve(process.cwd(), options.agentDir);
+  const port = parseInt(options.port, 10);
+  const localApiUrl = `http://127.0.0.1:${port}/v1`;
+  if (!process.env.CENCORI_API_KEY) {
+    process.env.CENCORI_API_KEY = "local-dev-key";
+  }
+  if (!process.env.CENCORI_API_URL) {
+    process.env.CENCORI_API_URL = localApiUrl;
+  }
+  if (!options.input) {
+    showHeader();
+    const { diagnostics } = discoverAgent(agentDirPath);
+    if (diagnostics.some((d) => d.severity === "error")) {
+      for (const d of diagnostics) {
+        console.error(`  ${grey("\u2716")} ${d.code}: ${d.message}`);
+      }
+      process.exit(1);
+    }
+    for (const d of diagnostics) {
+      console.warn(`  ${grey("\u26A0")} ${d.code}: ${d.message}`);
+    }
+    try {
+      const agent = await loadAgent(agentDirPath);
+      console.log(`  ${agentDirPath} ${grey("\xB7")} ${grey(agent.manifest.config.model)}`);
+      console.log();
+      console.log(`  ${dimmed(`http://localhost:${port}`)}`);
+      console.log();
+      console.log(`  ${dimmed(`$ curl -X POST http://localhost:${port} \\`)}`);
+      console.log(`  ${dimmed(`  -H "Content-Type: application/json" \\`)}`);
+      console.log(`  ${dimmed(`  -d '{"message": "hello"}'`)}`);
+      console.log();
+      const missing = checkProviderKeys(agent.manifest.config.model);
+      if (missing.length > 0) {
+        console.log(`  ${grey("\u26A0")} Missing API keys: ${missing.join(", ")}`);
+        console.log(`  ${dimmed("  Set them in .env.local or your environment")}`);
+        console.log();
+      }
+    } catch {
+      console.log(`  ${agentDirPath}`);
+      console.log();
+      console.log(`  ${dimmed(`http://localhost:${port}`)}`);
+      console.log();
+    }
+  }
+  const server = createServer(async (req, res) => {
+    if (await handleSessionsRequest(req, res)) {
+      return;
+    }
+    if (req.method === "POST" && req.url === "/") {
+      let body = "";
+      for await (const chunk of req) body += chunk;
+      try {
+        const { message, stream } = JSON.parse(body);
+        if (stream) {
+          res.writeHead(200, {
+            "Content-Type": "application/x-ndjson",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          });
+          for await (const event of streamAgent(agentDirPath, message)) {
+            res.write(JSON.stringify(event) + "\n");
+          }
+          res.end();
+        } else {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          for await (const _event of streamAgent(agentDirPath, message)) {
+          }
+          res.end(JSON.stringify({ status: "ok" }));
+        }
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(err) }));
+      }
+    } else {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      console.error();
+      console.error(`  ${grey("\u2717")} port ${port} is already in use`);
+      console.error(`  ${dimmed(`try: arcie dev --port ${port + 1}`)}`);
+      console.error(`  ${dimmed(`or:  lsof -iTCP:${port} -sTCP:LISTEN -n -P    # find and kill the holder`)}`);
+      console.error();
+    } else {
+      console.error();
+      console.error(`  ${grey("\u2717")} ${err.message}`);
+      console.error();
+    }
+    process.exit(1);
+  });
+  if (options.input) {
+    server.listen(port, () => {
+      void startBlockChat({ agentDir: agentDirPath });
+    });
+  } else {
+    server.listen(port, () => {
+    });
+  }
+}
+export {
+  devCommand
+};
+//# sourceMappingURL=dev-ZZDVOWUZ.js.map