@caspian2026/agent-sdk 0.0.8 → 0.0.11

package/dist/chunk-g8183rkv.js

@@ -0,0 +1,517 @@
+// @bun
+import {
+  CLAUDE_CODE_20250219_BETA_HEADER,
+  CLI_INTERNAL_BETA_HEADER,
+  CONTEXT_1M_BETA_HEADER,
+  CONTEXT_MANAGEMENT_BETA_HEADER,
+  INTERLEAVED_THINKING_BETA_HEADER,
+  PROMPT_CACHING_SCOPE_BETA_HEADER,
+  REDACT_THINKING_BETA_HEADER,
+  STRUCTURED_OUTPUTS_BETA_HEADER,
+  TOKEN_EFFICIENT_TOOLS_BETA_HEADER,
+  TOOL_SEARCH_BETA_HEADER_1P,
+  calculateUSDCost,
+  getAPIProvider,
+  getCanonicalName,
+  getContextWindowForModel,
+  getModelMaxOutputTokens,
+  has1mContext,
+  init_betas,
+  init_context,
+  init_fastMode,
+  init_model,
+  init_modelCost,
+  init_providers,
+  isFastModeEnabled
+} from "./chunk-vnzgpyrz.js";
+import {
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE,
+  getCurrentProjectConfig,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getInitialSettings,
+  init_config,
+  init_growthbook,
+  init_settings1 as init_settings,
+  saveCurrentProjectConfig
+} from "./chunk-rm9gb396.js";
+import {
+  formatDuration,
+  formatNumber,
+  init_format
+} from "./chunk-j35mw64g.js";
+import {
+  init_source,
+  source_default
+} from "./chunk-c7jwbe76.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-x8d2ehd7.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-nsc89h0n.js";
+import {
+  addToTotalCostState,
+  getCostCounter,
+  getIsNonInteractiveSession,
+  getModelUsage,
+  getSdkBetas,
+  getSessionId,
+  getTokenCounter,
+  getTotalAPIDuration,
+  getTotalAPIDurationWithoutRetries,
+  getTotalCacheCreationInputTokens,
+  getTotalCacheReadInputTokens,
+  getTotalCostUSD,
+  getTotalDuration,
+  getTotalInputTokens,
+  getTotalLinesAdded,
+  getTotalLinesRemoved,
+  getTotalOutputTokens,
+  getTotalToolDuration,
+  getTotalWebSearchRequests,
+  getUsageForModel,
+  hasUnknownModelCost,
+  init_state,
+  setCostStateForRestore
+} from "./chunk-k8vp0atq.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-vf612n57.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/model/modelSupportOverrides.ts
+var OPENAI_TIERS, get3PModelCapabilityOverride;
+var init_modelSupportOverrides = __esm(() => {
+  init_memoize();
+  init_providers();
+  OPENAI_TIERS = [
+    {
+      modelEnvVar: "OPENAI_DEFAULT_OPUS_MODEL",
+      capabilitiesEnvVar: "OPENAI_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES"
+    },
+    {
+      modelEnvVar: "OPENAI_DEFAULT_SONNET_MODEL",
+      capabilitiesEnvVar: "OPENAI_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES"
+    },
+    {
+      modelEnvVar: "OPENAI_DEFAULT_HAIKU_MODEL",
+      capabilitiesEnvVar: "OPENAI_DEFAULT_HAIKU_MODEL_SUPPORTED_CAPABILITIES"
+    }
+  ];
+  get3PModelCapabilityOverride = memoize_default((model, capability) => {
+    if (getAPIProvider() === "firstParty") {
+      return;
+    }
+    const m = model.toLowerCase();
+    for (const tier of OPENAI_TIERS) {
+      const pinned = process.env[tier.modelEnvVar];
+      const capabilities = process.env[tier.capabilitiesEnvVar];
+      if (!pinned || capabilities === undefined)
+        continue;
+      if (m !== pinned.toLowerCase())
+        continue;
+      return capabilities.toLowerCase().split(",").map((s) => s.trim()).includes(capability);
+    }
+    return;
+  }, (model, capability) => `${model.toLowerCase()}:${capability}`);
+});
+
+// src/utils/betas.ts
+function partitionBetasByAllowlist(betas) {
+  const allowed = [];
+  const disallowed = [];
+  for (const beta of betas) {
+    if (ALLOWED_SDK_BETAS.includes(beta)) {
+      allowed.push(beta);
+    } else {
+      disallowed.push(beta);
+    }
+  }
+  return { allowed, disallowed };
+}
+function filterAllowedSdkBetas(sdkBetas) {
+  if (!sdkBetas || sdkBetas.length === 0) {
+    return;
+  }
+  const { allowed, disallowed } = partitionBetasByAllowlist(sdkBetas);
+  for (const beta of disallowed) {
+    console.warn(`Warning: Beta header '${beta}' is not allowed. Only the following betas are supported: ${ALLOWED_SDK_BETAS.join(", ")}`);
+  }
+  return allowed.length > 0 ? allowed : undefined;
+}
+function modelSupportsISP(model) {
+  const supported3P = get3PModelCapabilityOverride(model, "interleaved_thinking");
+  if (supported3P !== undefined) {
+    return supported3P;
+  }
+  const canonical = getCanonicalName(model);
+  const provider = getAPIProvider();
+  if (provider === "firstParty") {
+    return !canonical.includes("claude-3-");
+  }
+  return canonical.includes("claude-opus-4") || canonical.includes("claude-sonnet-4");
+}
+function modelSupportsContextManagement(model) {
+  const canonical = getCanonicalName(model);
+  const provider = getAPIProvider();
+  if (provider === "firstParty") {
+    return !canonical.includes("claude-3-");
+  }
+  return canonical.includes("claude-opus-4") || canonical.includes("claude-sonnet-4") || canonical.includes("claude-haiku-4");
+}
+function modelSupportsStructuredOutputs(model) {
+  const canonical = getCanonicalName(model);
+  const provider = getAPIProvider();
+  if (provider !== "firstParty") {
+    return false;
+  }
+  return canonical.includes("claude-sonnet-4-6") || canonical.includes("claude-sonnet-4-5") || canonical.includes("claude-opus-4-1") || canonical.includes("claude-opus-4-5") || canonical.includes("claude-opus-4-6") || canonical.includes("claude-haiku-4-5");
+}
+function modelSupportsAutoMode(model) {
+  if (false) {}
+  return false;
+}
+function getToolSearchBetaHeader() {
+  return TOOL_SEARCH_BETA_HEADER_1P;
+}
+function shouldIncludeFirstPartyOnlyBetas() {
+  return getAPIProvider() === "firstParty" && !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS);
+}
+function shouldUseGlobalCacheScope() {
+  return getAPIProvider() === "firstParty" && !isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS);
+}
+function getMergedBetas(model, options) {
+  const baseBetas = [...getModelBetas(model)];
+  if (options?.isAgenticQuery) {
+    if (!baseBetas.includes(CLAUDE_CODE_20250219_BETA_HEADER)) {
+      baseBetas.push(CLAUDE_CODE_20250219_BETA_HEADER);
+    }
+    if (process.env.USER_TYPE === "ant" && process.env.CLAUDE_CODE_ENTRYPOINT === "cli" && CLI_INTERNAL_BETA_HEADER && !baseBetas.includes(CLI_INTERNAL_BETA_HEADER)) {
+      baseBetas.push(CLI_INTERNAL_BETA_HEADER);
+    }
+  }
+  const sdkBetas = getSdkBetas();
+  if (!sdkBetas || sdkBetas.length === 0) {
+    return baseBetas;
+  }
+  return [...baseBetas, ...sdkBetas.filter((b) => !baseBetas.includes(b))];
+}
+function clearBetasCaches() {
+  getAllModelBetas.cache?.clear?.();
+  getModelBetas.cache?.clear?.();
+}
+var ALLOWED_SDK_BETAS, getAllModelBetas, getModelBetas;
+var init_betas2 = __esm(() => {
+  init_memoize();
+  init_growthbook();
+  init_state();
+  init_betas();
+  init_context();
+  init_envUtils();
+  init_model();
+  init_modelSupportOverrides();
+  init_providers();
+  init_settings();
+  ALLOWED_SDK_BETAS = [CONTEXT_1M_BETA_HEADER];
+  getAllModelBetas = memoize_default((model) => {
+    const betaHeaders = [];
+    const isHaiku = getCanonicalName(model).includes("haiku");
+    const includeFirstPartyOnlyBetas = shouldIncludeFirstPartyOnlyBetas();
+    if (!isHaiku) {
+      betaHeaders.push(CLAUDE_CODE_20250219_BETA_HEADER);
+      if (process.env.USER_TYPE === "ant" && process.env.CLAUDE_CODE_ENTRYPOINT === "cli") {
+        if (CLI_INTERNAL_BETA_HEADER) {
+          betaHeaders.push(CLI_INTERNAL_BETA_HEADER);
+        }
+      }
+    }
+    if (has1mContext(model)) {
+      betaHeaders.push(CONTEXT_1M_BETA_HEADER);
+    }
+    if (!isEnvTruthy(process.env.DISABLE_INTERLEAVED_THINKING) && modelSupportsISP(model)) {
+      betaHeaders.push(INTERLEAVED_THINKING_BETA_HEADER);
+    }
+    if (includeFirstPartyOnlyBetas && modelSupportsISP(model) && !getIsNonInteractiveSession() && getInitialSettings().showThinkingSummaries !== true) {
+      betaHeaders.push(REDACT_THINKING_BETA_HEADER);
+    }
+    const antOptedIntoToolClearing = isEnvTruthy(process.env.USE_API_CONTEXT_MANAGEMENT) && process.env.USER_TYPE === "ant";
+    const thinkingPreservationEnabled = modelSupportsContextManagement(model);
+    if (shouldIncludeFirstPartyOnlyBetas() && (antOptedIntoToolClearing || thinkingPreservationEnabled)) {
+      betaHeaders.push(CONTEXT_MANAGEMENT_BETA_HEADER);
+    }
+    const strictToolsEnabled = checkStatsigFeatureGate_CACHED_MAY_BE_STALE("tengu_tool_pear");
+    const tokenEfficientToolsEnabled = !strictToolsEnabled && getFeatureValue_CACHED_MAY_BE_STALE("tengu_amber_json_tools", false);
+    if (includeFirstPartyOnlyBetas && modelSupportsStructuredOutputs(model) && strictToolsEnabled) {
+      betaHeaders.push(STRUCTURED_OUTPUTS_BETA_HEADER);
+    }
+    if (process.env.USER_TYPE === "ant" && includeFirstPartyOnlyBetas && tokenEfficientToolsEnabled) {
+      betaHeaders.push(TOKEN_EFFICIENT_TOOLS_BETA_HEADER);
+    }
+    if (includeFirstPartyOnlyBetas) {
+      betaHeaders.push(PROMPT_CACHING_SCOPE_BETA_HEADER);
+    }
+    if (process.env.ANTHROPIC_BETAS) {
+      betaHeaders.push(...process.env.ANTHROPIC_BETAS.split(",").map((_) => _.trim()).filter(Boolean));
+    }
+    return betaHeaders;
+  });
+  getModelBetas = memoize_default((model) => {
+    return getAllModelBetas(model);
+  });
+});
+
+// src/utils/advisor.ts
+function isAdvisorBlock(param) {
+  return param.type === "advisor_tool_result" || param.type === "server_tool_use" && param.name === "advisor";
+}
+function getAdvisorConfig() {
+  return getFeatureValue_CACHED_MAY_BE_STALE("tengu_sage_compass", {});
+}
+function isAdvisorEnabled() {
+  if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_ADVISOR_TOOL)) {
+    return false;
+  }
+  if (!shouldIncludeFirstPartyOnlyBetas()) {
+    return false;
+  }
+  return getAdvisorConfig().enabled ?? false;
+}
+function canUserConfigureAdvisor() {
+  return isAdvisorEnabled() && (getAdvisorConfig().canUserConfigure ?? false);
+}
+function getExperimentAdvisorModels() {
+  const config = getAdvisorConfig();
+  return isAdvisorEnabled() && !canUserConfigureAdvisor() && config.baseModel && config.advisorModel ? { baseModel: config.baseModel, advisorModel: config.advisorModel } : undefined;
+}
+function modelSupportsAdvisor(model) {
+  const m = model.toLowerCase();
+  return m.includes("opus-4-6") || m.includes("sonnet-4-6") || process.env.USER_TYPE === "ant";
+}
+function isValidAdvisorModel(model) {
+  const m = model.toLowerCase();
+  return m.includes("opus-4-6") || m.includes("sonnet-4-6") || process.env.USER_TYPE === "ant";
+}
+function getInitialAdvisorSetting() {
+  if (!isAdvisorEnabled()) {
+    return;
+  }
+  return getInitialSettings().advisorModel;
+}
+function getAdvisorUsage(usage) {
+  const iterations = usage.iterations;
+  if (!iterations) {
+    return [];
+  }
+  return iterations.filter((it) => it.type === "advisor_message");
+}
+var ADVISOR_TOOL_INSTRUCTIONS = `# Advisor Tool
+
+You have access to an \`advisor\` tool backed by a stronger reviewer model. It takes NO parameters -- when you call it, your entire conversation history is automatically forwarded. The advisor sees the task, every tool call you've made, every result you've seen.
+
+Call advisor BEFORE substantive work -- before writing code, before committing to an interpretation, before building on an assumption. If the task requires orientation first (finding files, reading code, seeing what's there), do that, then call advisor. Orientation is not substantive work. Writing, editing, and declaring an answer are.
+
+Also call advisor:
+- When you believe the task is complete. BEFORE this call, make your deliverable durable: write the file, stage the change, save the result. The advisor call takes time; if the session ends during it, a durable result persists and an unwritten one doesn't.
+- When stuck -- errors recurring, approach not converging, results that don't fit.
+- When considering a change of approach.
+
+On tasks longer than a few steps, call advisor at least once before committing to an approach and once before declaring done. On short reactive tasks where the next action is dictated by tool output you just read, you don't need to keep calling -- the advisor adds most of its value on the first call, before the approach crystallizes.
+
+Give the advice serious weight. If you follow a step and it fails empirically, or you have primary-source evidence that contradicts a specific claim (the file says X, the code does Y), adapt. A passing self-test is not evidence the advice is wrong -- it's evidence your test doesn't check what the advice is checking.
+
+If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call -- "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.`;
+var init_advisor = __esm(() => {
+  init_growthbook();
+  init_betas2();
+  init_envUtils();
+  init_settings();
+});
+
+// src/cost-tracker.ts
+function getStoredSessionCosts(sessionId) {
+  const projectConfig = getCurrentProjectConfig();
+  if (projectConfig.lastSessionId !== sessionId) {
+    return;
+  }
+  let modelUsage;
+  if (projectConfig.lastModelUsage) {
+    modelUsage = Object.fromEntries(Object.entries(projectConfig.lastModelUsage).map(([model, usage]) => [
+      model,
+      {
+        ...usage,
+        contextWindow: getContextWindowForModel(model, getSdkBetas()),
+        maxOutputTokens: getModelMaxOutputTokens(model).default
+      }
+    ]));
+  }
+  return {
+    totalCostUSD: projectConfig.lastCost ?? 0,
+    totalAPIDuration: projectConfig.lastAPIDuration ?? 0,
+    totalAPIDurationWithoutRetries: projectConfig.lastAPIDurationWithoutRetries ?? 0,
+    totalToolDuration: projectConfig.lastToolDuration ?? 0,
+    totalLinesAdded: projectConfig.lastLinesAdded ?? 0,
+    totalLinesRemoved: projectConfig.lastLinesRemoved ?? 0,
+    lastDuration: projectConfig.lastDuration,
+    modelUsage
+  };
+}
+function restoreCostStateForSession(sessionId) {
+  const data = getStoredSessionCosts(sessionId);
+  if (!data) {
+    return false;
+  }
+  setCostStateForRestore(data);
+  return true;
+}
+function saveCurrentSessionCosts(fpsMetrics) {
+  saveCurrentProjectConfig((current) => ({
+    ...current,
+    lastCost: getTotalCostUSD(),
+    lastAPIDuration: getTotalAPIDuration(),
+    lastAPIDurationWithoutRetries: getTotalAPIDurationWithoutRetries(),
+    lastToolDuration: getTotalToolDuration(),
+    lastDuration: getTotalDuration(),
+    lastLinesAdded: getTotalLinesAdded(),
+    lastLinesRemoved: getTotalLinesRemoved(),
+    lastTotalInputTokens: getTotalInputTokens(),
+    lastTotalOutputTokens: getTotalOutputTokens(),
+    lastTotalCacheCreationInputTokens: getTotalCacheCreationInputTokens(),
+    lastTotalCacheReadInputTokens: getTotalCacheReadInputTokens(),
+    lastTotalWebSearchRequests: getTotalWebSearchRequests(),
+    lastFpsAverage: fpsMetrics?.averageFps,
+    lastFpsLow1Pct: fpsMetrics?.low1PctFps,
+    lastModelUsage: Object.fromEntries(Object.entries(getModelUsage()).map(([model, usage]) => [
+      model,
+      {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadInputTokens: usage.cacheReadInputTokens,
+        cacheCreationInputTokens: usage.cacheCreationInputTokens,
+        webSearchRequests: usage.webSearchRequests,
+        costUSD: usage.costUSD
+      }
+    ])),
+    lastSessionId: getSessionId()
+  }));
+}
+function formatCost(cost, maxDecimalPlaces = 4) {
+  return `$${cost > 0.5 ? round(cost, 100).toFixed(2) : cost.toFixed(maxDecimalPlaces)}`;
+}
+function formatModelUsage() {
+  const modelUsageMap = getModelUsage();
+  if (Object.keys(modelUsageMap).length === 0) {
+    return "Usage:                 0 input, 0 output, 0 cache read, 0 cache write";
+  }
+  const usageByShortName = {};
+  for (const [model, usage] of Object.entries(modelUsageMap)) {
+    const shortName = getCanonicalName(model);
+    if (!usageByShortName[shortName]) {
+      usageByShortName[shortName] = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        webSearchRequests: 0,
+        costUSD: 0,
+        contextWindow: 0,
+        maxOutputTokens: 0
+      };
+    }
+    const accumulated = usageByShortName[shortName];
+    accumulated.inputTokens += usage.inputTokens;
+    accumulated.outputTokens += usage.outputTokens;
+    accumulated.cacheReadInputTokens += usage.cacheReadInputTokens;
+    accumulated.cacheCreationInputTokens += usage.cacheCreationInputTokens;
+    accumulated.webSearchRequests += usage.webSearchRequests;
+    accumulated.costUSD += usage.costUSD;
+  }
+  let result = "Usage by model:";
+  for (const [shortName, usage] of Object.entries(usageByShortName)) {
+    const usageString = `  ${formatNumber(usage.inputTokens)} input, ` + `${formatNumber(usage.outputTokens)} output, ` + `${formatNumber(usage.cacheReadInputTokens)} cache read, ` + `${formatNumber(usage.cacheCreationInputTokens)} cache write` + (usage.webSearchRequests > 0 ? `, ${formatNumber(usage.webSearchRequests)} web search` : "") + ` (${formatCost(usage.costUSD)})`;
+    result += `
+` + `${shortName}:`.padStart(21) + usageString;
+  }
+  return result;
+}
+function formatTotalCost() {
+  const costDisplay = formatCost(getTotalCostUSD()) + (hasUnknownModelCost() ? " (costs may be inaccurate due to usage of unknown models)" : "");
+  const modelUsageDisplay = formatModelUsage();
+  return source_default.dim(`Total cost:            ${costDisplay}
+` + `Total duration (API):  ${formatDuration(getTotalAPIDuration())}
+Total duration (wall): ${formatDuration(getTotalDuration())}
+Total code changes:    ${getTotalLinesAdded()} ${getTotalLinesAdded() === 1 ? "line" : "lines"} added, ${getTotalLinesRemoved()} ${getTotalLinesRemoved() === 1 ? "line" : "lines"} removed
+${modelUsageDisplay}`);
+}
+function round(number, precision) {
+  return Math.round(number * precision) / precision;
+}
+function addToTotalModelUsage(cost, usage, model) {
+  const modelUsage = getUsageForModel(model) ?? {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    webSearchRequests: 0,
+    costUSD: 0,
+    contextWindow: 0,
+    maxOutputTokens: 0
+  };
+  modelUsage.inputTokens += usage.input_tokens;
+  modelUsage.outputTokens += usage.output_tokens;
+  modelUsage.cacheReadInputTokens += usage.cache_read_input_tokens ?? 0;
+  modelUsage.cacheCreationInputTokens += usage.cache_creation_input_tokens ?? 0;
+  modelUsage.webSearchRequests += usage.server_tool_use?.web_search_requests ?? 0;
+  modelUsage.costUSD += cost;
+  modelUsage.contextWindow = getContextWindowForModel(model, getSdkBetas());
+  modelUsage.maxOutputTokens = getModelMaxOutputTokens(model).default;
+  return modelUsage;
+}
+function addToTotalSessionCost(cost, usage, model) {
+  const modelUsage = addToTotalModelUsage(cost, usage, model);
+  addToTotalCostState(cost, modelUsage, model);
+  const attrs = isFastModeEnabled() && usage.speed === "fast" ? { model, speed: "fast" } : { model };
+  getCostCounter()?.add(cost, attrs);
+  getTokenCounter()?.add(usage.input_tokens, { ...attrs, type: "input" });
+  getTokenCounter()?.add(usage.output_tokens, { ...attrs, type: "output" });
+  getTokenCounter()?.add(usage.cache_read_input_tokens ?? 0, {
+    ...attrs,
+    type: "cacheRead"
+  });
+  getTokenCounter()?.add(usage.cache_creation_input_tokens ?? 0, {
+    ...attrs,
+    type: "cacheCreation"
+  });
+  let totalCost = cost;
+  for (const advisorUsage of getAdvisorUsage(usage)) {
+    const advisorCost = calculateUSDCost(advisorUsage.model, advisorUsage);
+    logEvent("tengu_advisor_tool_token_usage", {
+      advisor_model: advisorUsage.model,
+      input_tokens: advisorUsage.input_tokens,
+      output_tokens: advisorUsage.output_tokens,
+      cache_read_input_tokens: advisorUsage.cache_read_input_tokens ?? 0,
+      cache_creation_input_tokens: advisorUsage.cache_creation_input_tokens ?? 0,
+      cost_usd_micros: Math.round(advisorCost * 1e6)
+    });
+    totalCost += addToTotalSessionCost(advisorCost, advisorUsage, advisorUsage.model);
+  }
+  return totalCost;
+}
+var init_cost_tracker = __esm(() => {
+  init_source();
+  init_state();
+  init_analytics();
+  init_advisor();
+  init_config();
+  init_context();
+  init_fastMode();
+  init_format();
+  init_model();
+  init_modelCost();
+});
+
+export { get3PModelCapabilityOverride, init_modelSupportOverrides, filterAllowedSdkBetas, modelSupportsStructuredOutputs, modelSupportsAutoMode, getToolSearchBetaHeader, shouldIncludeFirstPartyOnlyBetas, shouldUseGlobalCacheScope, getModelBetas, getMergedBetas, clearBetasCaches, init_betas2 as init_betas, isAdvisorBlock, isAdvisorEnabled, canUserConfigureAdvisor, getExperimentAdvisorModels, modelSupportsAdvisor, isValidAdvisorModel, getInitialAdvisorSetting, ADVISOR_TOOL_INSTRUCTIONS, init_advisor, getStoredSessionCosts, restoreCostStateForSession, saveCurrentSessionCosts, formatCost, formatTotalCost, addToTotalSessionCost, init_cost_tracker };

