@wrongstack/core 0.9.19 → 0.10.0

package/dist/types/index.js

@@ -66,8 +66,10 @@ var ERROR_CODES = {
   // Container / Registry
   CONTAINER_TOKEN_ALREADY_BOUND: "CONTAINER_TOKEN_ALREADY_BOUND",
   CONTAINER_TOKEN_NOT_BOUND: "CONTAINER_TOKEN_NOT_BOUND",
+  CONTAINER_CIRCULAR_DEPENDENCY: "CONTAINER_CIRCULAR_DEPENDENCY",
   REGISTRY_DUPLICATE: "REGISTRY_DUPLICATE",
   REGISTRY_NOT_FOUND: "REGISTRY_NOT_FOUND",
+  REGISTRY_INVALID: "REGISTRY_INVALID",
   // File system
   FS_READ_FAILED: "FS_READ_FAILED",
   FS_WRITE_FAILED: "FS_WRITE_FAILED",
@@ -315,6 +317,14 @@ var DEFAULT_CONTEXT_CONFIG = Object.freeze({
 var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
   autoProceedDelayMs: 45e3
 });
+var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
+  auditLevel: "standard",
+  sampling: {
+    toolProgress: {
+      sampleRate: 8
+    }
+  }
+});
 
 // src/types/secret-vault.ts
 var ENCRYPTED_PREFIX = "enc:v1:";
