@tabbio-technologies/cli 1.2.8

package/dist/chunks/chunk-QVR5KIEQ.js

@@ -0,0 +1,1976 @@
+import { createRequire as __tabbioCreateRequire } from 'node:module';
+const require = __tabbioCreateRequire(import.meta.url);
+import {
+  CliError,
+  ExitCode,
+  debug,
+  interruptedError,
+  kebabCase,
+  loadConfig,
+  networkError,
+  parseJsonResponse,
+  relativeTime,
+  updateConfig,
+  usageError
+} from "./chunk-7LNC3FIV.js";
+import {
+  theme
+} from "./chunk-VHHZFMIF.js";
+
+// src/core/chat-model.ts
+import { marked } from "marked";
+
+// src/core/capabilities.ts
+var TOGGLE_MODES = ["auto", "on", "off"];
+var RESULT_MODES = ["auto", "summary", "document", "slides", "page", "image"];
+var DEFAULT_CAPABILITIES = { research: "auto", image: "auto", result: "auto" };
+var CAPABILITY_CHOICES = {
+  research: TOGGLE_MODES,
+  image: TOGGLE_MODES,
+  result: RESULT_MODES
+};
+var CAPABILITY_CHOICE_HELP = {
+  research: { auto: "Search the web when it helps", on: "Always search first", off: "Never search the web" },
+  image: { auto: "Only when you ask for one", on: "Make an image (uses image credits)", off: "Never make images" },
+  result: {
+    auto: "Let the message decide",
+    summary: "Answer in the chat",
+    document: "A document (HTML and PDF)",
+    slides: "A slide deck (PPTX)",
+    page: "A web page (HTML)",
+    image: "An image"
+  }
+};
+function isToggle(value) {
+  return typeof value === "string" && TOGGLE_MODES.includes(value);
+}
+function isResult(value) {
+  return typeof value === "string" && RESULT_MODES.includes(value);
+}
+function parseCapabilityMode(key, value) {
+  const normalized = value.trim().toLowerCase();
+  const alias = key === "result" && (normalized === "doc" || normalized === "pdf") ? "document" : key === "result" && normalized === "deck" ? "slides" : normalized;
+  if (key === "result" ? isResult(alias) : isToggle(alias)) return alias;
+  throw usageError(`--${key} must be one of ${CAPABILITY_CHOICES[key].join(", ")}; got "${value}"`);
+}
+function sanitizeCapabilities(raw) {
+  const record = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  return {
+    research: isToggle(record.research) ? record.research : DEFAULT_CAPABILITIES.research,
+    image: isToggle(record.image) ? record.image : DEFAULT_CAPABILITIES.image,
+    result: isResult(record.result) ? record.result : DEFAULT_CAPABILITIES.result
+  };
+}
+function loadCapabilityPrefs(profileName) {
+  try {
+    const stored = loadConfig().profiles[profileName];
+    return sanitizeCapabilities(stored?.capabilities);
+  } catch {
+    return { ...DEFAULT_CAPABILITIES };
+  }
+}
+function saveCapabilityPrefs(profileName, capabilities) {
+  updateConfig((config) => {
+    config.profiles[profileName] = { ...config.profiles[profileName], capabilities: { ...capabilities } };
+  });
+}
+function resolveCapabilities(stored, flags = {}) {
+  return {
+    research: flags.research !== void 0 ? parseCapabilityMode("research", flags.research) : stored.research,
+    image: flags.image !== void 0 ? parseCapabilityMode("image", flags.image) : stored.image,
+    result: flags.result !== void 0 ? parseCapabilityMode("result", flags.result) : stored.result
+  };
+}
+function toWireCapabilities(capabilities) {
+  return { research: capabilities.research, image: capabilities.image, artifact: capabilities.result };
+}
+function deviceTimeZone() {
+  try {
+    const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    return typeof zone === "string" && zone ? zone : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function capabilityRequestFields(mode, capabilities, timezone = deviceTimeZone()) {
+  return {
+    ...mode === "employer" ? {} : { capabilities: toWireCapabilities(capabilities) },
+    ...timezone ? { timezone } : {}
+  };
+}
+var REASON_TEXT = {
+  disabled: "switched off on this server",
+  not_allowlisted: "not enabled for this account yet (canary or plan tier)",
+  not_configured: "the provider is not configured on this server",
+  upgrade_required: "needs a paid plan"
+};
+function reasonText(reason) {
+  return reason && REASON_TEXT[reason] || reason || "unavailable";
+}
+function unavailableNotices(capabilities, availability) {
+  if (!availability) return [];
+  const notices = [];
+  if (capabilities.research === "on" && !availability.research.available) {
+    notices.push(`Research is unavailable: ${reasonText(availability.research.reason)}. This message runs without it.`);
+  }
+  const wantsImage = capabilities.image === "on" || capabilities.result === "image";
+  if (wantsImage && !availability.image.available) {
+    notices.push(`Images are unavailable: ${reasonText(availability.image.reason)}. Tabbio answers in the chat instead.`);
+  }
+  const wantsFile = capabilities.result === "document" || capabilities.result === "slides" || capabilities.result === "page";
+  if (wantsFile && !availability.artifacts.available) {
+    notices.push(`Documents, slides and pages are unavailable: ${reasonText(availability.artifacts.reason)}. Tabbio answers in the chat instead.`);
+  }
+  return notices;
+}
+
+// src/core/chat-model.ts
+function initialChatState(opts) {
+  return {
+    mode: opts.mode,
+    threadId: opts.threadId,
+    modelId: opts.modelId,
+    entries: [],
+    turn: null,
+    approvals: [],
+    streaming: false,
+    seq: 0,
+    capabilities: opts.capabilities ?? { ...DEFAULT_CAPABILITIES },
+    links: opts.links ?? false
+  };
+}
+var FINAL_STAGES = /* @__PURE__ */ new Set(["completed", "failed", "declined"]);
+function toolTitle(payload) {
+  const raw = payload.display?.title?.trim() || payload.name.replace(/([a-z0-9])([A-Z])/g, "$1 $2");
+  return raw.split(/\s+/).map((w, i) => i === 0 ? w.charAt(0).toUpperCase() + w.slice(1) : /^[A-Z][a-z]/.test(w) ? w.toLowerCase() : w).join(" ");
+}
+function stageOf(payload, fallback) {
+  const stage = payload.stage ?? payload.status;
+  if (stage === "completed" || stage === "failed" || stage === "declined" || stage === "running") return stage;
+  if (stage === "pending_approval" || stage === "pending" || stage === "requires_approval") return "pending_approval";
+  return fallback;
+}
+function stableBoundary(text) {
+  let tokens;
+  try {
+    tokens = marked.lexer(text, { gfm: true });
+  } catch {
+    return 0;
+  }
+  let lastContent = -1;
+  tokens.forEach((token, i) => {
+    if (token.type !== "space") lastContent = i;
+  });
+  if (lastContent <= 0) return 0;
+  const prefix = tokens.slice(0, lastContent).map((t) => t.raw).join("");
+  if (!prefix || !text.startsWith(prefix) || !prefix.endsWith("\n")) return 0;
+  return prefix.length;
+}
+function normalizeText(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function isDestructiveTool(name) {
+  return /(delete|remove|revoke|withdraw|unpublish|send|close|reject|archive)/i.test(name);
+}
+
+// src/core/schema-flags.ts
+import { Option } from "commander";
+
+// src/core/schema-spec.ts
+var RESERVED_GLOBAL_FLAGS = [
+  "json",
+  "profile",
+  "debug",
+  "yes",
+  "quiet",
+  "color",
+  "no-color",
+  "api-url",
+  "app-url",
+  "help",
+  "version"
+];
+var RUN_LEVEL_FLAGS = ["input", "input-file", "fields", "wait", "timeout", "output"];
+var RESERVED = /* @__PURE__ */ new Set([...RESERVED_GLOBAL_FLAGS, ...RUN_LEVEL_FLAGS]);
+var TOOL_FLAGS_HELP_GROUP = "Tool flags:";
+function commanderAttr(flag) {
+  return flag.split("-").reduce((acc, word, index) => index === 0 ? word : acc + word.charAt(0).toUpperCase() + word.slice(1), "");
+}
+var ABBREVIATION = /(?:^|[\s(])(?:e\.g|i\.e|etc|vs|approx|incl|min|max)$/i;
+function shortDescription(text, max = 80) {
+  if (!text) return "";
+  const clean = text.replace(/\s+/g, " ").trim();
+  let end = clean.length;
+  for (const match of clean.matchAll(/[.!?](?=\s+[A-Z(]|$)/g)) {
+    const index = match.index ?? 0;
+    if (match[0] === "." && ABBREVIATION.test(clean.slice(0, index))) continue;
+    end = index + 1;
+    break;
+  }
+  const first = clean.slice(0, end).replace(/\.$/, "");
+  if (first.length <= max) return first;
+  return `${first.slice(0, max - 1).trimEnd()}${theme.symbols.ellipsis}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNullSchema(schema) {
+  return schema.type === "null" || Array.isArray(schema.enum) && schema.enum.length === 1 && schema.enum[0] === null;
+}
+function unwrapNullable(schema) {
+  let nullable = schema.nullable === true;
+  const union = schema.anyOf ?? schema.oneOf;
+  if (Array.isArray(union)) {
+    const nonNull = union.filter((member) => !isNullSchema(member));
+    if (nonNull.length < union.length) nullable = true;
+    if (nonNull.length === 1) {
+      const only = nonNull[0];
+      return { schema: { ...only, description: only.description ?? schema.description }, nullable };
+    }
+    return { schema: { ...schema, anyOf: nonNull, oneOf: void 0 }, nullable };
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length === 1) {
+    return unwrapNullable({ ...schema.allOf[0], description: schema.description });
+  }
+  if (Array.isArray(schema.type)) {
+    const types = schema.type.filter((type) => type !== "null");
+    if (types.length < schema.type.length) nullable = true;
+    if (types.length === 1) return { schema: { ...schema, type: types[0] }, nullable };
+  }
+  return { schema, nullable };
+}
+function scalarKind(schema) {
+  if (Array.isArray(schema.enum) && schema.enum.length > 0 && schema.enum.every((v) => typeof v === "string")) {
+    return "enum";
+  }
+  if (typeof schema.const === "string") return "enum";
+  switch (schema.type) {
+    case "string":
+      return "string";
+    case "number":
+      return "number";
+    case "integer":
+      return "integer";
+    case "boolean":
+      return "boolean";
+    default:
+      return null;
+  }
+}
+function enumValuesOf(schema) {
+  if (typeof schema.const === "string") return [schema.const];
+  return Array.isArray(schema.enum) ? schema.enum.filter((v) => typeof v === "string") : void 0;
+}
+function classify(schema) {
+  const scalar = scalarKind(schema);
+  if (scalar) return { kind: scalar, ...scalar === "enum" ? { enumValues: enumValuesOf(schema) } : {} };
+  if (schema.type === "array") {
+    const items = Array.isArray(schema.items) ? void 0 : schema.items;
+    const item = items ? unwrapNullable(items).schema : void 0;
+    const itemKind = item ? scalarKind(item) : null;
+    if (item && itemKind) {
+      return { kind: "array", itemKind, ...itemKind === "enum" ? { enumValues: enumValuesOf(item) } : {} };
+    }
+    return { kind: "json", jsonShape: "array" };
+  }
+  if (schema.type === "object" || schema.properties || schema.additionalProperties) {
+    return { kind: "json", jsonShape: "object" };
+  }
+  return { kind: "json", jsonShape: "any" };
+}
+function safeFlagName(property) {
+  const name = kebabCase(property).replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return name || "value";
+}
+function schemaToFlags(schema) {
+  const properties = isRecord(schema?.properties) ? schema?.properties : {};
+  const required = new Set(Array.isArray(schema?.required) ? schema.required : []);
+  const usedFlags = /* @__PURE__ */ new Set();
+  const usedAttrs = /* @__PURE__ */ new Set();
+  const specs = [];
+  for (const [property, rawProp] of Object.entries(properties)) {
+    const { schema: prop, nullable } = unwrapNullable(isRecord(rawProp) ? rawProp : {});
+    let flag = safeFlagName(property);
+    const renamed = RESERVED.has(flag) || flag.startsWith("no-");
+    if (renamed) flag = `in-${flag}`;
+    for (let n = 2; usedFlags.has(flag); n += 1) flag = `${flag.replace(/-\d+$/, "")}-${n}`;
+    usedFlags.add(flag);
+    const attr = commanderAttr(flag);
+    usedAttrs.add(attr);
+    const spec = {
+      property,
+      flag,
+      attr,
+      ...classify(prop),
+      nullable,
+      required: required.has(property),
+      description: shortDescription(prop.description ?? rawProp?.description ?? prop.title),
+      renamed,
+      ...prop.default !== void 0 ? { defaultValue: prop.default } : {}
+    };
+    specs.push(spec);
+  }
+  for (const spec of specs) {
+    const alias = spec.property;
+    if (spec.renamed || alias === spec.flag || !/^[A-Za-z][A-Za-z0-9_]*$/.test(alias)) continue;
+    const aliasAttr = commanderAttr(alias);
+    if (usedFlags.has(alias) || aliasAttr !== spec.attr && usedAttrs.has(aliasAttr)) continue;
+    spec.alias = alias;
+    spec.aliasAttr = aliasAttr;
+    usedAttrs.add(aliasAttr);
+  }
+  return specs;
+}
+function placeholderFor(spec) {
+  switch (spec.kind) {
+    case "boolean":
+      return "[boolean]";
+    case "number":
+      return "<number>";
+    case "integer":
+      return "<int>";
+    case "json":
+      return "<json>";
+    case "enum": {
+      const joined = (spec.enumValues ?? []).join("|");
+      return joined && joined.length <= 32 ? `<${joined}>` : "<choice>";
+    }
+    default:
+      return "<value>";
+  }
+}
+function flagNotes(spec) {
+  const notes = [];
+  if (spec.required) notes.push("required");
+  if (spec.kind === "enum" && placeholderFor(spec) === "<choice>") notes.push(`one of: ${spec.enumValues?.join(", ")}`);
+  if (spec.kind === "array") {
+    notes.push("repeatable or comma-separated");
+    if (spec.enumValues) notes.push(`each one of: ${spec.enumValues.join(", ")}`);
+  }
+  if (spec.kind === "json") notes.push(spec.jsonShape === "array" ? "JSON array" : spec.jsonShape === "object" ? "JSON object" : "JSON");
+  if (spec.renamed) notes.push(`schema field "${spec.property}"`);
+  if (spec.defaultValue !== void 0) notes.push(`default: ${JSON.stringify(spec.defaultValue)}`);
+  return notes;
+}
+
+// src/core/schema-flags.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collect(value, previous) {
+  return [...Array.isArray(previous) ? previous : [], value];
+}
+function schemaToOptions(schema, specs = schemaToFlags(schema)) {
+  const options = [];
+  for (const spec of specs) {
+    const notes = flagNotes(spec);
+    const help = [spec.description || spec.property, notes.length ? `(${notes.join("; ")})` : ""].filter(Boolean).join(" ");
+    const make = (flag) => {
+      const option = new Option(`--${flag} ${placeholderFor(spec)}`, help);
+      if (spec.kind === "array") option.argParser(collect);
+      return option;
+    };
+    options.push(make(spec.flag).helpGroup(TOOL_FLAGS_HELP_GROUP));
+    if (spec.alias) options.push(make(spec.alias).hideHelp());
+  }
+  return options;
+}
+function levenshtein(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i += 1) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const temp = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = temp;
+    }
+  }
+  return row[b.length];
+}
+function didYouMean(value, candidates) {
+  const needle = value.toLowerCase();
+  let best;
+  for (const candidate of candidates) {
+    const lower = candidate.toLowerCase();
+    const distance = lower.startsWith(needle) || needle.startsWith(lower) ? 1 : levenshtein(needle, lower);
+    if (!best || distance < best.distance) best = { candidate, distance };
+  }
+  return best && best.distance <= Math.max(2, Math.floor(needle.length / 3)) ? best.candidate : void 0;
+}
+function flagLabel(spec) {
+  return `--${spec.flag}`;
+}
+function coerceScalar(spec, kind, raw) {
+  const label = flagLabel(spec);
+  if (kind === "boolean") {
+    if (raw === true || raw === null || raw === void 0) return true;
+    if (raw === false) return false;
+    const text2 = String(raw).trim().toLowerCase();
+    if (["true", "yes", "1", "on"].includes(text2)) return true;
+    if (["false", "no", "0", "off"].includes(text2)) return false;
+    throw usageError(`${label} expects true or false, got "${String(raw)}"`);
+  }
+  const text = String(raw);
+  if (kind === "number" || kind === "integer") {
+    const value = Number(text.trim());
+    if (text.trim() === "" || !Number.isFinite(value)) throw usageError(`${label} expects a number, got "${text}"`);
+    if (kind === "integer" && !Number.isInteger(value)) throw usageError(`${label} expects a whole number, got "${text}"`);
+    return value;
+  }
+  if (kind === "enum") {
+    const allowed = spec.enumValues ?? [];
+    const exact = allowed.find((v) => v === text) ?? allowed.find((v) => v.toLowerCase() === text.toLowerCase());
+    if (exact !== void 0) return exact;
+    const guess = didYouMean(text, allowed);
+    throw usageError(
+      `${label} must be one of ${allowed.join(", ")}; got "${text}"`,
+      guess ? `Did you mean "${guess}"?` : void 0
+    );
+  }
+  return text;
+}
+function parseJsonFlag(spec, raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    if (spec.kind === "json" && spec.jsonShape === "any") return raw;
+    throw usageError(
+      `${flagLabel(spec)} expects JSON, got ${JSON.stringify(raw.length > 40 ? `${raw.slice(0, 40)}\u2026` : raw)}`,
+      `Quote it for the shell, e.g. ${flagLabel(spec)} '${spec.jsonShape === "array" ? "[\u2026]" : '{"key":"value"}'}'`
+    );
+  }
+}
+function coerce(spec, raw) {
+  if (spec.nullable && raw === "null") return null;
+  if (spec.kind === "array") {
+    const values = Array.isArray(raw) ? raw : [raw];
+    const items = [];
+    for (const value of values) {
+      const text = String(value);
+      if (text.trim().startsWith("[")) {
+        const parsed = parseJsonFlag(spec, text);
+        if (!Array.isArray(parsed)) throw usageError(`${flagLabel(spec)} expects a JSON array`);
+        items.push(...parsed);
+        continue;
+      }
+      for (const part of text.split(",")) {
+        const trimmed = part.trim();
+        if (trimmed) items.push(coerceScalar(spec, spec.itemKind ?? "string", trimmed));
+      }
+    }
+    return items;
+  }
+  if (spec.kind === "json") {
+    const parsed = typeof raw === "string" ? parseJsonFlag(spec, raw) : raw;
+    if (spec.jsonShape === "object" && !isRecord2(parsed)) throw usageError(`${flagLabel(spec)} expects a JSON object`);
+    if (spec.jsonShape === "array" && !Array.isArray(parsed)) throw usageError(`${flagLabel(spec)} expects a JSON array`);
+    return parsed;
+  }
+  return coerceScalar(spec, spec.kind, raw);
+}
+function parseToolInput(schema, opts, extras = {}) {
+  const specs = schemaToFlags(schema);
+  const input = { ...extras.base ?? {} };
+  for (const spec of specs) {
+    const primary = opts[spec.attr];
+    const alias = spec.aliasAttr && spec.aliasAttr !== spec.attr ? opts[spec.aliasAttr] : void 0;
+    let raw = primary !== void 0 ? primary : alias;
+    if (spec.kind === "array" && Array.isArray(primary) && Array.isArray(alias)) raw = [...alias, ...primary];
+    if (raw === void 0) continue;
+    input[spec.property] = coerce(spec, raw);
+  }
+  for (const [key, value] of Object.entries(extras.defaults ?? {})) {
+    if (input[key] === void 0 && value !== void 0) input[key] = value;
+  }
+  const required = Array.isArray(schema?.required) ? schema.required : [];
+  const missingRequired = required.filter((key) => input[key] === void 0);
+  return { input, missingRequired };
+}
+function flagsForProperties(schema, properties) {
+  const specs = schemaToFlags(schema);
+  return properties.map((property) => {
+    const spec = specs.find((s) => s.property === property);
+    return spec ? `--${spec.flag}` : property;
+  });
+}
+function typeLabel(spec) {
+  if (spec.kind === "enum") return (spec.enumValues ?? []).join("|");
+  if (spec.kind === "array") return `${spec.itemKind === "enum" ? "enum" : spec.itemKind ?? "string"}[]`;
+  if (spec.kind === "json") return spec.jsonShape === "any" ? "json" : spec.jsonShape ?? "json";
+  return spec.kind;
+}
+function describeSchema(schema) {
+  const rows = schemaToFlags(schema).map((spec) => ({
+    flag: `--${spec.flag}`,
+    ...spec.alias ? { alias: `--${spec.alias}` } : {},
+    property: spec.property,
+    type: typeLabel(spec),
+    required: spec.required,
+    nullable: spec.nullable,
+    description: spec.description,
+    notes: [...flagNotes(spec).filter((n) => n !== "required"), ...spec.nullable ? ['"null" clears it'] : []]
+  }));
+  return [...rows.filter((r) => r.required), ...rows.filter((r) => !r.required)];
+}
+function exampleValue(spec) {
+  switch (spec.kind) {
+    case "boolean":
+      return null;
+    case "enum":
+      return spec.enumValues?.[0] ?? "<value>";
+    case "number":
+    case "integer":
+      return "<n>";
+    case "array":
+      return spec.itemKind === "enum" ? spec.enumValues?.[0] ?? "<value>" : `<${spec.flag}>`;
+    case "json":
+      return spec.jsonShape === "array" ? `'[\u2026]'` : `'{\u2026}'`;
+    default:
+      return `<${spec.flag}>`;
+  }
+}
+function autoFilledProperties(tool, schema) {
+  return tool.kind === "workflow" && isRecord2(schema?.properties) && "userId" in (schema?.properties ?? {}) ? ["userId"] : [];
+}
+function exampleInvocation(tool, schema, commandPath = tool.commandPath) {
+  if (tool.kind === "agent") return `tabbio ${commandPath.join(" ")} "What jobs fit my CV?"`;
+  const skip = new Set(autoFilledProperties(tool, schema));
+  const parts = ["tabbio", ...commandPath];
+  for (const spec of schemaToFlags(schema)) {
+    if (!spec.required || skip.has(spec.property)) continue;
+    const value = exampleValue(spec);
+    parts.push(value === null ? `--${spec.flag}` : `--${spec.flag} ${value}`);
+  }
+  return parts.join(" ");
+}
+
+// src/ui/render.ts
+function isInteractiveTerminal(stdin = process.stdin, stdout = process.stdout) {
+  return Boolean(stdin.isTTY && stdout.isTTY);
+}
+function assertInteractive(what = "This screen", stdin = process.stdin, stdout = process.stdout) {
+  if (isInteractiveTerminal(stdin, stdout)) return;
+  throw new CliError({
+    code: "NOT_INTERACTIVE",
+    message: `${what} needs an interactive terminal`,
+    hint: "Run it in a terminal, or use the non-interactive form (e.g. --json, or pass the values as flags).",
+    exitCode: ExitCode.Usage
+  });
+}
+async function renderScreen(what, build, opts = {}) {
+  assertInteractive(what);
+  const { mountScreen } = await import("./mount-NGUARMCL.js");
+  return mountScreen(build, opts);
+}
+
+// src/ui/hooks.ts
+var registered = null;
+function setInteractiveHooks(hooks) {
+  registered = hooks;
+}
+function getInteractiveHooks() {
+  return registered;
+}
+function canUseInteractiveUi(ctx) {
+  return Boolean(
+    process.stdout.isTTY && process.stdin.isTTY && !ctx.globals.json && !process.env.CI && registered
+  );
+}
+
+// src/core/table.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getPath(value, path) {
+  let current = value;
+  for (const key of path.split(".")) {
+    if (!isRecord3(current)) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+var ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+function isRowList(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isRecord3);
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const char of text) {
+    const code = char.codePointAt(0) ?? 0;
+    if (code < 32 || code >= 127 && code < 160) continue;
+    if (code >= 768 && code <= 879 || code >= 8203 && code <= 8207 || code === 65039) continue;
+    const wide = code >= 4352 && code <= 4447 || code >= 11904 && code <= 42191 || code >= 44032 && code <= 55203 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65376 || code >= 65504 && code <= 65510 || code >= 127744 && code <= 129791 || code >= 131072 && code <= 262141;
+    width += wide ? 2 : 1;
+  }
+  return width;
+}
+function truncate(text, max) {
+  if (displayWidth(text) <= max) return text;
+  const ellipsis = theme.symbols.ellipsis;
+  const budget = Math.max(0, max - displayWidth(ellipsis));
+  let out = "";
+  let width = 0;
+  for (const char of text) {
+    const w = displayWidth(char);
+    if (width + w > budget) break;
+    out += char;
+    width += w;
+  }
+  return `${out}${ellipsis}`;
+}
+function pad(text, width, align) {
+  const fill = " ".repeat(Math.max(0, width - displayWidth(text)));
+  return align === "right" ? `${fill}${text}` : `${text}${fill}`;
+}
+function compactJson(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function humanCell(value, now = Date.now()) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "boolean") return value ? "yes" : "no";
+  if (typeof value === "string") {
+    if (ISO_DATE.test(value)) {
+      const date = new Date(value);
+      if (!Number.isNaN(date.getTime())) return relativeTime(date, now);
+    }
+    return value.replace(/\s+/g, " ").trim();
+  }
+  if (Array.isArray(value) && value.every((v) => v === null || typeof v !== "object")) {
+    return value.map((v) => humanCell(v, now)).join(", ");
+  }
+  if (typeof value === "object") return compactJson(value);
+  return String(value);
+}
+function tsvCell(value) {
+  if (value === null || value === void 0) return "";
+  const text = typeof value === "object" ? compactJson(value) : String(value);
+  return text.replace(/[\t\r\n]+/g, " ");
+}
+var MAX_COLUMNS = 6;
+var PRIORITY = [
+  ["id"],
+  ["title", "name"],
+  ["status", "state", "stage"],
+  ["company", "companyName", "employer"],
+  ["location"],
+  ["isPublic", "published", "visibility"],
+  ["updatedAt", "createdAt"]
+];
+var LOW_VALUE = /^(?:.+Id|.+_id|.+Ids|default[A-Z_].*|(?:.*[a-z])?[Ll]ocale)$/;
+var CONSTANT_MIN_ROWS = 3;
+function isScalar(value) {
+  return value === null || value === void 0 || typeof value !== "object";
+}
+function headerLabel(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toUpperCase();
+}
+function column(key, rows) {
+  const values = rows.map((r) => getPath(r, key)).filter((v) => v !== null && v !== void 0);
+  const numeric = values.length > 0 && values.every((v) => typeof v === "number");
+  return { key, label: headerLabel(key), align: numeric ? "right" : "left" };
+}
+var isEmpty = (value) => value === null || value === void 0 || value === "";
+function pickColumns(rows, fields) {
+  if (fields?.length) return fields.map((f) => column(f, rows));
+  const sample = rows.slice(0, 50);
+  const keys = [];
+  for (const row of sample) for (const key of Object.keys(row)) if (!keys.includes(key)) keys.push(key);
+  const usable = keys.filter(
+    (key) => sample.every((r) => isScalar(r[key]) || Array.isArray(r[key]) && r[key].every(isScalar)) && sample.some((r) => !isEmpty(r[key]))
+  );
+  const constant = (key) => new Set(rows.map((r) => JSON.stringify(r[key] ?? null))).size === 1;
+  const varying = rows.length >= CONSTANT_MIN_ROWS ? usable.filter((key) => !constant(key)) : usable;
+  const pool = varying.length ? varying : usable;
+  const chosen = [];
+  for (const group of PRIORITY) {
+    const key = group.find((k) => pool.includes(k));
+    if (key) chosen.push(key);
+  }
+  const avgLength = (key) => sample.reduce((sum, r) => sum + humanCell(r[key]).length, 0) / Math.max(1, sample.length);
+  const tier = (key) => {
+    if (LOW_VALUE.test(key)) return 3;
+    if (sample.filter((r) => isEmpty(r[key])).length * 2 > sample.length) return 2;
+    return avgLength(key) > 40 ? 1 : 0;
+  };
+  const rest = pool.filter((k) => !chosen.includes(k)).map((key, index) => ({ key, index, tier: tier(key) })).sort((a, b) => a.tier - b.tier || a.index - b.index);
+  for (const { key } of rest) {
+    if (chosen.length >= MAX_COLUMNS) break;
+    chosen.push(key);
+  }
+  return chosen.slice(0, MAX_COLUMNS).map((key) => column(key, rows));
+}
+function fitWidths(widths, max, gap = 2) {
+  const out = [...widths];
+  if (!max || max <= 0) return out;
+  const total = () => out.reduce((a, b) => a + b, 0) + gap * Math.max(0, out.length - 1);
+  const floor = 4;
+  while (total() > max) {
+    let widest = -1;
+    for (let i = 0; i < out.length; i += 1) {
+      if (out[i] > floor && (widest < 0 || out[i] > out[widest])) widest = i;
+    }
+    if (widest < 0) break;
+    out[widest] = out[widest] - 1;
+  }
+  return out;
+}
+function formatTable(rows, opts = {}) {
+  if (rows.length === 0) return [theme.dim("No results")];
+  const columns = pickColumns(rows, opts.fields);
+  if (columns.length === 0) return rows.map((r) => compactJson(r));
+  const cells = rows.map((row) => columns.map((c) => humanCell(getPath(row, c.key), opts.now)));
+  const natural = columns.map((c, i) => Math.max(displayWidth(c.label), ...cells.map((r) => displayWidth(r[i]))));
+  const widths = fitWidths(natural, opts.width);
+  const line = (values, style) => values.map((v, i) => {
+    const text = pad(truncate(v, widths[i]), widths[i], columns[i].align);
+    return style ? style(text) : text;
+  }).join("  ").trimEnd();
+  return [line(columns.map((c) => c.label), theme.dim), ...cells.map((r) => line(r))];
+}
+function formatKv(value, opts = {}) {
+  const keys = opts.fields?.length ? [...opts.fields] : Object.keys(value);
+  const rows = keys.map((key) => [key, getPath(value, key)]).filter(([, v]) => v !== void 0);
+  if (rows.length === 0) return [theme.dim("(empty)")];
+  const width = Math.max(...rows.map(([k]) => displayWidth(k)));
+  const lines = [];
+  for (const [key, raw] of rows) {
+    const label = theme.dim(pad(key, width, "left"));
+    if (typeof raw === "string" && !ISO_DATE.test(raw)) {
+      const [first = "", ...more] = raw.split(/\r?\n/);
+      lines.push(`${label}  ${first}`);
+      for (const next of more) lines.push(`${" ".repeat(width)}  ${next}`);
+      continue;
+    }
+    const text = isScalar(raw) || Array.isArray(raw) && raw.every(isScalar) ? humanCell(raw, opts.now) : compactJson(raw);
+    lines.push(`${label}  ${truncate(text, 100)}`);
+  }
+  return lines;
+}
+
+// src/core/output.ts
+var MODE_ALIASES = {
+  json: "json",
+  table: "table",
+  human: "table",
+  plain: "tsv",
+  tsv: "tsv"
+};
+var JSON_SCHEMA_VERSION = 1;
+function parseOutputMode(value, source = "--output") {
+  const mode = MODE_ALIASES[value.trim().toLowerCase()];
+  if (!mode) throw usageError(`${source} must be one of json, table, plain, tsv; got "${value}"`);
+  return mode;
+}
+function resolveOutputMode(opts, env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+  if (opts.json) return "json";
+  if (opts.output) return parseOutputMode(opts.output);
+  if (env.TABBIO_OUTPUT?.trim()) return parseOutputMode(env.TABBIO_OUTPUT, "TABBIO_OUTPUT");
+  return isTTY ? "table" : "tsv";
+}
+function parseFields(value) {
+  if (!value) return void 0;
+  const fields = value.split(",").map((f) => f.trim()).filter(Boolean);
+  return fields.length ? fields : void 0;
+}
+var COUNT_KEYS = ["total", "totalCount", "count"];
+function findListWrapper(value) {
+  if (!isRecord3(value) || "id" in value) return null;
+  const arrays = Object.entries(value).filter(([, v]) => Array.isArray(v));
+  if (arrays.length !== 1) return null;
+  const [key, list] = arrays[0];
+  if (list.length === 0) {
+    const counted = COUNT_KEYS.some((k) => typeof value[k] === "number");
+    return counted || Object.keys(value).length === 1 ? { key, rows: [] } : null;
+  }
+  return list.every(isRecord3) ? { key, rows: list } : null;
+}
+function countFooter(wrapper, key, shown) {
+  const parts = [`${shown} ${shown === 1 ? "item" : "items"}`];
+  const countKey = COUNT_KEYS.find((k) => typeof wrapper[k] === "number");
+  if (countKey) parts.push(`total ${wrapper[countKey]}`);
+  const others = Object.keys(wrapper).filter((k) => k !== key && k !== countKey);
+  if (others.length) parts.push("--json for all fields");
+  return parts.join(" \xB7 ");
+}
+function formatHuman(result, opts = {}) {
+  if (result === null || result === void 0) return [theme.dim("(no output)")];
+  if (typeof result === "string") return result.split(/\r?\n/);
+  if (!isRecord3(result) && !Array.isArray(result)) return [String(result)];
+  if (Array.isArray(result)) {
+    if (result.length === 0 || isRowList(result)) return formatTable(result, opts);
+    return result.map((item) => isScalar(item) ? humanCell(item, opts.now) : compactJson(item));
+  }
+  const wrapper = findListWrapper(result);
+  if (wrapper) {
+    return [...formatTable(wrapper.rows, opts), theme.dim(countFooter(result, wrapper.key, wrapper.rows.length))];
+  }
+  return formatKv(result, opts);
+}
+function toTsv(result, fields) {
+  const rowsToTsv = (rows) => {
+    const columns = pickColumns(rows, fields);
+    return rows.map((row) => columns.map((c) => tsvCell(getPath(row, c.key))).join("	"));
+  };
+  let lines;
+  if (result === null || result === void 0) lines = [];
+  else if (Array.isArray(result)) lines = isRowList(result) ? rowsToTsv(result) : result.map(tsvCell);
+  else if (isRecord3(result)) {
+    const wrapper = findListWrapper(result);
+    if (wrapper) lines = rowsToTsv(wrapper.rows);
+    else {
+      const keys = fields?.length ? fields : Object.keys(result);
+      lines = keys.map((key) => `${key}	${tsvCell(getPath(result, key))}`);
+    }
+  } else lines = [String(result)];
+  return lines.length ? `${lines.join("\n")}
+` : "";
+}
+function projectFields(result, fields) {
+  if (!fields?.length) return result;
+  const pick = (row) => Object.fromEntries(fields.map((f) => [f, getPath(row, f) ?? null]));
+  if (Array.isArray(result)) return result.map((item) => isRecord3(item) ? pick(item) : item);
+  if (isRecord3(result)) {
+    const wrapper = findListWrapper(result);
+    if (wrapper) return { ...result, [wrapper.key]: wrapper.rows.map(pick) };
+    return pick(result);
+  }
+  return result;
+}
+function jsonEnvelope(tool, data, meta) {
+  return {
+    data: data === void 0 ? null : data,
+    meta: {
+      schemaVersion: JSON_SCHEMA_VERSION,
+      tool: tool.id,
+      durationMs: Math.round(meta.durationMs),
+      ...meta.requestId ? { requestId: meta.requestId } : {},
+      ...meta.extra ?? {}
+    }
+  };
+}
+function writeJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, process.stdout.isTTY ? 2 : 0)}
+`);
+}
+function formatDuration(ms) {
+  if (ms < 6e4) return `${(Math.max(0, ms) / 1e3).toFixed(2)}s`;
+  const minutes = Math.floor(ms / 6e4);
+  return `${minutes}m ${Math.round(ms % 6e4 / 1e3)}s`;
+}
+function shortId(id) {
+  return id.length > 12 ? `${id.slice(0, 4)}${theme.symbols.ellipsis}${id.slice(-3)}` : id;
+}
+function formatResultHeader(tool, meta) {
+  const name = (tool.commandPath?.length ? tool.commandPath.join(" ") : tool.id).trim();
+  const right = [formatDuration(meta.durationMs), meta.requestId ? `req ${shortId(meta.requestId)}` : null].filter(Boolean).join(" \xB7 ");
+  const width = Math.min(meta.width ?? 80, 100);
+  const used = displayWidth(theme.symbols.success) + 1 + displayWidth(name) + 2 + displayWidth(right) + 1;
+  const rule = theme.symbols.line.repeat(Math.max(3, width - used));
+  return `${theme.success(theme.symbols.success)} ${theme.bold(name)} ${theme.accent(rule)} ${theme.dim(right)}`;
+}
+function printEmptyNotice(mode, message, opts = {}) {
+  if (mode === "json") return;
+  if (mode === "table") process.stdout.write(`${theme.dim(message)}
+`);
+  else if (!opts.quiet) process.stderr.write(`${theme.dim(message)}
+`);
+}
+async function renderResult(ctx, tool, result, meta) {
+  const mode = meta.mode ?? resolveOutputMode({ json: ctx.globals.json });
+  if (mode === "json") {
+    writeJson(jsonEnvelope(tool, projectFields(result, meta.fields), meta));
+    return;
+  }
+  if (mode === "tsv") {
+    process.stdout.write(toTsv(result, meta.fields));
+    return;
+  }
+  const hooks = getInteractiveHooks();
+  if (!meta.fields?.length && hooks?.showResult && canUseInteractiveUi(ctx) && "mcpName" in tool) {
+    await hooks.showResult(ctx, tool, result, { durationMs: meta.durationMs, requestId: meta.requestId });
+    return;
+  }
+  const width = meta.width ?? process.stdout.columns;
+  if (!ctx.globals.quiet) process.stdout.write(`${formatResultHeader(tool, { ...meta, width })}
+`);
+  for (const line of formatHuman(result, { fields: meta.fields, width })) process.stdout.write(`${line}
+`);
+}
+
+// src/core/chat-artifacts.ts
+var RESEARCH_TOOL_NAMES = /* @__PURE__ */ new Set(["webSearch", "readUrl", "readPdf", "readGithubRepo", "readSkill"]);
+var ARTIFACT_CARD_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "generateImage",
+  "createDocument",
+  "createPage",
+  "updatePage",
+  "updateDocument",
+  "editImage",
+  "artifactGet"
+]);
+var ARTIFACT_PRODUCING_TOOL_IDS = /* @__PURE__ */ new Set([
+  "artifact.generateImage",
+  "artifact.createDocument",
+  "artifact.createPage",
+  "artifact.updatePage",
+  "artifact.updateDocument",
+  "artifact.editImage"
+]);
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function isResearchTool(payload) {
+  return payload.cardType === "research" || RESEARCH_TOOL_NAMES.has(payload.name);
+}
+function isArtifactTool(payload) {
+  return payload.cardType === "artifact" || ARTIFACT_CARD_TOOL_NAMES.has(payload.name);
+}
+var STATUSES = /* @__PURE__ */ new Set(["pending", "ready", "failed"]);
+function artifactFromResult(result) {
+  if (!isRecord4(result)) return null;
+  const id = str(result.artifactId);
+  const status = str(result.status);
+  if (!id || !status || !STATUSES.has(status) || result.mode === "suggest") return null;
+  const failure = isRecord4(result.failure) ? { code: str(result.failure.code) ?? "FAILED", message: str(result.failure.message) ?? "" } : void 0;
+  return {
+    id,
+    kind: str(result.kind) ?? "file",
+    title: str(result.title) ?? "Untitled",
+    status,
+    ...typeof result.versionNumber === "number" ? { versionNumber: result.versionNumber } : {},
+    ...typeof result.previewAvailable === "boolean" ? { previewAvailable: result.previewAvailable } : {},
+    ...failure ? { failure } : {}
+  };
+}
+function sourcesFromResult(result) {
+  if (!isRecord4(result)) return [];
+  const raw = Array.isArray(result.sources) ? result.sources : isRecord4(result.source) ? [result.source] : [];
+  return raw.filter(isRecord4).flatMap((source) => {
+    const url = str(source.url);
+    if (!url) return [];
+    return [{ url, title: str(source.title) ?? url, ...str(source.domain) ? { domain: str(source.domain) } : {} }];
+  });
+}
+function mergeSources(existing, incoming) {
+  const seen = new Set(existing.map((s) => s.url));
+  const merged = [...existing];
+  for (const source of incoming) {
+    if (seen.has(source.url)) continue;
+    seen.add(source.url);
+    merged.push(source);
+  }
+  return merged;
+}
+var CAPABILITY_DENIAL_CODES = /* @__PURE__ */ new Set([
+  "SUBSCRIPTION_ENTITLEMENT_DENIED",
+  "RESEARCH_DISABLED",
+  "RESEARCH_NOT_CONFIGURED",
+  "RESEARCH_RATE_LIMITED",
+  "IMAGE_DISABLED",
+  "ARTIFACTS_DISABLED",
+  "ARTIFACT_EDITS_DISABLED",
+  "ARTIFACT_LIMIT_REACHED",
+  "SITES_DISABLED"
+]);
+var DENIAL_REASONS = {
+  capability_quota_reached: "daily quota",
+  artifact_edit_quota_reached: "daily edit quota",
+  wrong_tier: "plan tier",
+  ai_daily_limit_reached: "daily credits",
+  RESEARCH_DISABLED: "flag off",
+  IMAGE_DISABLED: "flag off",
+  ARTIFACTS_DISABLED: "flag off",
+  ARTIFACT_EDITS_DISABLED: "flag off",
+  SITES_DISABLED: "flag off",
+  RESEARCH_NOT_CONFIGURED: "not configured",
+  ARTIFACT_LIMIT_REACHED: "daily file cap",
+  RESEARCH_RATE_LIMITED: "hourly fetch cap"
+};
+function capabilityDenial(result) {
+  if (!isRecord4(result) || result.ok !== false || !isRecord4(result.error)) return null;
+  const code = str(result.error.code);
+  if (!code || !CAPABILITY_DENIAL_CODES.has(code)) return null;
+  const decision = isRecord4(result.error.decision) ? result.error.decision : void 0;
+  const reasonCode = str(decision?.reasonCode) ?? (Array.isArray(result.error.reasonCodes) ? str(result.error.reasonCodes[0]) : void 0) ?? code;
+  const reason = DENIAL_REASONS[reasonCode] ?? reasonCode.toLowerCase().replace(/_/g, " ");
+  return { code, message: str(result.error.message) ?? "This is not available right now.", reason };
+}
+var RESEARCH_VERBS = {
+  webSearch: ["Searching the web", "Searched the web"],
+  readUrl: ["Reading pages", "Read pages"],
+  readPdf: ["Reading a PDF", "Read a PDF"],
+  readGithubRepo: ["Reading a repository", "Read a repository"],
+  readSkill: ["Reading a skill", "Read a skill"]
+};
+function researchTitle(name, running) {
+  const verbs = RESEARCH_VERBS[name];
+  return verbs ? verbs[running ? 0 : 1] : null;
+}
+function applyDraft(previous, event) {
+  const base = previous ?? {
+    phase: event.phase,
+    kind: event.kind,
+    artifactId: event.artifactId,
+    chars: 0,
+    lines: 0,
+    sections: 0,
+    headings: 0
+  };
+  return {
+    ...base,
+    phase: event.phase,
+    kind: event.kind || base.kind,
+    artifactId: event.artifactId,
+    chars: event.stats?.chars ?? base.chars + (event.textChars ?? 0),
+    lines: event.stats?.lines ?? base.lines + (event.textLines ?? 0),
+    sections: event.stats?.sections ?? base.sections,
+    headings: event.outline ? event.outline.length : base.headings,
+    ...event.versionNumber !== void 0 ? { versionNumber: event.versionNumber } : {},
+    ...event.error ? { error: event.error.message || event.error.code } : {}
+  };
+}
+function draftSummary(draft) {
+  switch (draft.phase) {
+    case "start":
+      return "starting";
+    case "code":
+      return `writing \xB7 ${draft.lines} ${draft.lines === 1 ? "line" : "lines"}`;
+    case "outline":
+      return `writing \xB7 ${draft.headings} ${draft.headings === 1 ? "section" : "sections"}`;
+    case "snapshot":
+      return "previewing";
+    case "checking":
+      return "checking";
+    case "end":
+      return draft.versionNumber ? `version ${draft.versionNumber}` : "written";
+    case "error":
+      return `failed${draft.error ? `: ${draft.error}` : ""}`;
+    default:
+      return "";
+  }
+}
+function previewVariantFor(kind) {
+  return kind === "image" ? "image" : "html";
+}
+
+// src/core/artifacts.ts
+import { createWriteStream, existsSync, renameSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var ARTIFACT_KINDS = ["document", "slides", "image", "page", "file"];
+var PREVIEW_VARIANTS = ["html", "pdf", "image", "thumbnail"];
+var BASE = "/api/artifacts";
+var enc = encodeURIComponent;
+function listArtifacts(api, query = {}) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) if (value !== void 0 && value !== "") params.set(key, String(value));
+  const qs = params.toString();
+  return api.json(`${BASE}${qs ? `?${qs}` : ""}`);
+}
+function getArtifact(api, id) {
+  return api.json(`${BASE}/${enc(id)}`);
+}
+function previewUrl(api, id, opts) {
+  const params = new URLSearchParams({ variant: opts.variant, ...opts.theme ? { theme: opts.theme } : {}, ...opts.versionId ? { versionId: opts.versionId } : {} });
+  return api.json(`${BASE}/${enc(id)}/preview-url?${params.toString()}`);
+}
+function downloadUrl(api, id, opts) {
+  const params = new URLSearchParams({ variant: opts.variant, ...opts.versionId ? { versionId: opts.versionId } : {} });
+  return api.json(`${BASE}/${enc(id)}/download-url?${params.toString()}`);
+}
+function listVersions(api, id, opts = {}) {
+  const params = new URLSearchParams({ ...opts.limit ? { limit: String(opts.limit) } : {}, ...opts.cursor ? { cursor: opts.cursor } : {} });
+  const qs = params.toString();
+  return api.json(`${BASE}/${enc(id)}/versions${qs ? `?${qs}` : ""}`);
+}
+function restoreVersion(api, id, versionId) {
+  return api.json(
+    `${BASE}/${enc(id)}/versions/${enc(versionId)}/restore`,
+    { method: "POST", body: {} }
+  );
+}
+function deleteArtifact(api, id) {
+  return api.json(`${BASE}/${enc(id)}`, { method: "DELETE" });
+}
+function formatToVariant(format) {
+  const f = format.trim().toLowerCase().replace(/^\./, "");
+  if (f === "pdf" || f === "pptx" || f === "html") return f;
+  if (["image", "png", "jpg", "jpeg", "webp", "gif"].includes(f)) return "image";
+  throw usageError(`--format must be pdf, pptx, html or an image format (png, jpg, webp); got "${format}"`);
+}
+function defaultVariantFor(artifact) {
+  const v = artifact.variants;
+  const preferred = artifact.kind === "image" ? ["image"] : artifact.kind === "slides" ? ["pptx", "pdf", "html"] : artifact.kind === "page" ? ["html"] : ["pdf", "html", "pptx"];
+  return preferred.find((variant) => v?.[variant]) ?? preferred[0];
+}
+var IMAGE_EXT = { "image/png": "png", "image/jpeg": "jpg", "image/webp": "webp", "image/gif": "gif" };
+function extensionFor(variant, contentType) {
+  if (variant === "image") return IMAGE_EXT[(contentType ?? "").split(";")[0]?.trim().toLowerCase() ?? ""] ?? "png";
+  return variant;
+}
+function safeFileName(title, ext) {
+  const base = title.normalize("NFKC").replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 80).replace(/-+$/, "") || "artifact";
+  return `${base}.${ext}`;
+}
+function resolveOutputPath(out, fileName, cwd = process.cwd()) {
+  if (!out) return join(cwd, fileName);
+  try {
+    if (statSync(out).isDirectory()) return join(out, fileName);
+  } catch {
+  }
+  return out;
+}
+var WAIT_POLL_START_MS = 2e3;
+var WAIT_POLL_MAX_MS = 5e3;
+var DEFAULT_ARTIFACT_WAIT_MS = 5 * 6e4;
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function waitForArtifact(fetchStatus, opts = {}) {
+  const sleep = opts.sleep ?? defaultSleep;
+  const now = opts.now ?? Date.now;
+  const deadline = now() + (opts.timeoutMs ?? DEFAULT_ARTIFACT_WAIT_MS);
+  let interval = WAIT_POLL_START_MS;
+  let last = null;
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      last = await fetchStatus();
+      opts.onPoll?.({ status: last.status, attempt });
+      if (last.status !== "pending") return { artifact: last, timedOut: false };
+    } catch (error) {
+      if (!(error instanceof CliError) || error.exitCode !== ExitCode.Network) throw error;
+    }
+    const remaining = deadline - now();
+    if (remaining <= 0) return { artifact: last, timedOut: true };
+    await sleep(Math.min(interval, remaining));
+    interval = Math.min(WAIT_POLL_MAX_MS, Math.round(interval * 1.5));
+  }
+}
+async function downloadToFile(url, dest, opts = {}) {
+  if (existsSync(dest) && !opts.force) {
+    throw new CliError({
+      code: "FILE_EXISTS",
+      message: `${dest} already exists`,
+      hint: "Pass --force to overwrite it, or --out <path> for another name.",
+      exitCode: ExitCode.Usage
+    });
+  }
+  const fetchImpl = opts.fetch ?? ((...args) => fetch(...args));
+  let response;
+  try {
+    response = await fetchImpl(url, { signal: opts.signal });
+  } catch (error) {
+    throw networkError(new URL(url).origin, error);
+  }
+  if (!response.ok || !response.body) {
+    throw new CliError({
+      code: "DOWNLOAD_FAILED",
+      message: `The download failed (HTTP ${response.status})`,
+      hint: "Signed links last 15 minutes; run the command again for a fresh one.",
+      exitCode: response.status === 404 ? ExitCode.NotFound : response.status >= 500 ? ExitCode.Server : ExitCode.Error,
+      status: response.status
+    });
+  }
+  const totalHeader = Number(response.headers.get("content-length"));
+  const total = Number.isFinite(totalHeader) && totalHeader > 0 ? totalHeader : null;
+  const temp = `${dest}.part-${process.pid}`;
+  let received = 0;
+  const source = Readable.fromWeb(response.body);
+  source.on("data", (chunk) => {
+    received += chunk.length;
+    opts.onProgress?.({ received, total });
+  });
+  try {
+    await pipeline(source, createWriteStream(temp, { mode: 420 }), { signal: opts.signal });
+    if (existsSync(dest) && !opts.force) throw new CliError({ code: "FILE_EXISTS", message: `${dest} already exists`, exitCode: ExitCode.Usage });
+    renameSync(temp, dest);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    throw error;
+  }
+  return { path: dest, bytes: received, contentType: response.headers.get("content-type") };
+}
+
+// src/ui/hyperlink.ts
+function supportsHyperlinks(env = process.env, isTTY = Boolean(process.stdout.isTTY)) {
+  const forced = env.FORCE_HYPERLINK?.trim();
+  if (forced !== void 0 && forced !== "") return forced !== "0" && forced.toLowerCase() !== "false";
+  if (!isTTY || env.CI || env.TERM === "dumb" || env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+  if (env.WT_SESSION || env.KITTY_WINDOW_ID || env.WEZTERM_PANE || env.GHOSTTY_RESOURCES_DIR) return true;
+  if (env.TERM === "xterm-kitty" || env.TERM === "xterm-ghostty" || env.TERM === "alacritty") return true;
+  const vte = Number.parseInt(env.VTE_VERSION ?? "", 10);
+  if (Number.isFinite(vte) && vte >= 5e3) return true;
+  switch (env.TERM_PROGRAM) {
+    case "iTerm.app": {
+      const [major = 0, minor = 0] = (env.TERM_PROGRAM_VERSION ?? "").split(".").map((n) => Number.parseInt(n, 10) || 0);
+      return major > 3 || major === 3 && minor >= 1;
+    }
+    case "WezTerm":
+    case "vscode":
+    case "ghostty":
+    case "Hyper":
+    case "Tabby":
+      return true;
+    default:
+      return false;
+  }
+}
+var OSC = "\x1B]8;;";
+var BEL = "\x07";
+function hyperlink(text, url) {
+  const safe = [...url].filter((ch) => ch.charCodeAt(0) > 31 && ch.charCodeAt(0) !== 127).join("");
+  return `${OSC}${safe}${BEL}${text}${OSC}${BEL}`;
+}
+
+// src/core/chat.ts
+import { createParser } from "eventsource-parser";
+
+// src/core/chat-events.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function toolPayload(raw) {
+  const id = asString(raw.id);
+  const name = asString(raw.name);
+  if (!id || !name) return null;
+  return {
+    ...raw,
+    id,
+    name,
+    args: isRecord5(raw.args) ? raw.args : {},
+    display: isRecord5(raw.display) ? raw.display : void 0
+  };
+}
+var DRAFT_PHASES = /* @__PURE__ */ new Set(["start", "code", "outline", "snapshot", "checking", "end", "error"]);
+function draftPayload(raw) {
+  const toolCallId = asString(raw.toolCallId);
+  const artifactId = asString(raw.artifactId);
+  const phase = asString(raw.phase);
+  if (!toolCallId || !artifactId || !phase || !DRAFT_PHASES.has(phase)) return null;
+  const text = asString(raw.text);
+  const stats = isRecord5(raw.stats) ? raw.stats : void 0;
+  const error = isRecord5(raw.error) ? raw.error : void 0;
+  return {
+    toolCallId,
+    artifactId,
+    kind: asString(raw.kind) ?? "document",
+    ...raw.mode === "create" || raw.mode === "edit" ? { mode: raw.mode } : {},
+    title: asString(raw.title) ?? "",
+    seq: asNumber(raw.seq) ?? 0,
+    phase,
+    ...text ? { textChars: text.length, textLines: text.split("\n").length - 1 } : {},
+    ...Array.isArray(raw.outline) ? {
+      outline: raw.outline.filter(isRecord5).map((entry) => ({ heading: asString(entry.heading) ?? "", done: entry.done === true }))
+    } : {},
+    ...stats ? { stats: { chars: asNumber(stats.chars) ?? 0, lines: asNumber(stats.lines) ?? 0, sections: asNumber(stats.sections) ?? 0 } } : {},
+    ...asNumber(raw.versionNumber) !== void 0 ? { versionNumber: asNumber(raw.versionNumber) } : {},
+    ...error ? { error: { code: asString(error.code) ?? "ERROR", message: asString(error.message) ?? "" } } : {}
+  };
+}
+function parseStreamEvent(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!isRecord5(parsed) || typeof parsed.type !== "string") return null;
+  const payload = isRecord5(parsed.payload) ? parsed.payload : {};
+  switch (parsed.type) {
+    case "start":
+      return {
+        type: "start",
+        payload: {
+          threadId: asString(payload.threadId),
+          mastraThreadId: asString(payload.mastraThreadId),
+          mode: payload.mode === "employer" ? "employer" : payload.mode === "seeker" ? "seeker" : void 0,
+          modelId: asString(payload.modelId)
+        }
+      };
+    case "text-delta":
+      return { type: "text-delta", payload: { text: asString(payload.text) ?? "" } };
+    case "tool-call":
+    case "tool-result": {
+      const tool = toolPayload(payload);
+      return tool ? { type: parsed.type, payload: tool } : null;
+    }
+    case "tool-call-approval": {
+      const tool = toolPayload(payload);
+      const approvalId = asString(payload.approvalId);
+      return tool && approvalId ? { type: "tool-call-approval", payload: { ...tool, approvalId } } : null;
+    }
+    case "artifact-draft": {
+      const draft = draftPayload(payload);
+      return draft ? { type: "artifact-draft", payload: draft } : null;
+    }
+    case "error":
+      return { type: "error", payload: { message: asString(payload.message) ?? "Tabbio hit an error" } };
+    case "finish":
+      return {
+        type: "finish",
+        payload: {
+          threadId: asString(payload.threadId),
+          runId: asString(payload.runId),
+          finishReason: asString(payload.finishReason),
+          text: asString(payload.text),
+          messageId: asString(payload.messageId)
+        }
+      };
+    default:
+      return null;
+  }
+}
+
+// src/core/chat-tool-extras.ts
+function holdsArtifact(call) {
+  const artifact = call.artifact;
+  return Boolean(artifact && !artifact.released && (artifact.status === "pending" || artifact.linkPending));
+}
+function withLinkState(artifact, links) {
+  const linkPending = links && artifact.status === "ready" && !artifact.previewUrl;
+  return { ...artifact, linkPending };
+}
+function toolExtras(payload, stage, opts) {
+  const extras = {};
+  if (isResearchTool(payload)) {
+    extras.research = true;
+    const title = researchTitle(payload.name, stage === "running");
+    if (title) extras.title = title;
+    if (payload.result !== void 0) {
+      const sources = sourcesFromResult(payload.result);
+      if (sources.length) extras.sources = sources;
+    }
+  }
+  if (payload.result !== void 0) {
+    const denial = capabilityDenial(payload.result);
+    if (denial) extras.denial = denial;
+    if (isArtifactTool(payload) || opts.previous?.draft) {
+      const artifact = artifactFromResult(payload.result);
+      if (artifact) {
+        const previous = opts.previous?.artifact;
+        const merged = previous?.id === artifact.id && previous.previewUrl ? { ...artifact, previewUrl: previous.previewUrl } : artifact;
+        extras.artifact = withLinkState(merged, opts.links);
+      }
+    }
+  }
+  return extras;
+}
+function patchArtifact(artifact, action, links) {
+  const next = {
+    ...artifact,
+    ...action.status ? { status: action.status } : {},
+    ...action.title ? { title: action.title } : {},
+    ...action.previewUrl ? { previewUrl: action.previewUrl } : {},
+    ...action.failure ? { failure: action.failure } : {},
+    ...action.release ? { released: true } : {}
+  };
+  const linked = withLinkState(next, links && !action.release);
+  return action.previewUrl === void 0 && action.status === void 0 && artifact.status === "ready" ? { ...linked, linkPending: false } : linked;
+}
+function lastShownArtifact(entries, artifactId) {
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i];
+    if (entry.kind === "tool" && entry.call.artifact?.id === artifactId) return entry.call.artifact;
+    if (entry.kind === "artifact" && entry.artifact.id === artifactId) return entry.artifact;
+  }
+  return void 0;
+}
+
+// src/core/chat-transcript.ts
+function nextId(d, prefix) {
+  d.state = { ...d.state, seq: d.state.seq + 1 };
+  return `${prefix}-${d.state.seq}`;
+}
+function push(d, entry) {
+  d.state = { ...d.state, entries: [...d.state.entries, entry] };
+}
+function setTurn(d, turn) {
+  d.state = { ...d.state, turn };
+}
+function commitMarkdown(d, turn, text) {
+  if (!text.trim()) return turn;
+  push(d, { kind: "markdown", id: nextId(d, "md"), text, gap: turn.lastKind !== "label" });
+  return { ...turn, committedText: true, lastKind: "markdown" };
+}
+function promote(d, final, force = false) {
+  let turn = d.state.turn;
+  if (!turn) return;
+  const items = [...turn.items];
+  while (items.length > 0) {
+    const item = items[0];
+    if (item.kind === "tool") {
+      if (!force && (!FINAL_STAGES.has(item.call.stage) && !item.call.left || holdsArtifact(item.call))) break;
+      const call = item.call.artifact ? { ...item.call, artifact: { ...item.call.artifact, linkPending: false } } : item.call;
+      push(d, { kind: "tool", id: nextId(d, "tool"), call, gap: turn.lastKind === "markdown" });
+      turn = { ...turn, lastKind: "tool" };
+      items.shift();
+      continue;
+    }
+    const pending = item.text.slice(item.committed);
+    if (item.closed || final) {
+      turn = commitMarkdown(d, turn, pending);
+      items.shift();
+      continue;
+    }
+    const boundary = stableBoundary(pending);
+    if (boundary > 0) {
+      turn = commitMarkdown(d, turn, pending.slice(0, boundary));
+      items[0] = { ...item, committed: item.committed + boundary };
+    }
+    break;
+  }
+  turn = { ...turn, items };
+  const settled = (turn.finished || force) && items.length === 0;
+  if (settled && turn.sources.length) push(d, { kind: "sources", id: nextId(d, "sources"), sources: turn.sources });
+  setTurn(d, settled ? null : turn);
+}
+function closeOpenText(items) {
+  return items.map((item) => item.kind === "text" && !item.closed ? { ...item, closed: true } : item);
+}
+function upsertTool(d, payload, stage, extra = {}) {
+  const turn = d.state.turn;
+  if (!turn) return;
+  const index = turn.items.findIndex((item) => item.kind === "tool" && item.call.id === payload.id);
+  const final = FINAL_STAGES.has(stage);
+  const previous = index >= 0 ? turn.items[index].call : void 0;
+  const enriched = toolExtras(payload, stage, { links: d.state.links, previous });
+  extra = { ...enriched, ...extra };
+  if (enriched.sources?.length) {
+    setTurn(d, { ...turn, sources: mergeSources(turn.sources, enriched.sources) });
+  }
+  if (index >= 0) {
+    const item = turn.items[index];
+    const finishing = final && item.call.endedAt === void 0;
+    const call2 = {
+      ...item.call,
+      stage,
+      args: Object.keys(payload.args).length ? payload.args : item.call.args,
+      ...payload.result !== void 0 ? { result: payload.result } : {},
+      preview: payload.display?.preview ?? item.call.preview,
+      ...finishing ? { endedAt: d.now, durationMs: Math.max(0, d.now - item.call.startedAt) } : {},
+      ...extra
+    };
+    const current2 = d.state.turn;
+    const items = [...current2.items];
+    items[index] = { ...item, call: call2 };
+    setTurn(d, { ...current2, items });
+    return;
+  }
+  const call = {
+    id: payload.id,
+    name: payload.name,
+    title: toolTitle(payload),
+    args: payload.args,
+    stage,
+    ...payload.result !== void 0 ? { result: payload.result } : {},
+    preview: payload.display?.preview,
+    startedAt: d.now,
+    ...final ? { endedAt: d.now } : {},
+    ...extra
+  };
+  const current = d.state.turn;
+  setTurn(d, { ...current, items: [...closeOpenText(current.items), { kind: "tool", id: payload.id, call }] });
+}
+function applyArtifactDraft(d, event) {
+  const turn = d.state.turn;
+  const index = turn?.items.findIndex((item2) => item2.kind === "tool" && item2.call.id === event.toolCallId) ?? -1;
+  if (!turn || index < 0) return;
+  const item = turn.items[index];
+  const items = [...turn.items];
+  items[index] = { ...item, call: { ...item.call, draft: applyDraft(item.call.draft, event) } };
+  setTurn(d, { ...turn, items });
+}
+function applyArtifactStatus(d, action) {
+  const turn = d.state.turn;
+  const index = turn?.items.findIndex((item) => item.kind === "tool" && item.call.artifact?.id === action.artifactId) ?? -1;
+  if (turn && index >= 0) {
+    const item = turn.items[index];
+    const artifact = patchArtifact(item.call.artifact, action, d.state.links);
+    const items = [...turn.items];
+    items[index] = { ...item, call: { ...item.call, artifact } };
+    setTurn(d, { ...turn, items });
+    promote(d, false);
+    return;
+  }
+  const shown = lastShownArtifact(d.state.entries, action.artifactId);
+  if (!shown || action.release) return;
+  const next = { ...patchArtifact(shown, action, false), linkPending: false };
+  if (next.status === shown.status && next.previewUrl === shown.previewUrl) return;
+  push(d, { kind: "artifact", id: nextId(d, "artifact"), artifact: next });
+}
+function finishTurn(d, payload) {
+  let turn = d.state.turn;
+  if (!turn) return;
+  const finalText = payload.text?.trim() ?? "";
+  let items = closeOpenText(turn.items);
+  let revision = null;
+  let extraNote = null;
+  if (payload.finishReason === "error") {
+    if (!turn.error && finalText) turn = { ...turn, error: finalText };
+    else if (finalText && normalizeText(finalText) !== normalizeText(turn.error ?? "")) extraNote = finalText;
+  } else if (finalText && normalizeText(finalText) !== normalizeText(turn.text)) {
+    if (!normalizeText(turn.text) || !turn.committedText) {
+      items = [...items.filter((item) => item.kind !== "text"), { kind: "text", id: "final", text: finalText, committed: 0, closed: true }];
+    } else {
+      revision = finalText;
+    }
+  }
+  turn = { ...turn, items, finished: true, finishReason: payload.finishReason };
+  if (payload.threadId) d.state = { ...d.state, threadId: payload.threadId };
+  setTurn(d, turn);
+  promote(d, true);
+  if (revision) {
+    push(d, { kind: "notice", id: nextId(d, "note"), tone: "info", text: "Tabbio revised this answer:" });
+    push(d, { kind: "markdown", id: nextId(d, "md"), text: revision, gap: false });
+  }
+  if (turn.error) push(d, { kind: "notice", id: nextId(d, "note"), tone: "error", text: turn.error });
+  if (extraNote) push(d, { kind: "notice", id: nextId(d, "note"), tone: "info", text: extraNote });
+  d.state = { ...d.state, streaming: false };
+}
+function applyStream(d, event) {
+  const turn = d.state.turn;
+  if (event.type === "start") {
+    d.state = {
+      ...d.state,
+      threadId: event.payload.threadId ?? d.state.threadId,
+      modelId: event.payload.modelId ?? d.state.modelId
+    };
+    return;
+  }
+  if (!turn || turn.finished) return;
+  setTurn(d, { ...turn, lastEventAt: d.now });
+  switch (event.type) {
+    case "text-delta": {
+      if (!event.payload.text) return;
+      const current = d.state.turn;
+      const items = [...current.items];
+      const last = items[items.length - 1];
+      if (last?.kind === "text" && !last.closed) items[items.length - 1] = { ...last, text: last.text + event.payload.text };
+      else items.push({ kind: "text", id: nextId(d, "text"), text: event.payload.text, committed: 0, closed: false });
+      setTurn(d, { ...current, items, text: current.text + event.payload.text });
+      return;
+    }
+    case "tool-call":
+      upsertTool(d, event.payload, stageOf(event.payload, "running"));
+      promote(d, false);
+      return;
+    case "tool-result":
+      upsertTool(d, event.payload, stageOf(event.payload, "completed"));
+      promote(d, false);
+      return;
+    case "artifact-draft":
+      applyArtifactDraft(d, event.payload);
+      return;
+    case "tool-call-approval": {
+      upsertTool(d, event.payload, "pending_approval", { approvalId: event.payload.approvalId });
+      const approval = {
+        approvalId: event.payload.approvalId,
+        toolCallId: event.payload.id,
+        name: event.payload.name,
+        title: toolTitle(event.payload),
+        args: event.payload.args,
+        requestedAt: d.now
+      };
+      const others = d.state.approvals.filter((a) => a.approvalId !== approval.approvalId);
+      d.state = { ...d.state, approvals: [...others, approval] };
+      promote(d, false);
+      return;
+    }
+    case "error":
+      setTurn(d, { ...d.state.turn, error: event.payload.message });
+      return;
+    case "finish":
+      finishTurn(d, event.payload);
+      return;
+  }
+}
+function resolveApproval(d, action) {
+  const approval = d.state.approvals.find((a) => a.approvalId === action.approvalId);
+  d.state = { ...d.state, approvals: d.state.approvals.filter((a) => a.approvalId !== action.approvalId) };
+  if (!approval) return;
+  const decision = action.error ? "leave" : action.decision;
+  const stage = decision === "approve" ? "completed" : decision === "reject" ? "declined" : "pending_approval";
+  const decided = { stage, decision, left: decision === "leave", endedAt: d.now };
+  const waited = { durationMs: Math.max(0, d.now - approval.requestedAt) };
+  const turn = d.state.turn;
+  const live = turn?.items.some((item) => item.kind === "tool" && item.call.id === approval.toolCallId);
+  if (turn && live) {
+    const items = turn.items.map(
+      (item) => item.kind === "tool" && item.call.id === approval.toolCallId ? { ...item, call: { ...item.call, ...decided, ...waited } } : item
+    );
+    setTurn(d, { ...turn, items });
+    promote(d, false);
+  } else {
+    const call = {
+      id: approval.toolCallId,
+      name: approval.name,
+      title: approval.title,
+      args: approval.args,
+      approvalId: approval.approvalId,
+      startedAt: approval.requestedAt,
+      ...decided,
+      ...waited
+    };
+    push(d, { kind: "tool", id: nextId(d, "tool"), call, gap: false });
+  }
+  if (action.error) push(d, { kind: "notice", id: nextId(d, "note"), tone: "error", text: action.error });
+  if (action.text?.trim()) push(d, { kind: "markdown", id: nextId(d, "md"), text: action.text.trim(), gap: true });
+}
+function chatReducer(state, action) {
+  return reduceChat(state, action, Date.now);
+}
+function reduceChat(state, action, now) {
+  const d = { state, now: "at" in action && typeof action.at === "number" ? action.at : now() };
+  switch (action.type) {
+    case "submit": {
+      if (d.state.turn) promote(d, true, true);
+      push(d, { kind: "user", id: nextId(d, "user"), text: action.text });
+      push(d, { kind: "assistant", id: nextId(d, "label") });
+      const turn = {
+        id: `turn-${d.state.seq}`,
+        startedAt: d.now,
+        lastEventAt: d.now,
+        items: [],
+        text: "",
+        committedText: false,
+        lastKind: "label",
+        finished: false,
+        sources: []
+      };
+      d.state = { ...d.state, turn, streaming: true };
+      return d.state;
+    }
+    case "tick":
+      promote(d, false);
+      return d.state;
+    case "stream-failed": {
+      const turn = d.state.turn;
+      if (turn && !turn.finished) {
+        setTurn(d, { ...turn, items: closeOpenText(turn.items), finished: true });
+        promote(d, true);
+      }
+      push(d, {
+        kind: "notice",
+        id: nextId(d, "note"),
+        tone: action.cancelled ? "attention" : "error",
+        text: action.message,
+        ...action.hint ? { hint: action.hint } : {}
+      });
+      d.state = { ...d.state, streaming: false };
+      return d.state;
+    }
+    case "approval-decided":
+      resolveApproval(d, action);
+      return d.state;
+    case "notice":
+      push(d, { kind: "notice", id: nextId(d, "note"), tone: action.tone, text: action.text, ...action.hint ? { hint: action.hint } : {} });
+      return d.state;
+    case "new-thread":
+      d.state = { ...d.state, threadId: void 0 };
+      return d.state;
+    case "set-thread":
+      d.state = { ...d.state, threadId: action.threadId };
+      return d.state;
+    case "history":
+      d.state = { ...d.state, threadId: action.threadId };
+      for (const message of action.messages) {
+        if (!message.text.trim()) continue;
+        if (message.role === "user") push(d, { kind: "user", id: nextId(d, "user"), text: message.text });
+        else {
+          push(d, { kind: "assistant", id: nextId(d, "label") });
+          push(d, { kind: "markdown", id: nextId(d, "md"), text: message.text, gap: false });
+        }
+      }
+      return d.state;
+    case "set-mode":
+      d.state = { ...d.state, mode: action.mode, threadId: void 0 };
+      return d.state;
+    case "set-model":
+      d.state = { ...d.state, modelId: action.modelId };
+      return d.state;
+    case "set-capability":
+      d.state = { ...d.state, capabilities: { ...d.state.capabilities, [action.key]: action.value } };
+      return d.state;
+    case "artifact-status":
+      applyArtifactStatus(d, action);
+      return d.state;
+    case "expand-last-tool": {
+      const last = [...d.state.entries].reverse().find((e) => e.kind === "tool");
+      if (last) push(d, { kind: "tool-detail", id: nextId(d, "detail"), call: last.call });
+      return d.state;
+    }
+    default:
+      applyStream(d, action);
+      return d.state;
+  }
+}
+
+// src/core/chat.ts
+var CHAT_PATH = "/api/agent/chat";
+var DEFAULT_IDLE_MS = 9e4;
+var DEFAULT_TURN_MS = 30 * 6e4;
+function agentHeaders(mode, companyId) {
+  return { "x-agent-mode": mode, ...companyId ? { "x-company-id": companyId } : {} };
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEventStream(response) {
+  return (response.headers.get("content-type") ?? "").toLowerCase().includes("text/event-stream");
+}
+async function* streamChat(ctx, request, opts = {}) {
+  for await (const frame of streamChatFrames(ctx, request, opts)) {
+    if (frame.event) yield frame.event;
+    else debug(`chat: skipped stream event ${frame.data.slice(0, 80)}`);
+  }
+}
+async function* streamChatFrames(ctx, request, opts = {}) {
+  const { companyId, ...body } = request;
+  const controller = new AbortController();
+  const userSignal = opts.signal;
+  const onUserAbort = () => controller.abort(userSignal?.reason);
+  if (userSignal?.aborted) throw interruptedError("Chat turn cancelled");
+  userSignal?.addEventListener("abort", onUserAbort, { once: true });
+  let stalled = false;
+  let idleTimer;
+  const armIdle = () => {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      stalled = true;
+      controller.abort(new Error("stream stalled"));
+    }, opts.idleTimeoutMs ?? DEFAULT_IDLE_MS);
+    idleTimer.unref?.();
+  };
+  const mapError = (error) => {
+    if (userSignal?.aborted) return interruptedError("Chat turn cancelled");
+    if (stalled) {
+      return new CliError({
+        code: "TIMEOUT",
+        message: "Tabbio stopped responding",
+        hint: "The stream went quiet. Try again; your thread keeps its history.",
+        exitCode: ExitCode.Network,
+        cause: error
+      });
+    }
+    if (error instanceof CliError) return error;
+    return networkError(`${ctx.api.profile.apiUrl}${CHAT_PATH}`, error);
+  };
+  let reader;
+  let done = false;
+  try {
+    armIdle();
+    let response;
+    try {
+      response = await ctx.api.raw(CHAT_PATH, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "text/event-stream",
+          ...agentHeaders(body.mode, companyId)
+        },
+        body: JSON.stringify(companyId ? { ...body, companyId } : body),
+        signal: controller.signal,
+        timeoutMs: opts.timeoutMs ?? DEFAULT_TURN_MS
+      });
+    } catch (error) {
+      throw mapError(error);
+    }
+    if (!response.ok || !isEventStream(response)) {
+      await parseJsonResponse(response);
+      throw new CliError({
+        code: "BAD_RESPONSE",
+        message: "Tabbio answered the chat request without a stream",
+        exitCode: ExitCode.Server,
+        status: response.status
+      });
+    }
+    if (!response.body) throw new CliError({ code: "BAD_RESPONSE", message: "Empty chat stream", exitCode: ExitCode.Server });
+    const queue = [];
+    const parser = createParser({
+      onEvent(message) {
+        if (message.data.trim()) queue.push({ data: message.data, event: parseStreamEvent(message.data) });
+      }
+    });
+    const decoder = new TextDecoder();
+    const activeReader = response.body.getReader();
+    reader = activeReader;
+    let sawFinish = false;
+    for (; ; ) {
+      let chunk;
+      try {
+        chunk = await activeReader.read();
+      } catch (error) {
+        throw mapError(error);
+      }
+      if (chunk.done) break;
+      armIdle();
+      parser.feed(decoder.decode(chunk.value, { stream: true }));
+      while (queue.length > 0) {
+        const frame = queue.shift();
+        if (frame.event?.type === "finish") sawFinish = true;
+        yield frame;
+      }
+    }
+    parser.feed(`${decoder.decode()}
+
+`);
+    while (queue.length > 0) {
+      const frame = queue.shift();
+      if (frame.event?.type === "finish") sawFinish = true;
+      yield frame;
+    }
+    done = true;
+    if (!sawFinish) {
+      if (userSignal?.aborted) throw interruptedError("Chat turn cancelled");
+      throw new CliError({
+        code: "STREAM_ENDED",
+        message: "The chat stream ended before Tabbio finished",
+        hint: "Check your connection and try again.",
+        exitCode: ExitCode.Network,
+        retry: true
+      });
+    }
+  } finally {
+    clearTimeout(idleTimer);
+    userSignal?.removeEventListener("abort", onUserAbort);
+    if (reader && !done) {
+      controller.abort();
+      await reader.cancel().catch(() => void 0);
+    }
+  }
+}
+function listThreads(ctx, scope) {
+  const query = new URLSearchParams({ mode: scope.mode, ...scope.companyId ? { companyId: scope.companyId } : {} });
+  return ctx.api.json(`/api/agent/threads?${query.toString()}`, {
+    headers: agentHeaders(scope.mode, scope.companyId)
+  });
+}
+async function getThreadMessages(ctx, threadId, scope) {
+  const data = await ctx.api.json(
+    `/api/agent/threads/${encodeURIComponent(threadId)}/messages`,
+    { headers: agentHeaders(scope.mode, scope.companyId) }
+  );
+  return { messages: data?.messages ?? [], toolCalls: data?.toolCalls ?? [] };
+}
+function decide(ctx, approvalId, action, scope) {
+  return ctx.api.json(`/api/agent/approvals/${encodeURIComponent(approvalId)}/${action}`, {
+    method: "POST",
+    body: scope?.reason ? { reason: scope.reason } : {},
+    headers: scope?.mode ? agentHeaders(scope.mode, scope.companyId) : void 0,
+    // Confirming resumes the agent run server-side; it can take a while.
+    timeoutMs: 5 * 6e4
+  });
+}
+function confirmApproval(ctx, approvalId, scope) {
+  return decide(ctx, approvalId, "confirm", scope);
+}
+function rejectApproval(ctx, approvalId, scope) {
+  return decide(ctx, approvalId, "reject", scope);
+}
+function listModels(ctx, scope) {
+  return ctx.api.json(`/api/agent/models?mode=${encodeURIComponent(scope.mode)}`, {
+    headers: agentHeaders(scope.mode, scope.companyId)
+  });
+}
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map((part) => isRecord6(part) && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
+  }
+  if (isRecord6(content) && typeof content.text === "string") return content.text;
+  return "";
+}
+
+export {
+  setInteractiveHooks,
+  getInteractiveHooks,
+  canUseInteractiveUi,
+  getPath,
+  displayWidth,
+  truncate,
+  humanCell,
+  pickColumns,
+  formatTable,
+  formatKv,
+  resolveOutputMode,
+  parseFields,
+  findListWrapper,
+  toTsv,
+  jsonEnvelope,
+  writeJson,
+  formatDuration,
+  printEmptyNotice,
+  renderResult,
+  ARTIFACT_PRODUCING_TOOL_IDS,
+  artifactFromResult,
+  sourcesFromResult,
+  mergeSources,
+  capabilityDenial,
+  draftSummary,
+  previewVariantFor,
+  ARTIFACT_KINDS,
+  PREVIEW_VARIANTS,
+  listArtifacts,
+  getArtifact,
+  previewUrl,
+  downloadUrl,
+  listVersions,
+  restoreVersion,
+  deleteArtifact,
+  formatToVariant,
+  defaultVariantFor,
+  extensionFor,
+  safeFileName,
+  resolveOutputPath,
+  waitForArtifact,
+  downloadToFile,
+  supportsHyperlinks,
+  hyperlink,
+  DEFAULT_CAPABILITIES,
+  CAPABILITY_CHOICES,
+  CAPABILITY_CHOICE_HELP,
+  parseCapabilityMode,
+  loadCapabilityPrefs,
+  saveCapabilityPrefs,
+  resolveCapabilities,
+  capabilityRequestFields,
+  unavailableNotices,
+  initialChatState,
+  isDestructiveTool,
+  chatReducer,
+  streamChat,
+  streamChatFrames,
+  listThreads,
+  getThreadMessages,
+  confirmApproval,
+  rejectApproval,
+  listModels,
+  messageText,
+  RESERVED_GLOBAL_FLAGS,
+  shortDescription,
+  schemaToFlags,
+  schemaToOptions,
+  didYouMean,
+  parseToolInput,
+  flagsForProperties,
+  describeSchema,
+  autoFilledProperties,
+  exampleInvocation,
+  isInteractiveTerminal,
+  assertInteractive,
+  renderScreen
+};
+//# sourceMappingURL=chunk-QVR5KIEQ.js.map