package/dist/{chunk-4g0nj78p.js → chunk-gbztsm42.js}

@@ -33,54 +33,55 @@ import {
   setLastSummarizedMessageId,
   suppressCompactWarning,
   trySessionMemoryCompaction
-} from "./chunk-f2hbn5rk.js";
-import"./chunk-jpc9zwsk.js";
-import"./chunk-hwfknpxv.js";
-import"./chunk-4nspekjp.js";
+} from "./chunk-ggq2y3tn.js";
+import"./chunk-mcws22k3.js";
 import"./chunk-jzthz1bx.js";
+import"./chunk-mq94v5vn.js";
+import"./chunk-hwfknpxv.js";
 import"./chunk-1gx78081.js";
-import"./chunk-qcnhb4cd.js";
-import"./chunk-s7q42kp2.js";
-import"./chunk-2gzv8nrw.js";
 import"./chunk-ehtwnxpg.js";
-import"./chunk-wr3pd88n.js";
-import"./chunk-wayfjcwt.js";
+import"./chunk-75qqeec8.js";
+import"./chunk-hadww3nd.js";
+import"./chunk-87xg6yb4.js";
+import"./chunk-w5zezk61.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-sdfvr9ps.js";
 import"./chunk-cgfdkzhb.js";
-import"./chunk-bxcfz5gy.js";
-import"./chunk-y0fhjxef.js";
+import"./chunk-xswyz2es.js";
 import"./chunk-j5bth84e.js";