@@ -867,6 +877,54 @@ function estimateToolResultTokens(content) {
 function estimateTextTokens(text) {
   return RoughTokenEstimate(text);
 }
+function estimateToolDefTokens(tool) {
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(tool.description ?? "") + RoughTokenEstimate(JSON.stringify(tool.inputSchema));
+}
+function estimateRequestTokens(messages, systemPrompt, tools) {
+  let messagesTokens = 0;
+  if (typeof messages === "string") {
+    messagesTokens = RoughTokenEstimate(messages);
+  } else if (Array.isArray(messages)) {
+    for (const m of messages) {
+      if (typeof m === "object" && m !== null && "content" in m) {
+        const content = m.content;
+        if (typeof content === "string") {
+          messagesTokens += RoughTokenEstimate(content);
+        } else if (Array.isArray(content)) {
+          for (const b of content) {
+            if (typeof b === "object" && b !== null) {
+              if (b.type === "text") {
+                messagesTokens += RoughTokenEstimate(b.text);
+              } else {
+                messagesTokens += RoughTokenEstimate(JSON.stringify(b));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let systemTokens = 0;
+  if (typeof systemPrompt === "string") {
+    systemTokens = RoughTokenEstimate(systemPrompt);
+  } else if (Array.isArray(systemPrompt)) {
+    for (const b of systemPrompt) {
+      if (typeof b === "object" && b !== null && b.type === "text") {
+        systemTokens += RoughTokenEstimate(b.text);
+      }
+    }
+  }
+  let toolsTokens = 0;
+  for (const t of tools) {
+    toolsTokens += estimateToolDefTokens(t);
+  }
+  return {
+    messages: messagesTokens,
+    systemPrompt: systemTokens,
+    tools: toolsTokens,
+    total: messagesTokens + systemTokens + toolsTokens
+  };
+}
 
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
@@ -972,6 +1030,7 @@ var HybridCompactor = class {
   }
   async compact(ctx, opts = {}) {
     const beforeTokens = this.estimateMessages(ctx.messages);
+    const beforeFull = this.estimateFullRequest(ctx);
     const reductions = [];
     const policy = readContextWindowPolicy(ctx);
     const preserveK = policy?.preserveK ?? this.preserveK;
@@ -987,9 +1046,12 @@ var HybridCompactor = class {
       ctx.state.replaceMessages(repaired.messages);
     }
     const afterTokens = this.estimateMessages(ctx.messages);
+    const afterFull = this.estimateFullRequest(ctx);
     return {
       before: beforeTokens,
       after: afterTokens,
+      fullRequestTokensBefore: beforeFull,
+      fullRequestTokensAfter: afterFull,
       reductions,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
@@ -998,6 +1060,14 @@ var HybridCompactor = class {
       } : void 0
     };
   }
+  /**
+   * Estimate the full API request token count: messages + systemPrompt + toolDefs.
+   * This is the accurate figure for context-window pressure monitoring.
+   */
+  estimateFullRequest(ctx) {
+    const breakdown = estimateRequestTokens(ctx.messages, ctx.systemPrompt, ctx.tools ?? []);
+    return breakdown.total;
+  }
   eliseOldToolResults(ctx, preserveK = this.preserveK, eliseThreshold = this.eliseThreshold) {
     const messages = ctx.messages;
     let pairCount = 0;
@@ -1421,6 +1491,71 @@ var DefaultSecretScrubber = class {
     return visit(obj);
   }
 };
+
+// src/utils/merge-models-payload.ts
+function mergeModelsPayload(base, overlay) {
+  const out = {};
+  for (const [id, provider] of Object.entries(base)) {
+    out[id] = cloneProvider(provider);
+  }
+  for (const [id, ovProvider] of Object.entries(overlay)) {
+    const existing = out[id];
+    out[id] = existing ? mergeProvider(existing, ovProvider) : cloneProvider(ovProvider);
+  }
+  return out;
+}
+function mergeProvider(base, overlay) {
+  const models = {};
+  for (const [mid, m] of Object.entries(base.models ?? {})) {
+    models[mid] = { ...m };
+  }
+  for (const [mid, ovModel] of Object.entries(overlay.models ?? {})) {
+    const existing = models[mid];
+    models[mid] = existing ? mergeModel(existing, ovModel) : { ...ovModel };
+  }
+  return {
+    ...base,
+    // Overlay scalar fields win when explicitly provided; otherwise keep base.
+    ...stripUndefined({
+      id: overlay.id,
+      name: overlay.name,
+      npm: overlay.npm,
+      api: overlay.api,
+      env: overlay.env,
+      doc: overlay.doc
+    }),
+    models
+  };
+}
+function mergeModel(base, overlay) {
+  const merged = { ...base, ...overlay };
+  if (base.limit || overlay.limit) {
+    merged.limit = { ...base.limit, ...overlay.limit };
+  }
+  if (base.cost || overlay.cost) {
+    merged.cost = { ...base.cost, ...overlay.cost };
+  }
+  if (base.modalities || overlay.modalities) {
+    merged.modalities = { ...base.modalities, ...overlay.modalities };
+  }
+  return merged;
+}
+function cloneProvider(p) {
+  const models = {};
+  for (const [mid, m] of Object.entries(p.models ?? {})) {
+    models[mid] = { ...m };
+  }
+  return { ...p, models };
+}
+function stripUndefined(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+
+// src/models/models-registry.ts
 var DEFAULT_URL = "https://models.dev/api.json";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
 var FAMILY_BY_NPM = {
@@ -1448,7 +1583,10 @@ function classifyFamily(npm) {
   return FAMILY_BY_NPM[npm] ?? "unsupported";
 }
 var DefaultModelsRegistry = class {
+  /** Merged (base + overlay) payload — what every reader sees. */
   payload;
+  /** Memoised overlay payload (in-memory / fetched / file). */
+  overlayPayload;
   fetchedAt;
   cacheFile;
   url;
@@ -1456,6 +1594,10 @@ var DefaultModelsRegistry = class {
   fetchImpl;
   seed;
   maxStaleAgeMs;
+  overlay;
+  overlayUrl;
+  overlayFile;
+  overlayCacheFile;
   constructor(opts) {
     this.cacheFile = opts.cacheFile;
     this.url = opts.url ?? DEFAULT_URL;
@@ -1464,6 +1606,10 @@ var DefaultModelsRegistry = class {
     this.seed = opts.seed;
     const maxStaleSeconds = opts.maxStaleAgeSeconds ?? 7 * 24 * 3600;
     this.maxStaleAgeMs = maxStaleSeconds * 1e3;
+    this.overlay = opts.overlay;
+    this.overlayUrl = opts.overlayUrl;
+    this.overlayFile = opts.overlayFile;
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path4.join(path4.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -1472,27 +1618,45 @@ var DefaultModelsRegistry = class {
       this.fetchedAt = /* @__PURE__ */ new Date();
       return this.payload;
     }
+    const overlay = await this.loadOverlay(opts);
+    const base = await this.loadBase(opts, Object.keys(overlay).length > 0);
+    this.payload = mergeModelsPayload(base, overlay);
+    return this.payload;
+  }
+  /**
+   * Load the models.dev base payload: fresh cache → network → stale cache.
+   * On total failure, degrade to `{}` (so a non-empty overlay still drives
+   * the catalog) rather than throwing — unless there's no curated overlay to
+   * fall back on, in which case the original error propagates so pure-
+   * models.dev setups still surface the problem.
+   */
+  async loadBase(opts = {}, overlayAvailable = false) {
     if (!opts.force) {
-      const cached = await this.readCache();
+      const cached = await this.readCacheAt(this.cacheFile);
       if (cached && this.isFresh(cached.fetchedAt)) {
-        this.payload = cached.payload;
         this.fetchedAt = new Date(cached.fetchedAt);
         return cached.payload;
       }
     }
     try {
-      return await this.refresh();
+      return await this.refreshBase();
     } catch (err) {
-      const cached = await this.readCache();
+      const cached = await this.readCacheAt(this.cacheFile);
       if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) {
-        this.payload = cached.payload;
         this.fetchedAt = new Date(cached.fetchedAt);
         return cached.payload;
       }
+      if (overlayAvailable) {
+        console.warn(
+          `ModelsRegistry: models.dev unavailable (${err instanceof Error ? err.message : String(err)}); serving curated overlay only.`
+        );
+        return {};
+      }
       throw err;
     }
   }
-  async refresh() {
+  /** Fetch + cache the models.dev base. Throws on failure (used by `refresh`). */
+  async refreshBase() {
     const res = await this.fetchImpl(this.url, {
       method: "GET",
       headers: { accept: "application/json" }
@@ -1501,7 +1665,6 @@ var DefaultModelsRegistry = class {
       throw new Error(`ModelsRegistry: HTTP ${res.status} fetching ${this.url}`);
     }
     const json = await res.json();
-    this.payload = json;
     this.fetchedAt = /* @__PURE__ */ new Date();
     const envelope = {
       fetchedAt: this.fetchedAt.toISOString(),
@@ -1511,6 +1674,68 @@ var DefaultModelsRegistry = class {
     await atomicWrite(this.cacheFile, JSON.stringify(envelope));
     return json;
   }
+  /**
+   * Resolve the curated overlay, memoised. Order: in-memory `overlay` →
+   * fetched `overlayUrl` (cached, same TTL/stale rules) → `overlayFile` on
+   * disk. Never throws — a missing/broken overlay yields `{}`.
+   */
+  async loadOverlay(opts = {}) {
+    if (this.overlayPayload && !opts.force) return this.overlayPayload;
+    if (this.overlay) {
+      this.overlayPayload = this.overlay;
+      return this.overlayPayload;
+    }
+    const fetched = await this.loadOverlayFromUrl(opts);
+    if (fetched) {
+      this.overlayPayload = fetched;
+      return fetched;
+    }
+    const fromFile = await this.readOverlayFile();
+    this.overlayPayload = fromFile ?? {};
+    return this.overlayPayload;
+  }
+  async loadOverlayFromUrl(opts) {
+    if (!this.overlayUrl || !this.overlayCacheFile) return void 0;
+    if (!opts.force) {
+      const cached = await this.readCacheAt(this.overlayCacheFile);
+      if (cached && this.isFresh(cached.fetchedAt)) return cached.payload;
+    }
+    try {
+      const res = await this.fetchImpl(this.overlayUrl, {
+        method: "GET",
+        headers: { accept: "application/json" }
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+      const json = await res.json();
+      const envelope = {
+        fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        url: this.overlayUrl,
+        payload: json
+      };
+      await atomicWrite(this.overlayCacheFile, JSON.stringify(envelope)).catch(() => {
+      });
+      return json;
+    } catch {
+      const cached = await this.readCacheAt(this.overlayCacheFile);
+      if (cached && this.isWithinMaxStaleAge(cached.fetchedAt)) return cached.payload;
+      return void 0;
+    }
+  }
+  async readOverlayFile() {
+    if (!this.overlayFile) return void 0;
+    try {
+      const raw = await fs.readFile(this.overlayFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  async refresh() {
+    const base = await this.refreshBase();
+    const overlay = await this.loadOverlay({ force: true });
+    this.payload = mergeModelsPayload(base, overlay);
+    return this.payload;
+  }
   async listProviders() {
     const payload = await this.load();
     return Object.values(payload).map((p) => this.resolveProvider(p));
@@ -1551,7 +1776,7 @@ var DefaultModelsRegistry = class {
   }
   async ageSeconds() {
     if (!this.fetchedAt) {
-      const cached = await this.readCache();
+      const cached = await this.readCacheAt(this.cacheFile);
       if (!cached) return Number.POSITIVE_INFINITY;
       return (Date.now() - new Date(cached.fetchedAt).getTime()) / 1e3;
     }
@@ -1575,9 +1800,9 @@ var DefaultModelsRegistry = class {
   isWithinMaxStaleAge(fetchedAtIso) {
     return Date.now() - new Date(fetchedAtIso).getTime() < this.maxStaleAgeMs;
   }
-  async readCache() {
+  async readCacheAt(file) {
     try {
-      const raw = await fs.readFile(this.cacheFile, "utf8");
+      const raw = await fs.readFile(file, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -2149,6 +2374,141 @@ function topologicalSort(graph) {
   return result;
 }
 
+// src/security/capabilities.ts
+var ToolCapabilities = {
+  /** Can execute arbitrary commands in the user's shell (the `bash` tool). */
+  SHELL_ARBITRARY: "shell.arbitrary",
+  /** Can write / modify / delete files inside the project. */
+  FS_WRITE: "fs.write",
+  /** Can write files outside the current project root (very high risk). */
+  FS_WRITE_OUTSIDE_PROJECT: "fs.write.outside-project",
+  /** Proxies tools from external MCP servers (unknown capability). */
+  MCP_PROXY: "mcp.proxy",
+  /** Can spawn or manage subagents / multi-agent tasks. */
+  SUBAGENT_SPAWN: "subagent.spawn",
+  /** Can mutate global or session configuration / trust state. */
+  CONFIG_MUTATE: "config.mutate",
+  /** Can install packages or run package managers with side effects. */
+  PACKAGE_INSTALL: "package.install"
+};
+var DANGEROUS_FOR_SUBAGENTS = [
+  ToolCapabilities.SHELL_ARBITRARY,
+  ToolCapabilities.FS_WRITE,
+  ToolCapabilities.FS_WRITE_OUTSIDE_PROJECT,
+  ToolCapabilities.MCP_PROXY,
+  ToolCapabilities.SUBAGENT_SPAWN,
+  ToolCapabilities.CONFIG_MUTATE,
+  ToolCapabilities.PACKAGE_INSTALL
+];
+function hasDangerousCapabilityForSubagents(toolOrCaps) {
+  if (!toolOrCaps) return false;
+  const input = toolOrCaps;
+  const caps = Array.isArray(input) ? input : input?.capabilities ?? [];
+  return caps.some((c) => DANGEROUS_FOR_SUBAGENTS.includes(c));
+}
+function getDangerousCapabilities(toolOrCaps) {
+  if (!toolOrCaps) return [];
+  const input = toolOrCaps;
+  const caps = Array.isArray(input) ? input : input?.capabilities ?? [];
+  return caps.filter(
+    (c) => DANGEROUS_FOR_SUBAGENTS.includes(c)
+  );
+}
+
+// src/utils/json-schema-validate.ts
+function validateAgainstSchema(value, schema) {
+  const errors = [];
+  walk2(value, schema, "", errors);
+  return { ok: errors.length === 0, errors };
+}
+function walk2(value, schema, path6, errors) {
+  if (schema.enum !== void 0) {
+    if (!schema.enum.some((e) => deepEqual(e, value))) {
+      errors.push({
+        path: path6 || "<root>",
+        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
+      });
+      return;
+    }
+  }
+  if (typeof schema.type === "string") {
+    if (!checkType(value, schema.type)) {
+      errors.push({
+        path: path6 || "<root>",
+        message: `expected ${schema.type}, got ${describeType(value)}`
+      });
+      return;
+    }
+  }
+  if (schema.type === "object" && isPlainObject(value)) {
+    const obj = value;
+    for (const req of schema.required ?? []) {
+      if (!(req in obj)) {
+        errors.push({ path: joinPath(path6, req), message: "required property missing" });
+      }
+    }
+    if (schema.properties) {
+      for (const [key, subSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          walk2(obj[key], subSchema, joinPath(path6, key), errors);
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && Array.isArray(value) && schema.items) {
+    value.forEach((item, i) => walk2(item, schema.items, `${path6}[${i}]`, errors));
+  }
+}
+function checkType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+    default:
+      return true;
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function describeType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function joinPath(parent, key) {
+  if (!parent) return key;
+  return `${parent}.${key}`;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+
 // src/utils/tool-output-serializer.ts
 function createToolOutputSerializer(opts = {}) {
   const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
@@ -2230,18 +2590,45 @@ var ToolExecutor = class {
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
+      const validation = validateAgainstSchema(use.input, tool.inputSchema);
+      if (!validation.ok) {
+        const errorDetails = validation.errors.map((e) => `  - ${e.path || "input"}: ${e.message}`).join("\n");
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Invalid arguments for tool "${tool.name}".
+
+Validation errors:
+${errorDetails}
+
+Please call the tool again with arguments that match its inputSchema. You can use the "tool-help" tool with name="${tool.name}" to see the exact expected schema.`,
+          is_error: true
+        };
+        budget = this.decrementBudget(result, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
+      const toolDangerousCaps = getDangerousCapabilities(tool);
+      if (toolDangerousCaps.length > 0) {
+        if (this.opts.events) ;
+      }
       if (hasMalformedArguments(use.input)) {
         const result = this.malformedInputResult(use, extractMalformedRaw(use.input));
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
-      if (decision.permission === "deny") {
+      let effectivePermission = decision.permission;
+      const policy = this.opts.permissionPolicy;
+      const yolo = policy.getYolo?.() === true || policy.getForceAllYolo?.() === true;
+      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo) {
+        effectivePermission = "confirm";
+      }
+      if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
         budget = this.decrementBudget(result, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
-      if (decision.permission === "confirm") {
+      if (effectivePermission === "confirm") {
         if (this.opts.confirmAwaiter) {
           const choice = await this.opts.confirmAwaiter(tool, use.input, use.id, tool.name);
           if (choice !== "yes" && choice !== "always") {
@@ -2266,10 +2653,13 @@ var ToolExecutor = class {
           return { result: pending, tool, durationMs: Date.now() - start };
         }
       }
+      const toolCapsForAudit = hasDangerousCapabilityForSubagents(tool) ? tool.capabilities ?? [] : [];
       const span = this.opts.tracer?.startSpan(`tool.${tool.name}`, {
         "tool.name": tool.name,
         "tool.mutating": tool.mutating,
-        "tool.permission": tool.permission
+        "tool.permission": tool.permission,
+        "tool.capabilities": JSON.stringify(tool.capabilities ?? []),
+        "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
         const result = await this.executeTool(tool, use, ctx, budget);
@@ -2814,6 +3204,6 @@ function renderPlainText(meta, events) {
   return lines.join("\n");
 }
 
-export { AgentError, CONTEXT_WINDOW_MODES, ConfigError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SPEC_TEMPLATE, DEFAULT_TOOLS_CONFIG, DefaultErrorHandler, DefaultLogger, DefaultModelsRegistry, DefaultPathResolver, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultTokenCounter, ERROR_CODES, FsError, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, PluginError, ProviderError, SessionError, ToolError, ToolExecutor, WrongStackError, asBlocks, asText, buildRecoveryStrategies, classifyFamily, computeTaskProgress, createMessage, decryptConfigSecrets, encryptConfigSecrets, findCriticalPath, formatContextWindowModeList, getContextWindowMode, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, migratePlaintextSecrets, resolveContextWindowPolicy, rewriteConfigEncrypted, toWrongStackError, topologicalSort };
+export { AgentError, CONTEXT_WINDOW_MODES, ConfigError, DEFAULT_AUTONOMY_CONFIG, DEFAULT_CONTEXT_CONFIG, DEFAULT_CONTEXT_WINDOW_MODE_ID, DEFAULT_MODES, DEFAULT_RECOVERY_STRATEGIES, DEFAULT_SESSION_LOGGING_CONFIG, DEFAULT_SPEC_TEMPLATE, DEFAULT_TOOLS_CONFIG, DefaultErrorHandler, DefaultLogger, DefaultModelsRegistry, DefaultPathResolver, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultTokenCounter, ERROR_CODES, FsError, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, PluginError, ProviderError, SessionError, ToolError, ToolExecutor, WrongStackError, asBlocks, asText, buildRecoveryStrategies, classifyFamily, computeTaskProgress, createMessage, decryptConfigSecrets, encryptConfigSecrets, findCriticalPath, formatContextWindowModeList, getContextWindowMode, isAgentError, isConfigError, isContextWindowModeId, isFsError, isImageBlock, isPluginError, isSessionError, isTextBlock, isThinkingBlock, isToolError, isToolResultBlock, isToolUseBlock, isWrongStackError, listContextWindowModes, migratePlaintextSecrets, resolveContextWindowPolicy, rewriteConfigEncrypted, toWrongStackError, topologicalSort };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map