@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-NFAYHPRH.js

@@ -0,0 +1,323 @@
+import {
+  truncate
+} from "./chunk-B4AMLZPB.js";
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-WOEZV3Q4.js";
+
+// src/types/quota-regex.ts
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)(?:\s+(?:has|have))?(?:\s+been)?[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit|(?:usage|credit)[-_\s]*(?:quota|limit)(?![-_\w])|usage[-_\s]*(?:limit|quota)[-_\s]*(?:reached|exceeded|for)/i;
+var ROUTE_SCOPED_QUOTA_RE = /\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b|\b(?:route|model)(?:[-_\s]+[\w.-]+)?[-_\s]*(?:quota|limit)\b|\b(?:quota|limit).{0,24}\b(?:for|on)\s+(?:(?:this|the)\s+)?(?:route|model)\b/i;
+
+// src/types/provider.ts
+var REASONING_EFFORT_LEVELS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function isReasoningEffort(value) {
+  return typeof value === "string" && REASONING_EFFORT_LEVELS.includes(value);
+}
+function effectiveInputTokens(usage) {
+  return usage.input + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+}
+function freshInputTokens(usage) {
+  return Math.max(0, effectiveInputTokens(usage) - (usage.cacheRead ?? 0));
+}
+function promptCacheHitRatio(usage) {
+  const total = effectiveInputTokens(usage);
+  if (!Number.isFinite(total) || total <= 0) return 0;
+  const cached = Number.isFinite(usage.cacheRead) ? Math.max(0, usage.cacheRead ?? 0) : 0;
+  return Math.min(1, cached / total);
+}
+var CONTEXT_OVERFLOW_RE = /context.length|context.window|maximum context|max.*tokens?.*exceeded|(?:prompt|request|input|messages?).{0,12}too (?:large|long)|exceeds the context|\btokens\b.*exceed|too many tokens|reduce the length|resulted in \d+ tokens|context_length_exceeded/i;
+var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+var RATE_LIMIT_EXCEEDED_RE = /rate[-_\s]*limit[-_\s]*exceeded/i;
+function classifyProviderError(status, body, message) {
+  const type = body?.type;
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
+  if (status === 0) return "network";
+  if (status === 408) return "timeout";
+  if (status === 599) return "stream_hang";
+  if (QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
+  if (status === 402) return "quota_exhausted";
+  if (status === 429 && body?.message && body.type !== "rate_limit_exceeded" && RATE_LIMIT_EXCEEDED_RE.test(body.message)) {
+    return "quota_exhausted";
+  }
+  if (type === "rate_limit_error" || status === 429) return "rate_limit";
+  if (type === "overloaded_error" || status === 529) return "overloaded";
+  if (status >= 500) return "server";
+  if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
+    return "auth";
+  }
+  if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
+  if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
+    return "context_overflow";
+  }
+  if (status >= 400) return "invalid_request";
+  return "unknown";
+}
+var MAX_RESET_HINT_MS = 7 * 24 * 60 * 60 * 1e3;
+var RESET_HINT_LEAD_RE = /(?:try again|retry|resets?|resetting|available|returns?|back online|usable again)\s+(?:in|after)\s+/i;
+var RESET_AT_LEAD_RE = /resets?\s+(?:at|on)\s+/i;
+var DURATION_TOKEN_RE = /(\d+(?:\.\d+)?)\s*(ms|secs?|seconds?|s|mins?|minutes?|m|hrs?|hours?|h|days?|d)(?![a-z])/gi;
+var UNIT_MS = {
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+};
+function unitMs(unit) {
+  const u = unit.toLowerCase();
+  if (u === "ms") return 1;
+  if (u.startsWith("s")) return UNIT_MS["s"];
+  if (u.startsWith("m")) return UNIT_MS["m"];
+  if (u.startsWith("h")) return UNIT_MS["h"];
+  return UNIT_MS["d"];
+}
+var ISO_TIMESTAMP_RE = /(\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:\s*(?:Z|[+-]\d{2}:?\d{2}|UTC|GMT))?)?)/i;
+function parseResetHintMs(message, now = Date.now()) {
+  if (!message) return void 0;
+  const lead = RESET_HINT_LEAD_RE.exec(message);
+  if (lead) {
+    const window = message.slice(lead.index + lead[0].length, lead.index + lead[0].length + 80);
+    let total = 0;
+    let matched = false;
+    DURATION_TOKEN_RE.lastIndex = 0;
+    for (let m = DURATION_TOKEN_RE.exec(window); m; m = DURATION_TOKEN_RE.exec(window)) {
+      const value = Number.parseFloat(m[1]);
+      if (Number.isFinite(value) && value > 0) {
+        total += value * unitMs(m[2]);
+        matched = true;
+      }
+    }
+    if (!matched) {
+      const bare = /^(?:an?\s+)?(second|minute|hour|day)\b/i.exec(window.trim());
+      if (bare) {
+        total = unitMs(bare[1]);
+        matched = true;
+      }
+    }
+    if (matched && total > 0) {
+      return Math.min(total, MAX_RESET_HINT_MS);
+    }
+  }
+  const atLead = RESET_AT_LEAD_RE.exec(message);
+  if (atLead) {
+    const window = message.slice(atLead.index + atLead[0].length);
+    const iso = ISO_TIMESTAMP_RE.exec(window);
+    if (iso) {
+      const normalized = iso[1].replace(/^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2})/, "$1T$2").replace(/\s*(UTC|GMT)$/i, "Z");
+      const ts = Date.parse(normalized);
+      if (Number.isFinite(ts) && ts > now) {
+        return Math.min(ts - now, MAX_RESET_HINT_MS);
+      }
+    }
+  }
+  return void 0;
+}
+function isRetryableKind(kind) {
+  return RETRYABLE_BY_KIND[kind];
+}
+var RETRYABLE_BY_KIND = {
+  rate_limit: true,
+  quota_exhausted: false,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
+function isFallbackWorthy(kind) {
+  return FALLBACK_WORTHY_BY_KIND[kind];
+}
+var FALLBACK_WORTHY_BY_KIND = {
+  rate_limit: true,
+  quota_exhausted: true,
+  overloaded: true,
+  server: true,
+  timeout: true,
+  network: true,
+  stream_hang: true,
+  auth: false,
+  context_overflow: false,
+  content_filter: false,
+  invalid_request: false,
+  unknown: false
+};
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  /** Canonical failure classification — see {@link ProviderErrorKind}. */
+  kind;
+  body;
+  /**
+   * Duck-type guard: checks whether an unknown value *looks like* a
+   * ProviderError by probing for its structural properties.  Use this
+   * anywhere the constructor identity might cross a package boundary
+   * (e.g. `@wrongstack/providers` creates the error, but the runner in
+   * `@wrongstack/core` checks it). A plain `instanceof ProviderError`
+   * can fail when npm hoists duplicate copies of `@wrongstack/core`,
+   * each with its own class identity.
+   *
+   * The check tests for the four invariant properties defined in the
+   * constructor: `name === 'ProviderError'`, `status` (number),
+   * `retryable` (boolean), and `kind` (string). This tolerates both
+   * true `ProviderError` instances and cross-boundary copies.
+   */
+  static isProviderError(err) {
+    if (!err || typeof err !== "object") return false;
+    const e = err;
+    const name = e.name;
+    if (typeof name !== "string" || !name.endsWith("Error")) return false;
+    return typeof e.status === "number" && typeof e.retryable === "boolean" && typeof e.kind === "string" && typeof e.describe === "function";
+  }
+  constructor(message, status, retryable, providerId, opts = {}) {
+    const kind = opts.kind ?? classifyProviderError(status, opts.body, message);
+    super({
+      message,
+      code: kindToCode(kind),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.kind = kind;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function isContextOverflowShaped(err) {
+  if (!(err instanceof ProviderError) && !ProviderError.isProviderError(err)) return false;
+  const providerErr = err;
+  if (providerErr.kind === "context_overflow" || providerErr.status === 413) return true;
+  if (providerErr.status < 400) return false;
+  const text = [
+    providerErr.message,
+    providerErr.body?.message,
+    providerErr.body?.type,
+    providerErr.body?.raw
+  ].filter(Boolean).join("\n");
+  return CONTEXT_OVERFLOW_RE.test(text);
+}
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (status === 599) return `stream hang (${status})`;
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "content_filter") return `content filtered (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+var StreamHangError = class extends ProviderError {
+  /** Name of the provider that hung, e.g. "zai", "anthropic". */
+  hungProviderId;
+  /** Model that was being called when the hang occurred. */
+  hungModel;
+  /** How long (ms) we waited for the next chunk before declaring a hang. */
+  hangTimeoutMs;
+  /** How many bytes were received before the hang. */
+  bytesReceived;
+  /** Elapsed time (ms) from the start of the stream until the hang. */
+  elapsedMs;
+  constructor(opts) {
+    super(
+      `Stream hang: ${opts.providerId}/${opts.model} \u2014 no data for ${opts.hangTimeoutMs}ms after ${opts.bytesReceived} bytes (${opts.elapsedMs}ms elapsed)`,
+      599,
+      true,
+      // always retryable
+      opts.providerId,
+      {
+        body: {
+          message: `Stream stalled after ${opts.elapsedMs}ms, ${opts.bytesReceived} bytes received`
+        },
+        cause: opts.cause
+      }
+    );
+    this.name = "StreamHangError";
+    this.hungProviderId = opts.providerId;
+    this.hungModel = opts.model;
+    this.hangTimeoutMs = opts.hangTimeoutMs;
+    this.bytesReceived = opts.bytesReceived;
+    this.elapsedMs = opts.elapsedMs;
+  }
+};
+var KIND_TO_CODE = {
+  network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
+  rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
+  overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
+  context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
+  server: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  stream_hang: ERROR_CODES.PROVIDER_SERVER_ERROR,
+  content_filter: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  invalid_request: ERROR_CODES.PROVIDER_INVALID_REQUEST,
+  unknown: ERROR_CODES.PROVIDER_INVALID_REQUEST
+};
+function kindToCode(kind) {
+  return KIND_TO_CODE[kind];
+}
+
+export {
+  QUOTA_EXHAUSTED_RE,
+  ROUTE_SCOPED_QUOTA_RE,
+  REASONING_EFFORT_LEVELS,
+  isReasoningEffort,
+  effectiveInputTokens,
+  freshInputTokens,
+  promptCacheHitRatio,
+  classifyProviderError,
+  parseResetHintMs,
+  isRetryableKind,
+  isFallbackWorthy,
+  ProviderError,
+  isContextOverflowShaped,
+  StreamHangError
+};
+//# sourceMappingURL=chunk-NFAYHPRH.js.map

package/dist/chunk-O37BQ65S.js

@@ -0,0 +1,21 @@
+// src/types/blocks.ts
+function isTextBlock(b) {
+  return b.type === "text";
+}
+function isToolUseBlock(b) {
+  return b.type === "tool_use";
+}
+function isToolResultBlock(b) {
+  return b.type === "tool_result";
+}
+function isImageBlock(b) {
+  return b.type === "image";
+}
+
+export {
+  isTextBlock,
+  isToolUseBlock,
+  isToolResultBlock,
+  isImageBlock
+};
+//# sourceMappingURL=chunk-O37BQ65S.js.map

package/dist/chunk-O74MJHXU.js

@@ -0,0 +1,187 @@
+import {
+  ERROR_CODES,
+  WrongStackError
+} from "./chunk-WOEZV3Q4.js";
+
+// src/kernel/container.ts
+var Container = class {
+  entries = /* @__PURE__ */ new Map();
+  /**
+   * Tokens currently mid-resolve. Tracked so we can detect circular
+   * dependencies (A → B → A) and throw a structured error instead of
+   * overflowing the call stack with "Maximum call stack size exceeded".
+   *
+   * Not a memoization cache — the per-entry `cache` field is the source
+   * of truth for "have I built this before?". This set only lives for
+   * the duration of a single resolve call.
+   */
+  resolving = /* @__PURE__ */ new Set();
+  bind(token, factory, opts = {}) {
+    if (this.entries.has(token)) {
+      throw new WrongStackError({
+        message: `Container: token "${token.description ?? "unknown"}" already bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_ALREADY_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    this.entries.set(token, {
+      factory,
+      singleton: opts.singleton ?? true,
+      decorators: [],
+      hasCache: false,
+      owner: opts.owner ?? "core"
+    });
+  }
+  override(token, factory, opts = {}) {
+    const existing = this.entries.get(token);
+    if (!existing) {
+      throw new WrongStackError({
+        message: `Container: cannot override "${token.description ?? "unknown"}" \u2014 not bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    this.entries.set(token, {
+      factory,
+      singleton: opts.singleton ?? existing.singleton,
+      decorators: existing.decorators,
+      hasCache: false,
+      owner: opts.owner ?? existing.owner
+    });
+  }
+  decorate(token, decorator, owner = "core") {
+    const existing = this.entries.get(token);
+    if (!existing) {
+      throw new WrongStackError({
+        message: `Container: cannot decorate "${token.description ?? "unknown"}" \u2014 not bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    existing.decorators.push(decorator);
+    existing.cache = void 0;
+    existing.hasCache = false;
+    existing.owner = `${existing.owner}+${owner}`;
+  }
+  resolve(token) {
+    const entry = this.entries.get(token);
+    if (!entry) {
+      throw new WrongStackError({
+        message: `Container: token "${token.description ?? "unknown"}" not bound`,
+        code: ERROR_CODES.CONTAINER_TOKEN_NOT_BOUND,
+        subsystem: "container",
+        context: { token: token.description }
+      });
+    }
+    if (entry.singleton && entry.hasCache) {
+      return entry.cache;
+    }
+    if (this.resolving.has(token)) {
+      const cycle = this.describeCycle(token);
+      throw new WrongStackError({
+        message: `Container: circular dependency detected \u2014 ${cycle}`,
+        code: ERROR_CODES.CONTAINER_CIRCULAR_DEPENDENCY,
+        subsystem: "container",
+        context: { token: token.description, cycle }
+      });
+    }
+    this.resolving.add(token);
+    try {
+      let value = entry.factory(this);
+      for (const d of entry.decorators) {
+        value = d(value, this);
+      }
+      if (entry.singleton) {
+        entry.cache = value;
+        entry.hasCache = true;
+      }
+      return value;
+    } finally {
+      this.resolving.delete(token);
+    }
+  }
+  /**
+   * Build a human-readable description of the dependency cycle that
+   * caused the resolution to re-enter. Lists the tokens in the order
+   * they were entered, then appends the re-entered token to close the
+   * loop. Falls back to a generic message if the resolving set is
+   * somehow empty (shouldn't happen, but defensive).
+   */
+  describeCycle(reentry) {
+    const descs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const t of this.resolving) {
+      if (seen.has(t)) continue;
+      seen.add(t);
+      descs.push(t.description ?? "unknown");
+    }
+    descs.push(reentry.description ?? "unknown");
+    return descs.join(" \u2192 ");
+  }
+  has(token) {
+    return this.entries.has(token);
+  }
+  /**
+   * Resolve a token if it is bound, otherwise return undefined.
+   * Unlike `resolve()`, this does not throw if the token is unbound.
+   *
+   * Single map lookup — `has()` + `resolve()` would walk the entries
+   * map twice. The bound check is folded into the resolve path so a
+   * non-existent token can never enter the `resolving` cycle-detection
+   * set.
+   */
+  safeResolve(token) {
+    if (!this.entries.has(token)) return void 0;
+    return this.resolve(token);
+  }
+  ownerOf(token) {
+    return this.entries.get(token)?.owner;
+  }
+  /**
+   * Remove a token's binding (along with any decorators stacked on it).
+   * Returns true if the token existed. Use this to withdraw temporary
+   * bindings installed by a short-lived run or plugin — without it, the
+   * entry persists in the map forever.
+   */
+  unbind(token) {
+    return this.entries.delete(token);
+  }
+  /**
+   * Drop every binding. Intended for tests and short-lived CLI invocations
+   * that rebuild the container from scratch. Production code should prefer
+   * `unbind` on the specific tokens it owns.
+   */
+  clear() {
+    this.entries.clear();
+  }
+  list() {
+    return Array.from(this.entries.entries()).map(([token, entry]) => ({
+      token,
+      owner: entry.owner
+    }));
+  }
+  /**
+   * Inspect a binding's full shape, including decorator count and whether
+   * a singleton value is cached. Returns null if the token is unbound.
+   * Decorator and factory function references are not exposed — only counts
+   * and metadata, to keep internal state hidden.
+   */
+  inspect(token) {
+    const entry = this.entries.get(token);
+    if (!entry) return null;
+    return {
+      owner: entry.owner,
+      singleton: entry.singleton,
+      decoratorCount: entry.decorators.length,
+      cached: entry.hasCache
+    };
+  }
+};
+
+export {
+  Container
+};
+//# sourceMappingURL=chunk-O74MJHXU.js.map

package/dist/chunk-OJZEX73F.js

@@ -0,0 +1,112 @@
+// src/types/config/fleet-chat.ts
+var FLEET_CHAT_VERBOSITY_VALUES = ["off", "full"];
+function resolveFleetChatVerbosity(autonomy) {
+  const explicit = autonomy?.fleetChatVerbosity;
+  if (explicit && FLEET_CHAT_VERBOSITY_VALUES.includes(explicit)) {
+    return explicit;
+  }
+  return "off";
+}
+
+// src/types/config/ui.ts
+var THEME_PRESET_IDS = [
+  "catppuccin",
+  "tokyo-night",
+  "nord",
+  "cyberpunk",
+  "dracula",
+  "gruvbox-dark",
+  "solarized-dark",
+  "one-dark",
+  "monokai",
+  "rose-pine",
+  "kanagawa",
+  "ayu-dark",
+  "everforest",
+  "night-owl",
+  "synthwave",
+  "github-dark",
+  "material-ocean",
+  "nightfox",
+  "oxocarbon",
+  "catppuccin-macchiato",
+  "catppuccin-frappe",
+  "gruvbox-material",
+  "tokyo-night-storm",
+  "rose-pine-moon",
+  "zenburn",
+  "palenight",
+  "horizon",
+  "sonokai",
+  "edge-dark",
+  "moonfly",
+  "melange",
+  "poimandres",
+  "vitesse-dark",
+  "aura",
+  "dark-plus",
+  "monochrome",
+  "matrix",
+  "amber",
+  "cyber-noir",
+  "cobalt-mono",
+  "blood-moon",
+  "cobalt2",
+  "shades-of-purple",
+  "flexoki-dark",
+  "laserwave",
+  "andromeda",
+  "github-dark-dimmed",
+  "snazzy",
+  "tokyo-night-moon",
+  "gruvbox-dark-hard"
+];
+
+// src/types/spec.ts
+var DEFAULT_SPEC_TEMPLATE = {
+  id: "default",
+  name: "Default Feature Spec",
+  description: "Standard template for feature specifications",
+  sections: [
+    { type: "overview", title: "Overview", level: 1 },
+    { type: "requirements", title: "Requirements", level: 1 },
+    { type: "architecture", title: "Architecture", level: 1 },
+    { type: "api", title: "API Design", level: 1 },
+    { type: "data", title: "Data Model", level: 1 },
+    { type: "security", title: "Security", level: 1 },
+    { type: "acceptance", title: "Acceptance Criteria", level: 1 }
+  ],
+  defaultRequirements: [
+    { type: "functional", priority: "high", acceptanceCriteria: [], blockedBy: [], implements: [] },
+    {
+      type: "non-functional",
+      priority: "medium",
+      acceptanceCriteria: [],
+      blockedBy: [],
+      implements: []
+    }
+  ]
+};
+
+// src/types/tool.ts
+var ToolErrorCategory = /* @__PURE__ */ ((ToolErrorCategory2) => {
+  ToolErrorCategory2["TRANSIENT"] = "transient";
+  ToolErrorCategory2["NOT_FOUND"] = "not_found";
+  ToolErrorCategory2["PERMISSION"] = "permission";
+  ToolErrorCategory2["VALIDATION"] = "validation";
+  ToolErrorCategory2["FATAL"] = "fatal";
+  return ToolErrorCategory2;
+})(ToolErrorCategory || {});
+
+// src/types/tool-markers.ts
+var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
+
+export {
+  FLEET_CHAT_VERBOSITY_VALUES,
+  resolveFleetChatVerbosity,
+  THEME_PRESET_IDS,
+  DEFAULT_SPEC_TEMPLATE,
+  ToolErrorCategory,
+  MALFORMED_ARG_MARKERS
+};
+//# sourceMappingURL=chunk-OJZEX73F.js.map