-import"./chunk-nk82j7r2.js";
-import"./chunk-68ffk5qa.js";
+import"./chunk-6696fngv.js";
 import"./chunk-ps49ymvj.js";
+import"./chunk-68ffk5qa.js";
+import"./chunk-g8183rkv.js";
+import"./chunk-vnzgpyrz.js";
+import"./chunk-7krg0dkt.js";
+import"./chunk-4057dtxd.js";
 import"./chunk-p7vkh4wx.js";
-import"./chunk-bmbq6nt1.js";
-import"./chunk-yc23zxmj.js";
-import"./chunk-njrt3tac.js";
-import"./chunk-m87bhhqv.js";
-import"./chunk-xwg327ys.js";
-import"./chunk-xz655xxa.js";
-import"./chunk-c11swzas.js";
-import"./chunk-chsyvavm.js";
-import"./chunk-5rv9c8yd.js";
-import"./chunk-e7efcp3k.js";
-import"./chunk-z19sd3bt.js";
-import"./chunk-1ax1znzj.js";
+import"./chunk-6wzg2hpc.js";
+import"./chunk-9g29z3dv.js";
+import"./chunk-7tphrzjj.js";
+import"./chunk-2vteceqh.js";
+import"./chunk-xeb6075z.js";
+import"./chunk-nrjtxhyr.js";
+import"./chunk-v4t6dyyh.js";
+import"./chunk-g5epkvz2.js";
+import"./chunk-bzatg35k.js";
+import"./chunk-rm9gb396.js";
+import"./chunk-p4196wzm.js";
+import"./chunk-cttezxcb.js";
 import"./chunk-6nsd9606.js";
-import"./chunk-xp61y5ba.js";
+import"./chunk-rkv8bdtr.js";
 import"./chunk-64c1avct.js";
-import"./chunk-wha6v7za.js";
 import"./chunk-8g5pe1gr.js";
-import"./chunk-4cp6193g.js";
-import"./chunk-8g747a8x.js";
-import"./chunk-d7886r6a.js";
-import"./chunk-yvtzznds.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-z6wm96eh.js";
 import"./chunk-4jm600zv.js";
-import"./chunk-qz2x630m.js";
-import"./chunk-2f21meep.js";
-import"./chunk-nrtksr2p.js";
+import"./chunk-1v01c96r.js";
+import"./chunk-8b2y3x7a.js";
 import"./chunk-3c25bcsw.js";
-import"./chunk-s3hsqf80.js";
-import"./chunk-yyf72f78.js";
+import"./chunk-cexw1jmv.js";
+import"./chunk-j35mw64g.js";
 import"./chunk-cdz5yb0r.js";
 import {
   init_source,
@@ -90,26 +91,26 @@ import"./chunk-0vkfrmqm.js";
 import"./chunk-7sgtxrsc.js";
 import"./chunk-0xjaqda8.js";
 import"./chunk-x8d2ehd7.js";
-import"./chunk-15m49c67.js";
-import"./chunk-tdbz9gbm.js";
-import"./chunk-0awwmrwr.js";
+import"./chunk-3e28fvn0.js";
+import"./chunk-kjqyhxz7.js";
+import"./chunk-4ayjwyqj.js";
 import"./chunk-qnfx3qtx.js";
-import"./chunk-70eey1nh.js";
+import"./chunk-40s88wdg.js";
 import {
   init_log,
   logError
-} from "./chunk-1nk93fqz.js";
+} from "./chunk-5cxjxxx8.js";
 import"./chunk-s8kj6ajy.js";
-import"./chunk-eenq3avg.js";
-import"./chunk-7mqab3z7.js";
+import"./chunk-qcrpqjya.js";
+import"./chunk-skp5w8bq.js";
 import"./chunk-5z28bqne.js";
 import"./chunk-qajrkk97.js";
 import {
   hasExactErrorMessage,
   init_errors
-} from "./chunk-phd1qfpc.js";
+} from "./chunk-pd2vy8hx.js";
+import"./chunk-nsc89h0n.js";
 import"./chunk-fbv4apne.js";
-import"./chunk-jaaxk89e.js";
 import {
   init_state,
   markPostCompaction

package/dist/{chunk-ga86yjm1.js → chunk-gdwdqewd.js}

@@ -2,12 +2,12 @@
 import {
   init_pack,
   packExtension
-} from "./chunk-nqn45znr.js";
-import"./chunk-v9smspw2.js";
-import"./chunk-v1kzp02e.js";
+} from "./chunk-ns7x6xam.js";
 import"./chunk-vyjeh50y.js";
 import"./chunk-v78fj8by.js";
 import"./chunk-sd36yzx8.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
 import"./chunk-7wm5s02e.js";
 import"./chunk-b0kf00ff.js";
 import"./chunk-netzwgv1.js";