@roo-code/types 1.44.0 → 1.46.0

package/dist/index.cjs

@@ -23,6 +23,7 @@ __export(index_exports, {
   ANTHROPIC_DEFAULT_MAX_TOKENS: () => ANTHROPIC_DEFAULT_MAX_TOKENS,
   ANTHROPIC_STYLE_PROVIDERS: () => ANTHROPIC_STYLE_PROVIDERS,
   AWS_INFERENCE_PROFILE_MAPPING: () => AWS_INFERENCE_PROFILE_MAPPING,
+  BEDROCK_CLAUDE_SONNET_4_MODEL_ID: () => BEDROCK_CLAUDE_SONNET_4_MODEL_ID,
   BEDROCK_DEFAULT_CONTEXT: () => BEDROCK_DEFAULT_CONTEXT,
   BEDROCK_DEFAULT_TEMPERATURE: () => BEDROCK_DEFAULT_TEMPERATURE,
   BEDROCK_MAX_TOKENS: () => BEDROCK_MAX_TOKENS,
@@ -33,6 +34,7 @@ __export(index_exports, {
   DEFAULT_CONSECUTIVE_MISTAKE_LIMIT: () => DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
   DEFAULT_MODES: () => DEFAULT_MODES,
   DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT: () => DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT,
+  DEFAULT_USAGE_COLLECTION_TIMEOUT_MS: () => DEFAULT_USAGE_COLLECTION_TIMEOUT_MS,
   DEFAULT_WRITE_DELAY_MS: () => DEFAULT_WRITE_DELAY_MS,
   DOUBAO_API_BASE_URL: () => DOUBAO_API_BASE_URL,
   DOUBAO_API_CHAT_PATH: () => DOUBAO_API_CHAT_PATH,
@@ -41,6 +43,7 @@ __export(index_exports, {
   GLAMA_DEFAULT_TEMPERATURE: () => GLAMA_DEFAULT_TEMPERATURE,
   GLOBAL_SETTINGS_KEYS: () => GLOBAL_SETTINGS_KEYS,
   GLOBAL_STATE_KEYS: () => GLOBAL_STATE_KEYS,
+  GPT5_DEFAULT_TEMPERATURE: () => GPT5_DEFAULT_TEMPERATURE,
   HUGGINGFACE_API_URL: () => HUGGINGFACE_API_URL,
   HUGGINGFACE_CACHE_DURATION: () => HUGGINGFACE_CACHE_DURATION,
   HUGGINGFACE_DEFAULT_CONTEXT_WINDOW: () => HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
@@ -49,6 +52,7 @@ __export(index_exports, {
   HUGGINGFACE_SLIDER_MIN: () => HUGGINGFACE_SLIDER_MIN,
   HUGGINGFACE_SLIDER_STEP: () => HUGGINGFACE_SLIDER_STEP,
   HUGGINGFACE_TEMPERATURE_MAX_VALUE: () => HUGGINGFACE_TEMPERATURE_MAX_VALUE,
+  IO_INTELLIGENCE_CACHE_DURATION: () => IO_INTELLIGENCE_CACHE_DURATION,
   IpcMessageType: () => IpcMessageType,
   IpcOrigin: () => IpcOrigin,
   LITELLM_COMPUTER_USE_MODELS: () => LITELLM_COMPUTER_USE_MODELS,
@@ -63,8 +67,6 @@ __export(index_exports, {
   OPEN_ROUTER_PROMPT_CACHING_MODELS: () => OPEN_ROUTER_PROMPT_CACHING_MODELS,
   OPEN_ROUTER_REASONING_BUDGET_MODELS: () => OPEN_ROUTER_REASONING_BUDGET_MODELS,
   OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS: () => OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS,
-  ORGANIZATION_ALLOW_ALL: () => ORGANIZATION_ALLOW_ALL,
-  ORGANIZATION_DEFAULT: () => ORGANIZATION_DEFAULT,
   PROVIDER_SETTINGS_KEYS: () => PROVIDER_SETTINGS_KEYS,
   RooCodeEventName: () => RooCodeEventName,
   SECRET_STATE_KEYS: () => SECRET_STATE_KEYS,
@@ -112,6 +114,9 @@ __export(index_exports, {
   experimentIds: () => experimentIds,
   experimentIdsSchema: () => experimentIdsSchema,
   experimentsSchema: () => experimentsSchema,
+  extendedReasoningEffortsSchema: () => extendedReasoningEffortsSchema,
+  fireworksDefaultModelId: () => fireworksDefaultModelId,
+  fireworksModels: () => fireworksModels,
   followUpDataSchema: () => followUpDataSchema,
   geminiDefaultModelId: () => geminiDefaultModelId,
   geminiModels: () => geminiModels,
@@ -130,6 +135,9 @@ __export(index_exports, {
   installMarketplaceItemOptionsSchema: () => installMarketplaceItemOptionsSchema,
   internationalZAiDefaultModelId: () => internationalZAiDefaultModelId,
   internationalZAiModels: () => internationalZAiModels,
+  ioIntelligenceDefaultBaseUrl: () => ioIntelligenceDefaultBaseUrl,
+  ioIntelligenceDefaultModelId: () => ioIntelligenceDefaultModelId,
+  ioIntelligenceModels: () => ioIntelligenceModels,
   ipcMessageSchema: () => ipcMessageSchema,
   isBlockingAsk: () => isBlockingAsk,
   isGlobalStateKey: () => isGlobalStateKey,
@@ -166,10 +174,6 @@ __export(index_exports, {
   openAiNativeModels: () => openAiNativeModels,
   openRouterDefaultModelId: () => openRouterDefaultModelId,
   openRouterDefaultModelInfo: () => openRouterDefaultModelInfo,
-  organizationAllowListSchema: () => organizationAllowListSchema,
-  organizationCloudSettingsSchema: () => organizationCloudSettingsSchema,
-  organizationDefaultSettingsSchema: () => organizationDefaultSettingsSchema,
-  organizationSettingsSchema: () => organizationSettingsSchema,
   promptComponentSchema: () => promptComponentSchema,
   providerNames: () => providerNames,
   providerNamesSchema: () => providerNamesSchema,
@@ -186,7 +190,6 @@ __export(index_exports, {
   rooCodeTelemetryEventSchema: () => rooCodeTelemetryEventSchema,
   sambaNovaDefaultModelId: () => sambaNovaDefaultModelId,
   sambaNovaModels: () => sambaNovaModels,
-  shareResponseSchema: () => shareResponseSchema,
   suggestionItemSchema: () => suggestionItemSchema,
   taskCommandSchema: () => taskCommandSchema,
   taskEventSchema: () => taskEventSchema,
@@ -206,6 +209,8 @@ __export(index_exports, {
   toolUsageSchema: () => toolUsageSchema,
   unboundDefaultModelId: () => unboundDefaultModelId,
   unboundDefaultModelInfo: () => unboundDefaultModelInfo,
+  verbosityLevels: () => verbosityLevels,
+  verbosityLevelsSchema: () => verbosityLevelsSchema,
   vertexDefaultModelId: () => vertexDefaultModelId,
   vertexModels: () => vertexModels,
   vscodeLlmDefaultModelId: () => vscodeLlmDefaultModelId,
@@ -215,55 +220,8 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/cloud.ts
-var import_zod13 = require("zod");
-
-// src/global-settings.ts
-var import_zod11 = require("zod");
-
-// src/provider-settings.ts
-var import_zod3 = require("zod");
-
-// src/model.ts
-var import_zod = require("zod");
-var reasoningEfforts = ["low", "medium", "high"];
-var reasoningEffortsSchema = import_zod.z.enum(reasoningEfforts);
-var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
-var modelParametersSchema = import_zod.z.enum(modelParameters);
-var isModelParameter = (value) => modelParameters.includes(value);
-var modelInfoSchema = import_zod.z.object({
-  maxTokens: import_zod.z.number().nullish(),
-  maxThinkingTokens: import_zod.z.number().nullish(),
-  contextWindow: import_zod.z.number(),
-  supportsImages: import_zod.z.boolean().optional(),
-  supportsComputerUse: import_zod.z.boolean().optional(),
-  supportsPromptCache: import_zod.z.boolean(),
-  supportsReasoningBudget: import_zod.z.boolean().optional(),
-  requiredReasoningBudget: import_zod.z.boolean().optional(),
-  supportsReasoningEffort: import_zod.z.boolean().optional(),
-  supportedParameters: import_zod.z.array(modelParametersSchema).optional(),
-  inputPrice: import_zod.z.number().optional(),
-  outputPrice: import_zod.z.number().optional(),
-  cacheWritesPrice: import_zod.z.number().optional(),
-  cacheReadsPrice: import_zod.z.number().optional(),
-  description: import_zod.z.string().optional(),
-  reasoningEffort: reasoningEffortsSchema.optional(),
-  minTokensPerCachePoint: import_zod.z.number().optional(),
-  maxCachePoints: import_zod.z.number().optional(),
-  cachableFields: import_zod.z.array(import_zod.z.string()).optional(),
-  tiers: import_zod.z.array(
-    import_zod.z.object({
-      contextWindow: import_zod.z.number(),
-      inputPrice: import_zod.z.number().optional(),
-      outputPrice: import_zod.z.number().optional(),
-      cacheWritesPrice: import_zod.z.number().optional(),
-      cacheReadsPrice: import_zod.z.number().optional()
-    })
-  ).optional()
-});
-
 // src/codebase-index.ts
-var import_zod2 = require("zod");
+var import_zod = require("zod");
 var CODEBASE_INDEX_DEFAULTS = {
   MIN_SEARCH_RESULTS: 10,
   MAX_SEARCH_RESULTS: 200,
@@ -274,37 +232,397 @@ var CODEBASE_INDEX_DEFAULTS = {
   DEFAULT_SEARCH_MIN_SCORE: 0.4,
   SEARCH_SCORE_STEP: 0.05
 };
-var codebaseIndexConfigSchema = import_zod2.z.object({
-  codebaseIndexEnabled: import_zod2.z.boolean().optional(),
-  codebaseIndexQdrantUrl: import_zod2.z.string().optional(),
-  codebaseIndexEmbedderProvider: import_zod2.z.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral"]).optional(),
-  codebaseIndexEmbedderBaseUrl: import_zod2.z.string().optional(),
-  codebaseIndexEmbedderModelId: import_zod2.z.string().optional(),
-  codebaseIndexEmbedderModelDimension: import_zod2.z.number().optional(),
-  codebaseIndexSearchMinScore: import_zod2.z.number().min(0).max(1).optional(),
-  codebaseIndexSearchMaxResults: import_zod2.z.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
+var codebaseIndexConfigSchema = import_zod.z.object({
+  codebaseIndexEnabled: import_zod.z.boolean().optional(),
+  codebaseIndexQdrantUrl: import_zod.z.string().optional(),
+  codebaseIndexEmbedderProvider: import_zod.z.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral"]).optional(),
+  codebaseIndexEmbedderBaseUrl: import_zod.z.string().optional(),
+  codebaseIndexEmbedderModelId: import_zod.z.string().optional(),
+  codebaseIndexEmbedderModelDimension: import_zod.z.number().optional(),
+  codebaseIndexSearchMinScore: import_zod.z.number().min(0).max(1).optional(),
+  codebaseIndexSearchMaxResults: import_zod.z.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
   // OpenAI Compatible specific fields
-  codebaseIndexOpenAiCompatibleBaseUrl: import_zod2.z.string().optional(),
-  codebaseIndexOpenAiCompatibleModelDimension: import_zod2.z.number().optional()
+  codebaseIndexOpenAiCompatibleBaseUrl: import_zod.z.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: import_zod.z.number().optional()
+});
+var codebaseIndexModelsSchema = import_zod.z.object({
+  openai: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
+  ollama: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
+  "openai-compatible": import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
+  gemini: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
+  mistral: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional()
+});
+var codebaseIndexProviderSchema = import_zod.z.object({
+  codeIndexOpenAiKey: import_zod.z.string().optional(),
+  codeIndexQdrantApiKey: import_zod.z.string().optional(),
+  codebaseIndexOpenAiCompatibleBaseUrl: import_zod.z.string().optional(),
+  codebaseIndexOpenAiCompatibleApiKey: import_zod.z.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: import_zod.z.number().optional(),
+  codebaseIndexGeminiApiKey: import_zod.z.string().optional(),
+  codebaseIndexMistralApiKey: import_zod.z.string().optional()
+});
+
+// src/events.ts
+var import_zod4 = require("zod");
+
+// src/message.ts
+var import_zod2 = require("zod");
+var clineAsks = [
+  "followup",
+  "command",
+  "command_output",
+  "completion_result",
+  "tool",
+  "api_req_failed",
+  "resume_task",
+  "resume_completed_task",
+  "mistake_limit_reached",
+  "browser_action_launch",
+  "use_mcp_server",
+  "auto_approval_max_req_reached"
+];
+var clineAskSchema = import_zod2.z.enum(clineAsks);
+var blockingAsks = [
+  "api_req_failed",
+  "mistake_limit_reached",
+  "completion_result",
+  "resume_task",
+  "resume_completed_task",
+  "command_output",
+  "auto_approval_max_req_reached"
+];
+function isBlockingAsk(ask) {
+  return blockingAsks.includes(ask);
+}
+var clineSays = [
+  "error",
+  "api_req_started",
+  "api_req_finished",
+  "api_req_retried",
+  "api_req_retry_delayed",
+  "api_req_deleted",
+  "text",
+  "reasoning",
+  "completion_result",
+  "user_feedback",
+  "user_feedback_diff",
+  "command_output",
+  "shell_integration_warning",
+  "browser_action",
+  "browser_action_result",
+  "mcp_server_request_started",
+  "mcp_server_response",
+  "subtask_result",
+  "checkpoint_saved",
+  "rooignore_error",
+  "diff_error",
+  "condense_context",
+  "condense_context_error",
+  "codebase_search_result",
+  "user_edit_todos"
+];
+var clineSaySchema = import_zod2.z.enum(clineSays);
+var toolProgressStatusSchema = import_zod2.z.object({
+  icon: import_zod2.z.string().optional(),
+  text: import_zod2.z.string().optional()
+});
+var contextCondenseSchema = import_zod2.z.object({
+  cost: import_zod2.z.number(),
+  prevContextTokens: import_zod2.z.number(),
+  newContextTokens: import_zod2.z.number(),
+  summary: import_zod2.z.string()
+});
+var clineMessageSchema = import_zod2.z.object({
+  ts: import_zod2.z.number(),
+  type: import_zod2.z.union([import_zod2.z.literal("ask"), import_zod2.z.literal("say")]),
+  ask: clineAskSchema.optional(),
+  say: clineSaySchema.optional(),
+  text: import_zod2.z.string().optional(),
+  images: import_zod2.z.array(import_zod2.z.string()).optional(),
+  partial: import_zod2.z.boolean().optional(),
+  reasoning: import_zod2.z.string().optional(),
+  conversationHistoryIndex: import_zod2.z.number().optional(),
+  checkpoint: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+  progressStatus: toolProgressStatusSchema.optional(),
+  contextCondense: contextCondenseSchema.optional(),
+  isProtected: import_zod2.z.boolean().optional(),
+  apiProtocol: import_zod2.z.union([import_zod2.z.literal("openai"), import_zod2.z.literal("anthropic")]).optional(),
+  metadata: import_zod2.z.object({
+    gpt5: import_zod2.z.object({
+      previous_response_id: import_zod2.z.string().optional(),
+      instructions: import_zod2.z.string().optional(),
+      reasoning_summary: import_zod2.z.string().optional()
+    }).optional()
+  }).optional()
+});
+var tokenUsageSchema = import_zod2.z.object({
+  totalTokensIn: import_zod2.z.number(),
+  totalTokensOut: import_zod2.z.number(),
+  totalCacheWrites: import_zod2.z.number().optional(),
+  totalCacheReads: import_zod2.z.number().optional(),
+  totalCost: import_zod2.z.number(),
+  contextTokens: import_zod2.z.number()
+});
+
+// src/tool.ts
+var import_zod3 = require("zod");
+var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
+var toolGroupsSchema = import_zod3.z.enum(toolGroups);
+var toolNames = [
+  "execute_command",
+  "read_file",
+  "write_to_file",
+  "apply_diff",
+  "insert_content",
+  "search_and_replace",
+  "search_files",
+  "list_files",
+  "list_code_definition_names",
+  "browser_action",
+  "use_mcp_tool",
+  "access_mcp_resource",
+  "ask_followup_question",
+  "attempt_completion",
+  "switch_mode",
+  "new_task",
+  "fetch_instructions",
+  "codebase_search",
+  "update_todo_list"
+];
+var toolNamesSchema = import_zod3.z.enum(toolNames);
+var toolUsageSchema = import_zod3.z.record(
+  toolNamesSchema,
+  import_zod3.z.object({
+    attempts: import_zod3.z.number(),
+    failures: import_zod3.z.number()
+  })
+);
+
+// src/events.ts
+var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
+  RooCodeEventName2["TaskCreated"] = "taskCreated";
+  RooCodeEventName2["TaskStarted"] = "taskStarted";
+  RooCodeEventName2["TaskCompleted"] = "taskCompleted";
+  RooCodeEventName2["TaskAborted"] = "taskAborted";
+  RooCodeEventName2["TaskFocused"] = "taskFocused";
+  RooCodeEventName2["TaskUnfocused"] = "taskUnfocused";
+  RooCodeEventName2["TaskActive"] = "taskActive";
+  RooCodeEventName2["TaskIdle"] = "taskIdle";
+  RooCodeEventName2["TaskPaused"] = "taskPaused";
+  RooCodeEventName2["TaskUnpaused"] = "taskUnpaused";
+  RooCodeEventName2["TaskSpawned"] = "taskSpawned";
+  RooCodeEventName2["Message"] = "message";
+  RooCodeEventName2["TaskModeSwitched"] = "taskModeSwitched";
+  RooCodeEventName2["TaskAskResponded"] = "taskAskResponded";
+  RooCodeEventName2["TaskTokenUsageUpdated"] = "taskTokenUsageUpdated";
+  RooCodeEventName2["TaskToolFailed"] = "taskToolFailed";
+  RooCodeEventName2["EvalPass"] = "evalPass";
+  RooCodeEventName2["EvalFail"] = "evalFail";
+  return RooCodeEventName2;
+})(RooCodeEventName || {});
+var rooCodeEventsSchema = import_zod4.z.object({
+  ["taskCreated" /* TaskCreated */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskStarted" /* TaskStarted */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskCompleted" /* TaskCompleted */]: import_zod4.z.tuple([
+    import_zod4.z.string(),
+    tokenUsageSchema,
+    toolUsageSchema,
+    import_zod4.z.object({
+      isSubtask: import_zod4.z.boolean()
+    })
+  ]),
+  ["taskAborted" /* TaskAborted */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskFocused" /* TaskFocused */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskUnfocused" /* TaskUnfocused */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskActive" /* TaskActive */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskIdle" /* TaskIdle */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskPaused" /* TaskPaused */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskUnpaused" /* TaskUnpaused */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskSpawned" /* TaskSpawned */]: import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]),
+  ["message" /* Message */]: import_zod4.z.tuple([
+    import_zod4.z.object({
+      taskId: import_zod4.z.string(),
+      action: import_zod4.z.union([import_zod4.z.literal("created"), import_zod4.z.literal("updated")]),
+      message: clineMessageSchema
+    })
+  ]),
+  ["taskModeSwitched" /* TaskModeSwitched */]: import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]),
+  ["taskAskResponded" /* TaskAskResponded */]: import_zod4.z.tuple([import_zod4.z.string()]),
+  ["taskToolFailed" /* TaskToolFailed */]: import_zod4.z.tuple([import_zod4.z.string(), toolNamesSchema, import_zod4.z.string()]),
+  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: import_zod4.z.tuple([import_zod4.z.string(), tokenUsageSchema])
 });
-var codebaseIndexModelsSchema = import_zod2.z.object({
-  openai: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.object({ dimension: import_zod2.z.number() })).optional(),
-  ollama: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.object({ dimension: import_zod2.z.number() })).optional(),
-  "openai-compatible": import_zod2.z.record(import_zod2.z.string(), import_zod2.z.object({ dimension: import_zod2.z.number() })).optional(),
-  gemini: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.object({ dimension: import_zod2.z.number() })).optional(),
-  mistral: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.object({ dimension: import_zod2.z.number() })).optional()
+var taskEventSchema = import_zod4.z.discriminatedUnion("eventName", [
+  // Task Provider Lifecycle
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskCreated" /* TaskCreated */),
+    payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  // Task Lifecycle
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskStarted" /* TaskStarted */),
+    payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskCompleted" /* TaskCompleted */),
+    payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskAborted" /* TaskAborted */),
+    payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskFocused" /* TaskFocused */),
+    payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskUnfocused" /* TaskUnfocused */),
+    payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskActive" /* TaskActive */),
+    payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskIdle" /* TaskIdle */),
+    payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  // Subtask Lifecycle
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskPaused" /* TaskPaused */),
+    payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskUnpaused" /* TaskUnpaused */),
+    payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskSpawned" /* TaskSpawned */),
+    payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  // Task Execution
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("message" /* Message */),
+    payload: rooCodeEventsSchema.shape["message" /* Message */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskModeSwitched" /* TaskModeSwitched */),
+    payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskAskResponded" /* TaskAskResponded */),
+    payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  // Task Analytics
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskToolFailed" /* TaskToolFailed */),
+    payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
+    payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
+    taskId: import_zod4.z.number().optional()
+  }),
+  // Evals
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("evalPass" /* EvalPass */),
+    payload: import_zod4.z.undefined(),
+    taskId: import_zod4.z.number()
+  }),
+  import_zod4.z.object({
+    eventName: import_zod4.z.literal("evalFail" /* EvalFail */),
+    payload: import_zod4.z.undefined(),
+    taskId: import_zod4.z.number()
+  })
+]);
+
+// src/experiment.ts
+var import_zod5 = require("zod");
+var experimentIds = ["powerSteering", "multiFileApplyDiff", "preventFocusDisruption", "assistantMessageParser"];
+var experimentIdsSchema = import_zod5.z.enum(experimentIds);
+var experimentsSchema = import_zod5.z.object({
+  powerSteering: import_zod5.z.boolean().optional(),
+  multiFileApplyDiff: import_zod5.z.boolean().optional(),
+  preventFocusDisruption: import_zod5.z.boolean().optional(),
+  assistantMessageParser: import_zod5.z.boolean().optional()
 });
-var codebaseIndexProviderSchema = import_zod2.z.object({
-  codeIndexOpenAiKey: import_zod2.z.string().optional(),
-  codeIndexQdrantApiKey: import_zod2.z.string().optional(),
-  codebaseIndexOpenAiCompatibleBaseUrl: import_zod2.z.string().optional(),
-  codebaseIndexOpenAiCompatibleApiKey: import_zod2.z.string().optional(),
-  codebaseIndexOpenAiCompatibleModelDimension: import_zod2.z.number().optional(),
-  codebaseIndexGeminiApiKey: import_zod2.z.string().optional(),
-  codebaseIndexMistralApiKey: import_zod2.z.string().optional()
+
+// src/followup.ts
+var import_zod6 = require("zod");
+var suggestionItemSchema = import_zod6.z.object({
+  answer: import_zod6.z.string(),
+  mode: import_zod6.z.string().optional()
+});
+var followUpDataSchema = import_zod6.z.object({
+  question: import_zod6.z.string().optional(),
+  suggest: import_zod6.z.array(suggestionItemSchema).optional()
 });
 
+// src/global-settings.ts
+var import_zod13 = require("zod");
+
 // src/provider-settings.ts
+var import_zod8 = require("zod");
+
+// src/model.ts
+var import_zod7 = require("zod");
+var reasoningEfforts = ["low", "medium", "high"];
+var reasoningEffortsSchema = import_zod7.z.enum(reasoningEfforts);
+var verbosityLevels = ["low", "medium", "high"];
+var verbosityLevelsSchema = import_zod7.z.enum(verbosityLevels);
+var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
+var modelParametersSchema = import_zod7.z.enum(modelParameters);
+var isModelParameter = (value) => modelParameters.includes(value);
+var modelInfoSchema = import_zod7.z.object({
+  maxTokens: import_zod7.z.number().nullish(),
+  maxThinkingTokens: import_zod7.z.number().nullish(),
+  contextWindow: import_zod7.z.number(),
+  supportsImages: import_zod7.z.boolean().optional(),
+  supportsComputerUse: import_zod7.z.boolean().optional(),
+  supportsPromptCache: import_zod7.z.boolean(),
+  // Capability flag to indicate whether the model supports an output verbosity parameter
+  supportsVerbosity: import_zod7.z.boolean().optional(),
+  supportsReasoningBudget: import_zod7.z.boolean().optional(),
+  requiredReasoningBudget: import_zod7.z.boolean().optional(),
+  supportsReasoningEffort: import_zod7.z.boolean().optional(),
+  supportedParameters: import_zod7.z.array(modelParametersSchema).optional(),
+  inputPrice: import_zod7.z.number().optional(),
+  outputPrice: import_zod7.z.number().optional(),
+  cacheWritesPrice: import_zod7.z.number().optional(),
+  cacheReadsPrice: import_zod7.z.number().optional(),
+  description: import_zod7.z.string().optional(),
+  reasoningEffort: reasoningEffortsSchema.optional(),
+  minTokensPerCachePoint: import_zod7.z.number().optional(),
+  maxCachePoints: import_zod7.z.number().optional(),
+  cachableFields: import_zod7.z.array(import_zod7.z.string()).optional(),
+  tiers: import_zod7.z.array(
+    import_zod7.z.object({
+      contextWindow: import_zod7.z.number(),
+      inputPrice: import_zod7.z.number().optional(),
+      outputPrice: import_zod7.z.number().optional(),
+      cacheWritesPrice: import_zod7.z.number().optional(),
+      cacheReadsPrice: import_zod7.z.number().optional()
+    })
+  ).optional()
+});
+
+// src/provider-settings.ts
+var BEDROCK_CLAUDE_SONNET_4_MODEL_ID = "anthropic.claude-sonnet-4-20250514-v1:0";
+var extendedReasoningEffortsSchema = import_zod8.z.union([reasoningEffortsSchema, import_zod8.z.literal("minimal")]);
 var providerNames = [
   "anthropic",
   "claude-code",
@@ -334,214 +652,232 @@ var providerNames = [
   "huggingface",
   "cerebras",
   "sambanova",
-  "zai"
+  "zai",
+  "fireworks",
+  "io-intelligence"
 ];
-var providerNamesSchema = import_zod3.z.enum(providerNames);
-var providerSettingsEntrySchema = import_zod3.z.object({
-  id: import_zod3.z.string(),
-  name: import_zod3.z.string(),
+var providerNamesSchema = import_zod8.z.enum(providerNames);
+var providerSettingsEntrySchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  name: import_zod8.z.string(),
   apiProvider: providerNamesSchema.optional()
 });
 var DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3;
-var baseProviderSettingsSchema = import_zod3.z.object({
-  includeMaxTokens: import_zod3.z.boolean().optional(),
-  diffEnabled: import_zod3.z.boolean().optional(),
-  todoListEnabled: import_zod3.z.boolean().optional(),
-  fuzzyMatchThreshold: import_zod3.z.number().optional(),
-  modelTemperature: import_zod3.z.number().nullish(),
-  rateLimitSeconds: import_zod3.z.number().optional(),
-  consecutiveMistakeLimit: import_zod3.z.number().min(0).optional(),
+var baseProviderSettingsSchema = import_zod8.z.object({
+  includeMaxTokens: import_zod8.z.boolean().optional(),
+  diffEnabled: import_zod8.z.boolean().optional(),
+  todoListEnabled: import_zod8.z.boolean().optional(),
+  fuzzyMatchThreshold: import_zod8.z.number().optional(),
+  modelTemperature: import_zod8.z.number().nullish(),
+  rateLimitSeconds: import_zod8.z.number().optional(),
+  consecutiveMistakeLimit: import_zod8.z.number().min(0).optional(),
   // Model reasoning.
-  enableReasoningEffort: import_zod3.z.boolean().optional(),
-  reasoningEffort: reasoningEffortsSchema.optional(),
-  modelMaxTokens: import_zod3.z.number().optional(),
-  modelMaxThinkingTokens: import_zod3.z.number().optional()
+  enableReasoningEffort: import_zod8.z.boolean().optional(),
+  reasoningEffort: extendedReasoningEffortsSchema.optional(),
+  modelMaxTokens: import_zod8.z.number().optional(),
+  modelMaxThinkingTokens: import_zod8.z.number().optional(),
+  // Model verbosity.
+  verbosity: verbosityLevelsSchema.optional()
 });
 var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
-  apiModelId: import_zod3.z.string().optional()
+  apiModelId: import_zod8.z.string().optional()
 });
 var anthropicSchema = apiModelIdProviderModelSchema.extend({
-  apiKey: import_zod3.z.string().optional(),
-  anthropicBaseUrl: import_zod3.z.string().optional(),
-  anthropicUseAuthToken: import_zod3.z.boolean().optional()
+  apiKey: import_zod8.z.string().optional(),
+  anthropicBaseUrl: import_zod8.z.string().optional(),
+  anthropicUseAuthToken: import_zod8.z.boolean().optional(),
+  anthropicBeta1MContext: import_zod8.z.boolean().optional()
+  // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var claudeCodeSchema = apiModelIdProviderModelSchema.extend({
-  claudeCodePath: import_zod3.z.string().optional(),
-  claudeCodeMaxOutputTokens: import_zod3.z.number().int().min(1).max(2e5).optional()
+  claudeCodePath: import_zod8.z.string().optional(),
+  claudeCodeMaxOutputTokens: import_zod8.z.number().int().min(1).max(2e5).optional()
 });
 var glamaSchema = baseProviderSettingsSchema.extend({
-  glamaModelId: import_zod3.z.string().optional(),
-  glamaApiKey: import_zod3.z.string().optional()
+  glamaModelId: import_zod8.z.string().optional(),
+  glamaApiKey: import_zod8.z.string().optional()
 });
 var openRouterSchema = baseProviderSettingsSchema.extend({
-  openRouterApiKey: import_zod3.z.string().optional(),
-  openRouterModelId: import_zod3.z.string().optional(),
-  openRouterBaseUrl: import_zod3.z.string().optional(),
-  openRouterSpecificProvider: import_zod3.z.string().optional(),
-  openRouterUseMiddleOutTransform: import_zod3.z.boolean().optional()
+  openRouterApiKey: import_zod8.z.string().optional(),
+  openRouterModelId: import_zod8.z.string().optional(),
+  openRouterBaseUrl: import_zod8.z.string().optional(),
+  openRouterSpecificProvider: import_zod8.z.string().optional(),
+  openRouterUseMiddleOutTransform: import_zod8.z.boolean().optional()
 });
 var bedrockSchema = apiModelIdProviderModelSchema.extend({
-  awsAccessKey: import_zod3.z.string().optional(),
-  awsSecretKey: import_zod3.z.string().optional(),
-  awsSessionToken: import_zod3.z.string().optional(),
-  awsRegion: import_zod3.z.string().optional(),
-  awsUseCrossRegionInference: import_zod3.z.boolean().optional(),
-  awsUsePromptCache: import_zod3.z.boolean().optional(),
-  awsProfile: import_zod3.z.string().optional(),
-  awsUseProfile: import_zod3.z.boolean().optional(),
-  awsApiKey: import_zod3.z.string().optional(),
-  awsUseApiKey: import_zod3.z.boolean().optional(),
-  awsCustomArn: import_zod3.z.string().optional(),
-  awsModelContextWindow: import_zod3.z.number().optional(),
-  awsBedrockEndpointEnabled: import_zod3.z.boolean().optional(),
-  awsBedrockEndpoint: import_zod3.z.string().optional()
+  awsAccessKey: import_zod8.z.string().optional(),
+  awsSecretKey: import_zod8.z.string().optional(),
+  awsSessionToken: import_zod8.z.string().optional(),
+  awsRegion: import_zod8.z.string().optional(),
+  awsUseCrossRegionInference: import_zod8.z.boolean().optional(),
+  awsUsePromptCache: import_zod8.z.boolean().optional(),
+  awsProfile: import_zod8.z.string().optional(),
+  awsUseProfile: import_zod8.z.boolean().optional(),
+  awsApiKey: import_zod8.z.string().optional(),
+  awsUseApiKey: import_zod8.z.boolean().optional(),
+  awsCustomArn: import_zod8.z.string().optional(),
+  awsModelContextWindow: import_zod8.z.number().optional(),
+  awsBedrockEndpointEnabled: import_zod8.z.boolean().optional(),
+  awsBedrockEndpoint: import_zod8.z.string().optional(),
+  awsBedrock1MContext: import_zod8.z.boolean().optional()
+  // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var vertexSchema = apiModelIdProviderModelSchema.extend({
-  vertexKeyFile: import_zod3.z.string().optional(),
-  vertexJsonCredentials: import_zod3.z.string().optional(),
-  vertexProjectId: import_zod3.z.string().optional(),
-  vertexRegion: import_zod3.z.string().optional()
+  vertexKeyFile: import_zod8.z.string().optional(),
+  vertexJsonCredentials: import_zod8.z.string().optional(),
+  vertexProjectId: import_zod8.z.string().optional(),
+  vertexRegion: import_zod8.z.string().optional()
 });
 var openAiSchema = baseProviderSettingsSchema.extend({
-  openAiBaseUrl: import_zod3.z.string().optional(),
-  openAiApiKey: import_zod3.z.string().optional(),
-  openAiLegacyFormat: import_zod3.z.boolean().optional(),
-  openAiR1FormatEnabled: import_zod3.z.boolean().optional(),
-  openAiModelId: import_zod3.z.string().optional(),
+  openAiBaseUrl: import_zod8.z.string().optional(),
+  openAiApiKey: import_zod8.z.string().optional(),
+  openAiLegacyFormat: import_zod8.z.boolean().optional(),
+  openAiR1FormatEnabled: import_zod8.z.boolean().optional(),
+  openAiModelId: import_zod8.z.string().optional(),
   openAiCustomModelInfo: modelInfoSchema.nullish(),
-  openAiUseAzure: import_zod3.z.boolean().optional(),
-  azureApiVersion: import_zod3.z.string().optional(),
-  openAiStreamingEnabled: import_zod3.z.boolean().optional(),
-  openAiHostHeader: import_zod3.z.string().optional(),
+  openAiUseAzure: import_zod8.z.boolean().optional(),
+  azureApiVersion: import_zod8.z.string().optional(),
+  openAiStreamingEnabled: import_zod8.z.boolean().optional(),
+  openAiHostHeader: import_zod8.z.string().optional(),
   // Keep temporarily for backward compatibility during migration.
-  openAiHeaders: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).optional()
+  openAiHeaders: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional()
 });
 var ollamaSchema = baseProviderSettingsSchema.extend({
-  ollamaModelId: import_zod3.z.string().optional(),
-  ollamaBaseUrl: import_zod3.z.string().optional()
+  ollamaModelId: import_zod8.z.string().optional(),
+  ollamaBaseUrl: import_zod8.z.string().optional()
 });
 var vsCodeLmSchema = baseProviderSettingsSchema.extend({
-  vsCodeLmModelSelector: import_zod3.z.object({
-    vendor: import_zod3.z.string().optional(),
-    family: import_zod3.z.string().optional(),
-    version: import_zod3.z.string().optional(),
-    id: import_zod3.z.string().optional()
+  vsCodeLmModelSelector: import_zod8.z.object({
+    vendor: import_zod8.z.string().optional(),
+    family: import_zod8.z.string().optional(),
+    version: import_zod8.z.string().optional(),
+    id: import_zod8.z.string().optional()
   }).optional()
 });
 var lmStudioSchema = baseProviderSettingsSchema.extend({
-  lmStudioModelId: import_zod3.z.string().optional(),
-  lmStudioBaseUrl: import_zod3.z.string().optional(),
-  lmStudioDraftModelId: import_zod3.z.string().optional(),
-  lmStudioSpeculativeDecodingEnabled: import_zod3.z.boolean().optional()
+  lmStudioModelId: import_zod8.z.string().optional(),
+  lmStudioBaseUrl: import_zod8.z.string().optional(),
+  lmStudioDraftModelId: import_zod8.z.string().optional(),
+  lmStudioSpeculativeDecodingEnabled: import_zod8.z.boolean().optional()
 });
 var geminiSchema = apiModelIdProviderModelSchema.extend({
-  geminiApiKey: import_zod3.z.string().optional(),
-  googleGeminiBaseUrl: import_zod3.z.string().optional(),
-  enableUrlContext: import_zod3.z.boolean().optional(),
-  enableGrounding: import_zod3.z.boolean().optional()
+  geminiApiKey: import_zod8.z.string().optional(),
+  googleGeminiBaseUrl: import_zod8.z.string().optional(),
+  enableUrlContext: import_zod8.z.boolean().optional(),
+  enableGrounding: import_zod8.z.boolean().optional()
 });
 var geminiCliSchema = apiModelIdProviderModelSchema.extend({
-  geminiCliOAuthPath: import_zod3.z.string().optional(),
-  geminiCliProjectId: import_zod3.z.string().optional()
+  geminiCliOAuthPath: import_zod8.z.string().optional(),
+  geminiCliProjectId: import_zod8.z.string().optional()
 });
 var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
-  openAiNativeApiKey: import_zod3.z.string().optional(),
-  openAiNativeBaseUrl: import_zod3.z.string().optional()
+  openAiNativeApiKey: import_zod8.z.string().optional(),
+  openAiNativeBaseUrl: import_zod8.z.string().optional()
 });
 var mistralSchema = apiModelIdProviderModelSchema.extend({
-  mistralApiKey: import_zod3.z.string().optional(),
-  mistralCodestralUrl: import_zod3.z.string().optional()
+  mistralApiKey: import_zod8.z.string().optional(),
+  mistralCodestralUrl: import_zod8.z.string().optional()
 });
 var deepSeekSchema = apiModelIdProviderModelSchema.extend({
-  deepSeekBaseUrl: import_zod3.z.string().optional(),
-  deepSeekApiKey: import_zod3.z.string().optional()
+  deepSeekBaseUrl: import_zod8.z.string().optional(),
+  deepSeekApiKey: import_zod8.z.string().optional()
 });
 var doubaoSchema = apiModelIdProviderModelSchema.extend({
-  doubaoBaseUrl: import_zod3.z.string().optional(),
-  doubaoApiKey: import_zod3.z.string().optional()
+  doubaoBaseUrl: import_zod8.z.string().optional(),
+  doubaoApiKey: import_zod8.z.string().optional()
 });
 var moonshotSchema = apiModelIdProviderModelSchema.extend({
-  moonshotBaseUrl: import_zod3.z.union([import_zod3.z.literal("https://api.moonshot.ai/v1"), import_zod3.z.literal("https://api.moonshot.cn/v1")]).optional(),
-  moonshotApiKey: import_zod3.z.string().optional()
+  moonshotBaseUrl: import_zod8.z.union([import_zod8.z.literal("https://api.moonshot.ai/v1"), import_zod8.z.literal("https://api.moonshot.cn/v1")]).optional(),
+  moonshotApiKey: import_zod8.z.string().optional()
 });
 var unboundSchema = baseProviderSettingsSchema.extend({
-  unboundApiKey: import_zod3.z.string().optional(),
-  unboundModelId: import_zod3.z.string().optional()
+  unboundApiKey: import_zod8.z.string().optional(),
+  unboundModelId: import_zod8.z.string().optional()
 });
 var requestySchema = baseProviderSettingsSchema.extend({
-  requestyApiKey: import_zod3.z.string().optional(),
-  requestyModelId: import_zod3.z.string().optional()
+  requestyBaseUrl: import_zod8.z.string().optional(),
+  requestyApiKey: import_zod8.z.string().optional(),
+  requestyModelId: import_zod8.z.string().optional()
 });
 var humanRelaySchema = baseProviderSettingsSchema;
 var fakeAiSchema = baseProviderSettingsSchema.extend({
-  fakeAi: import_zod3.z.unknown().optional()
+  fakeAi: import_zod8.z.unknown().optional()
 });
 var xaiSchema = apiModelIdProviderModelSchema.extend({
-  xaiApiKey: import_zod3.z.string().optional()
+  xaiApiKey: import_zod8.z.string().optional()
 });
 var groqSchema = apiModelIdProviderModelSchema.extend({
-  groqApiKey: import_zod3.z.string().optional()
+  groqApiKey: import_zod8.z.string().optional()
 });
 var huggingFaceSchema = baseProviderSettingsSchema.extend({
-  huggingFaceApiKey: import_zod3.z.string().optional(),
-  huggingFaceModelId: import_zod3.z.string().optional(),
-  huggingFaceInferenceProvider: import_zod3.z.string().optional()
+  huggingFaceApiKey: import_zod8.z.string().optional(),
+  huggingFaceModelId: import_zod8.z.string().optional(),
+  huggingFaceInferenceProvider: import_zod8.z.string().optional()
 });
 var chutesSchema = apiModelIdProviderModelSchema.extend({
-  chutesApiKey: import_zod3.z.string().optional()
+  chutesApiKey: import_zod8.z.string().optional()
 });
 var litellmSchema = baseProviderSettingsSchema.extend({
-  litellmBaseUrl: import_zod3.z.string().optional(),
-  litellmApiKey: import_zod3.z.string().optional(),
-  litellmModelId: import_zod3.z.string().optional(),
-  litellmUsePromptCache: import_zod3.z.boolean().optional()
+  litellmBaseUrl: import_zod8.z.string().optional(),
+  litellmApiKey: import_zod8.z.string().optional(),
+  litellmModelId: import_zod8.z.string().optional(),
+  litellmUsePromptCache: import_zod8.z.boolean().optional()
 });
 var cerebrasSchema = apiModelIdProviderModelSchema.extend({
-  cerebrasApiKey: import_zod3.z.string().optional()
+  cerebrasApiKey: import_zod8.z.string().optional()
 });
 var sambaNovaSchema = apiModelIdProviderModelSchema.extend({
-  sambaNovaApiKey: import_zod3.z.string().optional()
+  sambaNovaApiKey: import_zod8.z.string().optional()
 });
 var zaiSchema = apiModelIdProviderModelSchema.extend({
-  zaiApiKey: import_zod3.z.string().optional(),
-  zaiApiLine: import_zod3.z.union([import_zod3.z.literal("china"), import_zod3.z.literal("international")]).optional()
+  zaiApiKey: import_zod8.z.string().optional(),
+  zaiApiLine: import_zod8.z.union([import_zod8.z.literal("china"), import_zod8.z.literal("international")]).optional()
 });
-var defaultSchema = import_zod3.z.object({
-  apiProvider: import_zod3.z.undefined()
+var fireworksSchema = apiModelIdProviderModelSchema.extend({
+  fireworksApiKey: import_zod8.z.string().optional()
 });
-var providerSettingsSchemaDiscriminated = import_zod3.z.discriminatedUnion("apiProvider", [
-  anthropicSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("anthropic") })),
-  claudeCodeSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("claude-code") })),
-  glamaSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("glama") })),
-  openRouterSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("openrouter") })),
-  bedrockSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("bedrock") })),
-  vertexSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("vertex") })),
-  openAiSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("openai") })),
-  ollamaSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("ollama") })),
-  vsCodeLmSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("vscode-lm") })),
-  lmStudioSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("lmstudio") })),
-  geminiSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("gemini") })),
-  geminiCliSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("gemini-cli") })),
-  openAiNativeSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("openai-native") })),
-  mistralSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("mistral") })),
-  deepSeekSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("deepseek") })),
-  doubaoSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("doubao") })),
-  moonshotSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("moonshot") })),
-  unboundSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("unbound") })),
-  requestySchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("requesty") })),
-  humanRelaySchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("human-relay") })),
-  fakeAiSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("fake-ai") })),
-  xaiSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("xai") })),
-  groqSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("groq") })),
-  huggingFaceSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("huggingface") })),
-  chutesSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("chutes") })),
-  litellmSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("litellm") })),
-  cerebrasSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("cerebras") })),
-  sambaNovaSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("sambanova") })),
-  zaiSchema.merge(import_zod3.z.object({ apiProvider: import_zod3.z.literal("zai") })),
+var ioIntelligenceSchema = apiModelIdProviderModelSchema.extend({
+  ioIntelligenceModelId: import_zod8.z.string().optional(),
+  ioIntelligenceApiKey: import_zod8.z.string().optional()
+});
+var defaultSchema = import_zod8.z.object({
+  apiProvider: import_zod8.z.undefined()
+});
+var providerSettingsSchemaDiscriminated = import_zod8.z.discriminatedUnion("apiProvider", [
+  anthropicSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("anthropic") })),
+  claudeCodeSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("claude-code") })),
+  glamaSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("glama") })),
+  openRouterSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("openrouter") })),
+  bedrockSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("bedrock") })),
+  vertexSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("vertex") })),
+  openAiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("openai") })),
+  ollamaSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("ollama") })),
+  vsCodeLmSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("vscode-lm") })),
+  lmStudioSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("lmstudio") })),
+  geminiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("gemini") })),
+  geminiCliSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("gemini-cli") })),
+  openAiNativeSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("openai-native") })),
+  mistralSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("mistral") })),
+  deepSeekSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("deepseek") })),
+  doubaoSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("doubao") })),
+  moonshotSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("moonshot") })),
+  unboundSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("unbound") })),
+  requestySchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("requesty") })),
+  humanRelaySchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("human-relay") })),
+  fakeAiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("fake-ai") })),
+  xaiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("xai") })),
+  groqSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("groq") })),
+  huggingFaceSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("huggingface") })),
+  chutesSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("chutes") })),
+  litellmSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("litellm") })),
+  cerebrasSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("cerebras") })),
+  sambaNovaSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("sambanova") })),
+  zaiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("zai") })),
+  fireworksSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("fireworks") })),
+  ioIntelligenceSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("io-intelligence") })),
   defaultSchema
 ]);
-var providerSettingsSchema = import_zod3.z.object({
+var providerSettingsSchema = import_zod8.z.object({
   apiProvider: providerNamesSchema.optional(),
   ...anthropicSchema.shape,
   ...claudeCodeSchema.shape,
@@ -572,11 +908,13 @@ var providerSettingsSchema = import_zod3.z.object({
   ...cerebrasSchema.shape,
   ...sambaNovaSchema.shape,
   ...zaiSchema.shape,
+  ...fireworksSchema.shape,
+  ...ioIntelligenceSchema.shape,
   ...codebaseIndexProviderSchema.shape
 });
-var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: import_zod3.z.string().optional() });
+var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: import_zod8.z.string().optional() });
 var discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
-  import_zod3.z.object({ id: import_zod3.z.string().optional() })
+  import_zod8.z.object({ id: import_zod8.z.string().optional() })
 );
 var PROVIDER_SETTINGS_KEYS = providerSettingsSchema.keyof().options;
 var MODEL_ID_KEYS = [
@@ -590,7 +928,8 @@ var MODEL_ID_KEYS = [
   "unboundModelId",
   "requestyModelId",
   "litellmModelId",
-  "huggingFaceModelId"
+  "huggingFaceModelId",
+  "ioIntelligenceModelId"
 ];
 var getModelId = (settings) => {
   const modelIdKey = MODEL_ID_KEYS.find((key) => settings[key]);
@@ -608,131 +947,26 @@ var getApiProtocol = (provider, modelId) => {
 };
 
 // src/history.ts
-var import_zod4 = require("zod");
-var historyItemSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  number: import_zod4.z.number(),
-  ts: import_zod4.z.number(),
-  task: import_zod4.z.string(),
-  tokensIn: import_zod4.z.number(),
-  tokensOut: import_zod4.z.number(),
-  cacheWrites: import_zod4.z.number().optional(),
-  cacheReads: import_zod4.z.number().optional(),
-  totalCost: import_zod4.z.number(),
-  size: import_zod4.z.number().optional(),
-  workspace: import_zod4.z.string().optional(),
-  mode: import_zod4.z.string().optional()
-});
-
-// src/experiment.ts
-var import_zod5 = require("zod");
-var experimentIds = ["powerSteering", "multiFileApplyDiff", "preventFocusDisruption", "assistantMessageParser"];
-var experimentIdsSchema = import_zod5.z.enum(experimentIds);
-var experimentsSchema = import_zod5.z.object({
-  powerSteering: import_zod5.z.boolean().optional(),
-  multiFileApplyDiff: import_zod5.z.boolean().optional(),
-  preventFocusDisruption: import_zod5.z.boolean().optional(),
-  assistantMessageParser: import_zod5.z.boolean().optional()
-});
-
-// src/telemetry.ts
-var import_zod7 = require("zod");
-
-// src/message.ts
-var import_zod6 = require("zod");
-var clineAsks = [
-  "followup",
-  "command",
-  "command_output",
-  "completion_result",
-  "tool",
-  "api_req_failed",
-  "resume_task",
-  "resume_completed_task",
-  "mistake_limit_reached",
-  "browser_action_launch",
-  "use_mcp_server",
-  "auto_approval_max_req_reached"
-];
-var clineAskSchema = import_zod6.z.enum(clineAsks);
-var blockingAsks = [
-  "api_req_failed",
-  "mistake_limit_reached",
-  "completion_result",
-  "resume_task",
-  "resume_completed_task",
-  "command_output",
-  "auto_approval_max_req_reached"
-];
-function isBlockingAsk(ask) {
-  return blockingAsks.includes(ask);
-}
-var clineSays = [
-  "error",
-  "api_req_started",
-  "api_req_finished",
-  "api_req_retried",
-  "api_req_retry_delayed",
-  "api_req_deleted",
-  "text",
-  "reasoning",
-  "completion_result",
-  "user_feedback",
-  "user_feedback_diff",
-  "command_output",
-  "shell_integration_warning",
-  "browser_action",
-  "browser_action_result",
-  "mcp_server_request_started",
-  "mcp_server_response",
-  "subtask_result",
-  "checkpoint_saved",
-  "rooignore_error",
-  "diff_error",
-  "condense_context",
-  "condense_context_error",
-  "codebase_search_result",
-  "user_edit_todos"
-];
-var clineSaySchema = import_zod6.z.enum(clineSays);
-var toolProgressStatusSchema = import_zod6.z.object({
-  icon: import_zod6.z.string().optional(),
-  text: import_zod6.z.string().optional()
-});
-var contextCondenseSchema = import_zod6.z.object({
-  cost: import_zod6.z.number(),
-  prevContextTokens: import_zod6.z.number(),
-  newContextTokens: import_zod6.z.number(),
-  summary: import_zod6.z.string()
-});
-var clineMessageSchema = import_zod6.z.object({
-  ts: import_zod6.z.number(),
-  type: import_zod6.z.union([import_zod6.z.literal("ask"), import_zod6.z.literal("say")]),
-  ask: clineAskSchema.optional(),
-  say: clineSaySchema.optional(),
-  text: import_zod6.z.string().optional(),
-  images: import_zod6.z.array(import_zod6.z.string()).optional(),
-  partial: import_zod6.z.boolean().optional(),
-  reasoning: import_zod6.z.string().optional(),
-  conversationHistoryIndex: import_zod6.z.number().optional(),
-  checkpoint: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional(),
-  progressStatus: toolProgressStatusSchema.optional(),
-  contextCondense: contextCondenseSchema.optional(),
-  isProtected: import_zod6.z.boolean().optional(),
-  apiProtocol: import_zod6.z.union([import_zod6.z.literal("openai"), import_zod6.z.literal("anthropic")]).optional()
-});
-var tokenUsageSchema = import_zod6.z.object({
-  totalTokensIn: import_zod6.z.number(),
-  totalTokensOut: import_zod6.z.number(),
-  totalCacheWrites: import_zod6.z.number().optional(),
-  totalCacheReads: import_zod6.z.number().optional(),
-  totalCost: import_zod6.z.number(),
-  contextTokens: import_zod6.z.number()
+var import_zod9 = require("zod");
+var historyItemSchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  number: import_zod9.z.number(),
+  ts: import_zod9.z.number(),
+  task: import_zod9.z.string(),
+  tokensIn: import_zod9.z.number(),
+  tokensOut: import_zod9.z.number(),
+  cacheWrites: import_zod9.z.number().optional(),
+  cacheReads: import_zod9.z.number().optional(),
+  totalCost: import_zod9.z.number(),
+  size: import_zod9.z.number().optional(),
+  workspace: import_zod9.z.string().optional(),
+  mode: import_zod9.z.string().optional()
 });
 
 // src/telemetry.ts
+var import_zod10 = require("zod");
 var telemetrySettings = ["unset", "enabled", "disabled"];
-var telemetrySettingsSchema = import_zod7.z.enum(telemetrySettings);
+var telemetrySettingsSchema = import_zod10.z.enum(telemetrySettings);
 var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
   TelemetryEventName2["TASK_CREATED"] = "Task Created";
   TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
@@ -774,42 +1008,42 @@ var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
   TelemetryEventName2["CODE_INDEX_ERROR"] = "Code Index Error";
   return TelemetryEventName2;
 })(TelemetryEventName || {});
-var appPropertiesSchema = import_zod7.z.object({
-  appName: import_zod7.z.string(),
-  appVersion: import_zod7.z.string(),
-  vscodeVersion: import_zod7.z.string(),
-  platform: import_zod7.z.string(),
-  editorName: import_zod7.z.string(),
-  language: import_zod7.z.string(),
-  mode: import_zod7.z.string(),
-  cloudIsAuthenticated: import_zod7.z.boolean().optional()
+var appPropertiesSchema = import_zod10.z.object({
+  appName: import_zod10.z.string(),
+  appVersion: import_zod10.z.string(),
+  vscodeVersion: import_zod10.z.string(),
+  platform: import_zod10.z.string(),
+  editorName: import_zod10.z.string(),
+  language: import_zod10.z.string(),
+  mode: import_zod10.z.string(),
+  cloudIsAuthenticated: import_zod10.z.boolean().optional()
 });
-var taskPropertiesSchema = import_zod7.z.object({
-  taskId: import_zod7.z.string().optional(),
-  apiProvider: import_zod7.z.enum(providerNames).optional(),
-  modelId: import_zod7.z.string().optional(),
-  diffStrategy: import_zod7.z.string().optional(),
-  isSubtask: import_zod7.z.boolean().optional(),
-  todos: import_zod7.z.object({
-    total: import_zod7.z.number(),
-    completed: import_zod7.z.number(),
-    inProgress: import_zod7.z.number(),
-    pending: import_zod7.z.number()
+var taskPropertiesSchema = import_zod10.z.object({
+  taskId: import_zod10.z.string().optional(),
+  apiProvider: import_zod10.z.enum(providerNames).optional(),
+  modelId: import_zod10.z.string().optional(),
+  diffStrategy: import_zod10.z.string().optional(),
+  isSubtask: import_zod10.z.boolean().optional(),
+  todos: import_zod10.z.object({
+    total: import_zod10.z.number(),
+    completed: import_zod10.z.number(),
+    inProgress: import_zod10.z.number(),
+    pending: import_zod10.z.number()
   }).optional()
 });
-var gitPropertiesSchema = import_zod7.z.object({
-  repositoryUrl: import_zod7.z.string().optional(),
-  repositoryName: import_zod7.z.string().optional(),
-  defaultBranch: import_zod7.z.string().optional()
+var gitPropertiesSchema = import_zod10.z.object({
+  repositoryUrl: import_zod10.z.string().optional(),
+  repositoryName: import_zod10.z.string().optional(),
+  defaultBranch: import_zod10.z.string().optional()
 });
-var telemetryPropertiesSchema = import_zod7.z.object({
+var telemetryPropertiesSchema = import_zod10.z.object({
   ...appPropertiesSchema.shape,
   ...taskPropertiesSchema.shape,
   ...gitPropertiesSchema.shape
 });
-var rooCodeTelemetryEventSchema = import_zod7.z.discriminatedUnion("type", [
-  import_zod7.z.object({
-    type: import_zod7.z.enum([
+var rooCodeTelemetryEventSchema = import_zod10.z.discriminatedUnion("type", [
+  import_zod10.z.object({
+    type: import_zod10.z.enum([
       "Task Created" /* TASK_CREATED */,
       "Task Reopened" /* TASK_RESTARTED */,
       "Task Completed" /* TASK_COMPLETED */,
@@ -849,67 +1083,31 @@ var rooCodeTelemetryEventSchema = import_zod7.z.discriminatedUnion("type", [
     ]),
     properties: telemetryPropertiesSchema
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("Task Message" /* TASK_MESSAGE */),
-    properties: import_zod7.z.object({
+  import_zod10.z.object({
+    type: import_zod10.z.literal("Task Message" /* TASK_MESSAGE */),
+    properties: import_zod10.z.object({
       ...telemetryPropertiesSchema.shape,
-      taskId: import_zod7.z.string(),
+      taskId: import_zod10.z.string(),
       message: clineMessageSchema
     })
   }),
-  import_zod7.z.object({
-    type: import_zod7.z.literal("LLM Completion" /* LLM_COMPLETION */),
-    properties: import_zod7.z.object({
+  import_zod10.z.object({
+    type: import_zod10.z.literal("LLM Completion" /* LLM_COMPLETION */),
+    properties: import_zod10.z.object({
       ...telemetryPropertiesSchema.shape,
-      inputTokens: import_zod7.z.number(),
-      outputTokens: import_zod7.z.number(),
-      cacheReadTokens: import_zod7.z.number().optional(),
-      cacheWriteTokens: import_zod7.z.number().optional(),
-      cost: import_zod7.z.number().optional()
+      inputTokens: import_zod10.z.number(),
+      outputTokens: import_zod10.z.number(),
+      cacheReadTokens: import_zod10.z.number().optional(),
+      cacheWriteTokens: import_zod10.z.number().optional(),
+      cost: import_zod10.z.number().optional()
     })
   })
 ]);
 
 // src/mode.ts
-var import_zod9 = require("zod");
-
-// src/tool.ts
-var import_zod8 = require("zod");
-var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
-var toolGroupsSchema = import_zod8.z.enum(toolGroups);
-var toolNames = [
-  "execute_command",
-  "read_file",
-  "write_to_file",
-  "apply_diff",
-  "insert_content",
-  "search_and_replace",
-  "search_files",
-  "list_files",
-  "list_code_definition_names",
-  "browser_action",
-  "use_mcp_tool",
-  "access_mcp_resource",
-  "ask_followup_question",
-  "attempt_completion",
-  "switch_mode",
-  "new_task",
-  "fetch_instructions",
-  "codebase_search",
-  "update_todo_list"
-];
-var toolNamesSchema = import_zod8.z.enum(toolNames);
-var toolUsageSchema = import_zod8.z.record(
-  toolNamesSchema,
-  import_zod8.z.object({
-    attempts: import_zod8.z.number(),
-    failures: import_zod8.z.number()
-  })
-);
-
-// src/mode.ts
-var groupOptionsSchema = import_zod9.z.object({
-  fileRegex: import_zod9.z.string().optional().refine(
+var import_zod11 = require("zod");
+var groupOptionsSchema = import_zod11.z.object({
+  fileRegex: import_zod11.z.string().optional().refine(
     (pattern) => {
       if (!pattern) {
         return true;
@@ -923,10 +1121,10 @@ var groupOptionsSchema = import_zod9.z.object({
     },
     { message: "Invalid regular expression pattern" }
   ),
-  description: import_zod9.z.string().optional()
+  description: import_zod11.z.string().optional()
 });
-var groupEntrySchema = import_zod9.z.union([toolGroupsSchema, import_zod9.z.tuple([toolGroupsSchema, groupOptionsSchema])]);
-var groupEntryArraySchema = import_zod9.z.array(groupEntrySchema).refine(
+var groupEntrySchema = import_zod11.z.union([toolGroupsSchema, import_zod11.z.tuple([toolGroupsSchema, groupOptionsSchema])]);
+var groupEntryArraySchema = import_zod11.z.array(groupEntrySchema).refine(
   (groups) => {
     const seen = /* @__PURE__ */ new Set();
     return groups.every((group) => {
@@ -940,18 +1138,18 @@ var groupEntryArraySchema = import_zod9.z.array(groupEntrySchema).refine(
   },
   { message: "Duplicate groups are not allowed" }
 );
-var modeConfigSchema = import_zod9.z.object({
-  slug: import_zod9.z.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
-  name: import_zod9.z.string().min(1, "Name is required"),
-  roleDefinition: import_zod9.z.string().min(1, "Role definition is required"),
-  whenToUse: import_zod9.z.string().optional(),
-  description: import_zod9.z.string().optional(),
-  customInstructions: import_zod9.z.string().optional(),
+var modeConfigSchema = import_zod11.z.object({
+  slug: import_zod11.z.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
+  name: import_zod11.z.string().min(1, "Name is required"),
+  roleDefinition: import_zod11.z.string().min(1, "Role definition is required"),
+  whenToUse: import_zod11.z.string().optional(),
+  description: import_zod11.z.string().optional(),
+  customInstructions: import_zod11.z.string().optional(),
   groups: groupEntryArraySchema,
-  source: import_zod9.z.enum(["global", "project"]).optional()
+  source: import_zod11.z.enum(["global", "project"]).optional()
 });
-var customModesSettingsSchema = import_zod9.z.object({
-  customModes: import_zod9.z.array(modeConfigSchema).refine(
+var customModesSettingsSchema = import_zod11.z.object({
+  customModes: import_zod11.z.array(modeConfigSchema).refine(
     (modes) => {
       const slugs = /* @__PURE__ */ new Set();
       return modes.every((mode) => {
@@ -967,14 +1165,14 @@ var customModesSettingsSchema = import_zod9.z.object({
     }
   )
 });
-var promptComponentSchema = import_zod9.z.object({
-  roleDefinition: import_zod9.z.string().optional(),
-  whenToUse: import_zod9.z.string().optional(),
-  description: import_zod9.z.string().optional(),
-  customInstructions: import_zod9.z.string().optional()
+var promptComponentSchema = import_zod11.z.object({
+  roleDefinition: import_zod11.z.string().optional(),
+  whenToUse: import_zod11.z.string().optional(),
+  description: import_zod11.z.string().optional(),
+  customInstructions: import_zod11.z.string().optional()
 });
-var customModePromptsSchema = import_zod9.z.record(import_zod9.z.string(), promptComponentSchema.optional());
-var customSupportPromptsSchema = import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string().optional());
+var customModePromptsSchema = import_zod11.z.record(import_zod11.z.string(), promptComponentSchema.optional());
+var customSupportPromptsSchema = import_zod11.z.record(import_zod11.z.string(), import_zod11.z.string().optional());
 var DEFAULT_MODES = [
   {
     slug: "architect",
@@ -1023,7 +1221,7 @@ var DEFAULT_MODES = [
 ];
 
 // src/vscode.ts
-var import_zod10 = require("zod");
+var import_zod12 = require("zod");
 var codeActionIds = ["explainCode", "fixCode", "improveCode", "addToContext", "newTask"];
 var terminalActionIds = ["terminalAddToContext", "terminalFixCommand", "terminalExplainCommand"];
 var commandIds = [
@@ -1068,110 +1266,111 @@ var languages = [
   "zh-CN",
   "zh-TW"
 ];
-var languagesSchema = import_zod10.z.enum(languages);
+var languagesSchema = import_zod12.z.enum(languages);
 var isLanguage = (value) => languages.includes(value);
 
 // src/global-settings.ts
 var DEFAULT_WRITE_DELAY_MS = 1e3;
 var DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT = 5e4;
-var globalSettingsSchema = import_zod11.z.object({
-  currentApiConfigName: import_zod11.z.string().optional(),
-  listApiConfigMeta: import_zod11.z.array(providerSettingsEntrySchema).optional(),
-  pinnedApiConfigs: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.boolean()).optional(),
-  lastShownAnnouncementId: import_zod11.z.string().optional(),
-  customInstructions: import_zod11.z.string().optional(),
-  taskHistory: import_zod11.z.array(historyItemSchema).optional(),
-  condensingApiConfigId: import_zod11.z.string().optional(),
-  customCondensingPrompt: import_zod11.z.string().optional(),
-  autoApprovalEnabled: import_zod11.z.boolean().optional(),
-  alwaysAllowReadOnly: import_zod11.z.boolean().optional(),
-  alwaysAllowReadOnlyOutsideWorkspace: import_zod11.z.boolean().optional(),
-  alwaysAllowWrite: import_zod11.z.boolean().optional(),
-  alwaysAllowWriteOutsideWorkspace: import_zod11.z.boolean().optional(),
-  alwaysAllowWriteProtected: import_zod11.z.boolean().optional(),
-  writeDelayMs: import_zod11.z.number().min(0).optional(),
-  alwaysAllowBrowser: import_zod11.z.boolean().optional(),
-  alwaysApproveResubmit: import_zod11.z.boolean().optional(),
-  requestDelaySeconds: import_zod11.z.number().optional(),
-  alwaysAllowMcp: import_zod11.z.boolean().optional(),
-  alwaysAllowModeSwitch: import_zod11.z.boolean().optional(),
-  alwaysAllowSubtasks: import_zod11.z.boolean().optional(),
-  alwaysAllowExecute: import_zod11.z.boolean().optional(),
-  alwaysAllowFollowupQuestions: import_zod11.z.boolean().optional(),
-  followupAutoApproveTimeoutMs: import_zod11.z.number().optional(),
-  alwaysAllowUpdateTodoList: import_zod11.z.boolean().optional(),
-  allowedCommands: import_zod11.z.array(import_zod11.z.string()).optional(),
-  deniedCommands: import_zod11.z.array(import_zod11.z.string()).optional(),
-  commandExecutionTimeout: import_zod11.z.number().optional(),
-  commandTimeoutAllowlist: import_zod11.z.array(import_zod11.z.string()).optional(),
-  preventCompletionWithOpenTodos: import_zod11.z.boolean().optional(),
-  allowedMaxRequests: import_zod11.z.number().nullish(),
-  allowedMaxCost: import_zod11.z.number().nullish(),
-  autoCondenseContext: import_zod11.z.boolean().optional(),
-  autoCondenseContextPercent: import_zod11.z.number().optional(),
-  maxConcurrentFileReads: import_zod11.z.number().optional(),
+var DEFAULT_USAGE_COLLECTION_TIMEOUT_MS = 3e4;
+var globalSettingsSchema = import_zod13.z.object({
+  currentApiConfigName: import_zod13.z.string().optional(),
+  listApiConfigMeta: import_zod13.z.array(providerSettingsEntrySchema).optional(),
+  pinnedApiConfigs: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.boolean()).optional(),
+  lastShownAnnouncementId: import_zod13.z.string().optional(),
+  customInstructions: import_zod13.z.string().optional(),
+  taskHistory: import_zod13.z.array(historyItemSchema).optional(),
+  condensingApiConfigId: import_zod13.z.string().optional(),
+  customCondensingPrompt: import_zod13.z.string().optional(),
+  autoApprovalEnabled: import_zod13.z.boolean().optional(),
+  alwaysAllowReadOnly: import_zod13.z.boolean().optional(),
+  alwaysAllowReadOnlyOutsideWorkspace: import_zod13.z.boolean().optional(),
+  alwaysAllowWrite: import_zod13.z.boolean().optional(),
+  alwaysAllowWriteOutsideWorkspace: import_zod13.z.boolean().optional(),
+  alwaysAllowWriteProtected: import_zod13.z.boolean().optional(),
+  writeDelayMs: import_zod13.z.number().min(0).optional(),
+  alwaysAllowBrowser: import_zod13.z.boolean().optional(),
+  alwaysApproveResubmit: import_zod13.z.boolean().optional(),
+  requestDelaySeconds: import_zod13.z.number().optional(),
+  alwaysAllowMcp: import_zod13.z.boolean().optional(),
+  alwaysAllowModeSwitch: import_zod13.z.boolean().optional(),
+  alwaysAllowSubtasks: import_zod13.z.boolean().optional(),
+  alwaysAllowExecute: import_zod13.z.boolean().optional(),
+  alwaysAllowFollowupQuestions: import_zod13.z.boolean().optional(),
+  followupAutoApproveTimeoutMs: import_zod13.z.number().optional(),
+  alwaysAllowUpdateTodoList: import_zod13.z.boolean().optional(),
+  allowedCommands: import_zod13.z.array(import_zod13.z.string()).optional(),
+  deniedCommands: import_zod13.z.array(import_zod13.z.string()).optional(),
+  commandExecutionTimeout: import_zod13.z.number().optional(),
+  commandTimeoutAllowlist: import_zod13.z.array(import_zod13.z.string()).optional(),
+  preventCompletionWithOpenTodos: import_zod13.z.boolean().optional(),
+  allowedMaxRequests: import_zod13.z.number().nullish(),
+  allowedMaxCost: import_zod13.z.number().nullish(),
+  autoCondenseContext: import_zod13.z.boolean().optional(),
+  autoCondenseContextPercent: import_zod13.z.number().optional(),
+  maxConcurrentFileReads: import_zod13.z.number().optional(),
   /**
    * Whether to include diagnostic messages (errors, warnings) in tool outputs
    * @default true
    */
-  includeDiagnosticMessages: import_zod11.z.boolean().optional(),
+  includeDiagnosticMessages: import_zod13.z.boolean().optional(),
   /**
    * Maximum number of diagnostic messages to include in tool outputs
    * @default 50
    */
-  maxDiagnosticMessages: import_zod11.z.number().optional(),
-  browserToolEnabled: import_zod11.z.boolean().optional(),
-  browserViewportSize: import_zod11.z.string().optional(),
-  screenshotQuality: import_zod11.z.number().optional(),
-  remoteBrowserEnabled: import_zod11.z.boolean().optional(),
-  remoteBrowserHost: import_zod11.z.string().optional(),
-  cachedChromeHostUrl: import_zod11.z.string().optional(),
-  enableCheckpoints: import_zod11.z.boolean().optional(),
-  ttsEnabled: import_zod11.z.boolean().optional(),
-  ttsSpeed: import_zod11.z.number().optional(),
-  soundEnabled: import_zod11.z.boolean().optional(),
-  soundVolume: import_zod11.z.number().optional(),
-  maxOpenTabsContext: import_zod11.z.number().optional(),
-  maxWorkspaceFiles: import_zod11.z.number().optional(),
-  showRooIgnoredFiles: import_zod11.z.boolean().optional(),
-  maxReadFileLine: import_zod11.z.number().optional(),
-  maxImageFileSize: import_zod11.z.number().optional(),
-  maxTotalImageSize: import_zod11.z.number().optional(),
-  terminalOutputLineLimit: import_zod11.z.number().optional(),
-  terminalOutputCharacterLimit: import_zod11.z.number().optional(),
-  terminalShellIntegrationTimeout: import_zod11.z.number().optional(),
-  terminalShellIntegrationDisabled: import_zod11.z.boolean().optional(),
-  terminalCommandDelay: import_zod11.z.number().optional(),
-  terminalPowershellCounter: import_zod11.z.boolean().optional(),
-  terminalZshClearEolMark: import_zod11.z.boolean().optional(),
-  terminalZshOhMy: import_zod11.z.boolean().optional(),
-  terminalZshP10k: import_zod11.z.boolean().optional(),
-  terminalZdotdir: import_zod11.z.boolean().optional(),
-  terminalCompressProgressBar: import_zod11.z.boolean().optional(),
-  diagnosticsEnabled: import_zod11.z.boolean().optional(),
-  rateLimitSeconds: import_zod11.z.number().optional(),
-  diffEnabled: import_zod11.z.boolean().optional(),
-  fuzzyMatchThreshold: import_zod11.z.number().optional(),
+  maxDiagnosticMessages: import_zod13.z.number().optional(),
+  browserToolEnabled: import_zod13.z.boolean().optional(),
+  browserViewportSize: import_zod13.z.string().optional(),
+  screenshotQuality: import_zod13.z.number().optional(),
+  remoteBrowserEnabled: import_zod13.z.boolean().optional(),
+  remoteBrowserHost: import_zod13.z.string().optional(),
+  cachedChromeHostUrl: import_zod13.z.string().optional(),
+  enableCheckpoints: import_zod13.z.boolean().optional(),
+  ttsEnabled: import_zod13.z.boolean().optional(),
+  ttsSpeed: import_zod13.z.number().optional(),
+  soundEnabled: import_zod13.z.boolean().optional(),
+  soundVolume: import_zod13.z.number().optional(),
+  maxOpenTabsContext: import_zod13.z.number().optional(),
+  maxWorkspaceFiles: import_zod13.z.number().optional(),
+  showRooIgnoredFiles: import_zod13.z.boolean().optional(),
+  maxReadFileLine: import_zod13.z.number().optional(),
+  maxImageFileSize: import_zod13.z.number().optional(),
+  maxTotalImageSize: import_zod13.z.number().optional(),
+  terminalOutputLineLimit: import_zod13.z.number().optional(),
+  terminalOutputCharacterLimit: import_zod13.z.number().optional(),
+  terminalShellIntegrationTimeout: import_zod13.z.number().optional(),
+  terminalShellIntegrationDisabled: import_zod13.z.boolean().optional(),
+  terminalCommandDelay: import_zod13.z.number().optional(),
+  terminalPowershellCounter: import_zod13.z.boolean().optional(),
+  terminalZshClearEolMark: import_zod13.z.boolean().optional(),
+  terminalZshOhMy: import_zod13.z.boolean().optional(),
+  terminalZshP10k: import_zod13.z.boolean().optional(),
+  terminalZdotdir: import_zod13.z.boolean().optional(),
+  terminalCompressProgressBar: import_zod13.z.boolean().optional(),
+  diagnosticsEnabled: import_zod13.z.boolean().optional(),
+  rateLimitSeconds: import_zod13.z.number().optional(),
+  diffEnabled: import_zod13.z.boolean().optional(),
+  fuzzyMatchThreshold: import_zod13.z.number().optional(),
   experiments: experimentsSchema.optional(),
   codebaseIndexModels: codebaseIndexModelsSchema.optional(),
   codebaseIndexConfig: codebaseIndexConfigSchema.optional(),
   language: languagesSchema.optional(),
   telemetrySetting: telemetrySettingsSchema.optional(),
-  mcpEnabled: import_zod11.z.boolean().optional(),
-  enableMcpServerCreation: import_zod11.z.boolean().optional(),
-  remoteControlEnabled: import_zod11.z.boolean().optional(),
-  mode: import_zod11.z.string().optional(),
-  modeApiConfigs: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.string()).optional(),
-  customModes: import_zod11.z.array(modeConfigSchema).optional(),
+  mcpEnabled: import_zod13.z.boolean().optional(),
+  enableMcpServerCreation: import_zod13.z.boolean().optional(),
+  remoteControlEnabled: import_zod13.z.boolean().optional(),
+  mode: import_zod13.z.string().optional(),
+  modeApiConfigs: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.string()).optional(),
+  customModes: import_zod13.z.array(modeConfigSchema).optional(),
   customModePrompts: customModePromptsSchema.optional(),
   customSupportPrompts: customSupportPromptsSchema.optional(),
-  enhancementApiConfigId: import_zod11.z.string().optional(),
-  includeTaskHistoryInEnhance: import_zod11.z.boolean().optional(),
-  historyPreviewCollapsed: import_zod11.z.boolean().optional(),
-  profileThresholds: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.number()).optional(),
-  hasOpenedModeSelector: import_zod11.z.boolean().optional(),
-  lastModeExportPath: import_zod11.z.string().optional(),
-  lastModeImportPath: import_zod11.z.string().optional()
+  enhancementApiConfigId: import_zod13.z.string().optional(),
+  includeTaskHistoryInEnhance: import_zod13.z.boolean().optional(),
+  historyPreviewCollapsed: import_zod13.z.boolean().optional(),
+  profileThresholds: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.number()).optional(),
+  hasOpenedModeSelector: import_zod13.z.boolean().optional(),
+  lastModeExportPath: import_zod13.z.string().optional(),
+  lastModeImportPath: import_zod13.z.string().optional()
 });
 var GLOBAL_SETTINGS_KEYS = globalSettingsSchema.keyof().options;
 var rooCodeSettingsSchema = providerSettingsSchema.merge(globalSettingsSchema);
@@ -1202,7 +1401,9 @@ var SECRET_STATE_KEYS = [
   "codebaseIndexGeminiApiKey",
   "codebaseIndexMistralApiKey",
   "huggingFaceApiKey",
-  "sambaNovaApiKey"
+  "sambaNovaApiKey",
+  "fireworksApiKey",
+  "ioIntelligenceApiKey"
 ];
 var isSecretStateKey = (key) => SECRET_STATE_KEYS.includes(key);
 var GLOBAL_STATE_KEYS = [...GLOBAL_SETTINGS_KEYS, ...PROVIDER_SETTINGS_KEYS].filter(
@@ -1270,300 +1471,14 @@ var EVALS_SETTINGS = {
   telemetrySetting: "enabled",
   mcpEnabled: false,
   remoteControlEnabled: false,
-  mode: "code",
-  // "architect",
-  customModes: []
-};
-var EVALS_TIMEOUT = 5 * 60 * 1e3;
-
-// src/marketplace.ts
-var import_zod12 = require("zod");
-var mcpParameterSchema = import_zod12.z.object({
-  name: import_zod12.z.string().min(1),
-  key: import_zod12.z.string().min(1),
-  placeholder: import_zod12.z.string().optional(),
-  optional: import_zod12.z.boolean().optional().default(false)
-});
-var mcpInstallationMethodSchema = import_zod12.z.object({
-  name: import_zod12.z.string().min(1),
-  content: import_zod12.z.string().min(1),
-  parameters: import_zod12.z.array(mcpParameterSchema).optional(),
-  prerequisites: import_zod12.z.array(import_zod12.z.string()).optional()
-});
-var marketplaceItemTypeSchema = import_zod12.z.enum(["mode", "mcp"]);
-var baseMarketplaceItemSchema = import_zod12.z.object({
-  id: import_zod12.z.string().min(1),
-  name: import_zod12.z.string().min(1, "Name is required"),
-  description: import_zod12.z.string(),
-  author: import_zod12.z.string().optional(),
-  authorUrl: import_zod12.z.string().url("Author URL must be a valid URL").optional(),
-  tags: import_zod12.z.array(import_zod12.z.string()).optional(),
-  prerequisites: import_zod12.z.array(import_zod12.z.string()).optional()
-});
-var modeMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
-  content: import_zod12.z.string().min(1)
-  // YAML content for modes
-});
-var mcpMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
-  url: import_zod12.z.string().url(),
-  // Required url field
-  content: import_zod12.z.union([import_zod12.z.string().min(1), import_zod12.z.array(mcpInstallationMethodSchema)]),
-  // Single config or array of methods
-  parameters: import_zod12.z.array(mcpParameterSchema).optional()
-});
-var marketplaceItemSchema = import_zod12.z.discriminatedUnion("type", [
-  // Mode marketplace item
-  modeMarketplaceItemSchema.extend({
-    type: import_zod12.z.literal("mode")
-  }),
-  // MCP marketplace item
-  mcpMarketplaceItemSchema.extend({
-    type: import_zod12.z.literal("mcp")
-  })
-]);
-var installMarketplaceItemOptionsSchema = import_zod12.z.object({
-  target: import_zod12.z.enum(["global", "project"]).optional().default("project"),
-  parameters: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()).optional()
-});
-
-// src/cloud.ts
-var organizationAllowListSchema = import_zod13.z.object({
-  allowAll: import_zod13.z.boolean(),
-  providers: import_zod13.z.record(
-    import_zod13.z.object({
-      allowAll: import_zod13.z.boolean(),
-      models: import_zod13.z.array(import_zod13.z.string()).optional()
-    })
-  )
-});
-var organizationDefaultSettingsSchema = globalSettingsSchema.pick({
-  enableCheckpoints: true,
-  fuzzyMatchThreshold: true,
-  maxOpenTabsContext: true,
-  maxReadFileLine: true,
-  maxWorkspaceFiles: true,
-  showRooIgnoredFiles: true,
-  terminalCommandDelay: true,
-  terminalCompressProgressBar: true,
-  terminalOutputLineLimit: true,
-  terminalShellIntegrationDisabled: true,
-  terminalShellIntegrationTimeout: true,
-  terminalZshClearEolMark: true
-}).merge(
-  import_zod13.z.object({
-    maxOpenTabsContext: import_zod13.z.number().int().nonnegative().optional(),
-    maxReadFileLine: import_zod13.z.number().int().gte(-1).optional(),
-    maxWorkspaceFiles: import_zod13.z.number().int().nonnegative().optional(),
-    terminalCommandDelay: import_zod13.z.number().int().nonnegative().optional(),
-    terminalOutputLineLimit: import_zod13.z.number().int().nonnegative().optional(),
-    terminalShellIntegrationTimeout: import_zod13.z.number().int().nonnegative().optional()
-  })
-);
-var organizationCloudSettingsSchema = import_zod13.z.object({
-  recordTaskMessages: import_zod13.z.boolean().optional(),
-  enableTaskSharing: import_zod13.z.boolean().optional(),
-  taskShareExpirationDays: import_zod13.z.number().int().positive().optional(),
-  allowMembersViewAllTasks: import_zod13.z.boolean().optional()
-});
-var organizationSettingsSchema = import_zod13.z.object({
-  version: import_zod13.z.number(),
-  cloudSettings: organizationCloudSettingsSchema.optional(),
-  defaultSettings: organizationDefaultSettingsSchema,
-  allowList: organizationAllowListSchema,
-  hiddenMcps: import_zod13.z.array(import_zod13.z.string()).optional(),
-  hideMarketplaceMcps: import_zod13.z.boolean().optional(),
-  mcps: import_zod13.z.array(mcpMarketplaceItemSchema).optional(),
-  providerProfiles: import_zod13.z.record(import_zod13.z.string(), discriminatedProviderSettingsWithIdSchema).optional()
-});
-var ORGANIZATION_ALLOW_ALL = {
-  allowAll: true,
-  providers: {}
-};
-var ORGANIZATION_DEFAULT = {
-  version: 0,
-  cloudSettings: {
-    recordTaskMessages: true,
-    enableTaskSharing: true,
-    taskShareExpirationDays: 30,
-    allowMembersViewAllTasks: true
-  },
-  defaultSettings: {},
-  allowList: ORGANIZATION_ALLOW_ALL
-};
-var shareResponseSchema = import_zod13.z.object({
-  success: import_zod13.z.boolean(),
-  shareUrl: import_zod13.z.string().optional(),
-  error: import_zod13.z.string().optional(),
-  isNewShare: import_zod13.z.boolean().optional(),
-  manageUrl: import_zod13.z.string().optional()
-});
-
-// src/events.ts
-var import_zod14 = require("zod");
-var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
-  RooCodeEventName2["TaskCreated"] = "taskCreated";
-  RooCodeEventName2["TaskStarted"] = "taskStarted";
-  RooCodeEventName2["TaskCompleted"] = "taskCompleted";
-  RooCodeEventName2["TaskAborted"] = "taskAborted";
-  RooCodeEventName2["TaskFocused"] = "taskFocused";
-  RooCodeEventName2["TaskUnfocused"] = "taskUnfocused";
-  RooCodeEventName2["TaskActive"] = "taskActive";
-  RooCodeEventName2["TaskIdle"] = "taskIdle";
-  RooCodeEventName2["TaskPaused"] = "taskPaused";
-  RooCodeEventName2["TaskUnpaused"] = "taskUnpaused";
-  RooCodeEventName2["TaskSpawned"] = "taskSpawned";
-  RooCodeEventName2["Message"] = "message";
-  RooCodeEventName2["TaskModeSwitched"] = "taskModeSwitched";
-  RooCodeEventName2["TaskAskResponded"] = "taskAskResponded";
-  RooCodeEventName2["TaskTokenUsageUpdated"] = "taskTokenUsageUpdated";
-  RooCodeEventName2["TaskToolFailed"] = "taskToolFailed";
-  RooCodeEventName2["EvalPass"] = "evalPass";
-  RooCodeEventName2["EvalFail"] = "evalFail";
-  return RooCodeEventName2;
-})(RooCodeEventName || {});
-var rooCodeEventsSchema = import_zod14.z.object({
-  ["taskCreated" /* TaskCreated */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskStarted" /* TaskStarted */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskCompleted" /* TaskCompleted */]: import_zod14.z.tuple([
-    import_zod14.z.string(),
-    tokenUsageSchema,
-    toolUsageSchema,
-    import_zod14.z.object({
-      isSubtask: import_zod14.z.boolean()
-    })
-  ]),
-  ["taskAborted" /* TaskAborted */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskFocused" /* TaskFocused */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskUnfocused" /* TaskUnfocused */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskActive" /* TaskActive */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskIdle" /* TaskIdle */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskPaused" /* TaskPaused */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskUnpaused" /* TaskUnpaused */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskSpawned" /* TaskSpawned */]: import_zod14.z.tuple([import_zod14.z.string(), import_zod14.z.string()]),
-  ["message" /* Message */]: import_zod14.z.tuple([
-    import_zod14.z.object({
-      taskId: import_zod14.z.string(),
-      action: import_zod14.z.union([import_zod14.z.literal("created"), import_zod14.z.literal("updated")]),
-      message: clineMessageSchema
-    })
-  ]),
-  ["taskModeSwitched" /* TaskModeSwitched */]: import_zod14.z.tuple([import_zod14.z.string(), import_zod14.z.string()]),
-  ["taskAskResponded" /* TaskAskResponded */]: import_zod14.z.tuple([import_zod14.z.string()]),
-  ["taskToolFailed" /* TaskToolFailed */]: import_zod14.z.tuple([import_zod14.z.string(), toolNamesSchema, import_zod14.z.string()]),
-  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: import_zod14.z.tuple([import_zod14.z.string(), tokenUsageSchema])
-});
-var taskEventSchema = import_zod14.z.discriminatedUnion("eventName", [
-  // Task Provider Lifecycle
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskCreated" /* TaskCreated */),
-    payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  // Task Lifecycle
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskStarted" /* TaskStarted */),
-    payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskCompleted" /* TaskCompleted */),
-    payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskAborted" /* TaskAborted */),
-    payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskFocused" /* TaskFocused */),
-    payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskUnfocused" /* TaskUnfocused */),
-    payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskActive" /* TaskActive */),
-    payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskIdle" /* TaskIdle */),
-    payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  // Subtask Lifecycle
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskPaused" /* TaskPaused */),
-    payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskUnpaused" /* TaskUnpaused */),
-    payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskSpawned" /* TaskSpawned */),
-    payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  // Task Execution
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("message" /* Message */),
-    payload: rooCodeEventsSchema.shape["message" /* Message */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskModeSwitched" /* TaskModeSwitched */),
-    payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskAskResponded" /* TaskAskResponded */),
-    payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  // Task Analytics
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskToolFailed" /* TaskToolFailed */),
-    payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
-    payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
-    taskId: import_zod14.z.number().optional()
-  }),
-  // Evals
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("evalPass" /* EvalPass */),
-    payload: import_zod14.z.undefined(),
-    taskId: import_zod14.z.number()
-  }),
-  import_zod14.z.object({
-    eventName: import_zod14.z.literal("evalFail" /* EvalFail */),
-    payload: import_zod14.z.undefined(),
-    taskId: import_zod14.z.number()
-  })
-]);
-
-// src/followup.ts
-var import_zod15 = require("zod");
-var suggestionItemSchema = import_zod15.z.object({
-  answer: import_zod15.z.string(),
-  mode: import_zod15.z.string().optional()
-});
-var followUpDataSchema = import_zod15.z.object({
-  question: import_zod15.z.string().optional(),
-  suggest: import_zod15.z.array(suggestionItemSchema).optional()
-});
+  mode: "code",
+  // "architect",
+  customModes: []
+};
+var EVALS_TIMEOUT = 5 * 60 * 1e3;
 
 // src/ipc.ts
-var import_zod16 = require("zod");
+var import_zod14 = require("zod");
 var IpcMessageType = /* @__PURE__ */ ((IpcMessageType2) => {
   IpcMessageType2["Connect"] = "Connect";
   IpcMessageType2["Disconnect"] = "Disconnect";
@@ -1577,10 +1492,10 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
   IpcOrigin2["Server"] = "server";
   return IpcOrigin2;
 })(IpcOrigin || {});
-var ackSchema = import_zod16.z.object({
-  clientId: import_zod16.z.string(),
-  pid: import_zod16.z.number(),
-  ppid: import_zod16.z.number()
+var ackSchema = import_zod14.z.object({
+  clientId: import_zod14.z.string(),
+  pid: import_zod14.z.number(),
+  ppid: import_zod14.z.number()
 });
 var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -1588,106 +1503,156 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["CloseTask"] = "CloseTask";
   return TaskCommandName2;
 })(TaskCommandName || {});
-var taskCommandSchema = import_zod16.z.discriminatedUnion("commandName", [
-  import_zod16.z.object({
-    commandName: import_zod16.z.literal("StartNewTask" /* StartNewTask */),
-    data: import_zod16.z.object({
+var taskCommandSchema = import_zod14.z.discriminatedUnion("commandName", [
+  import_zod14.z.object({
+    commandName: import_zod14.z.literal("StartNewTask" /* StartNewTask */),
+    data: import_zod14.z.object({
       configuration: rooCodeSettingsSchema,
-      text: import_zod16.z.string(),
-      images: import_zod16.z.array(import_zod16.z.string()).optional(),
-      newTab: import_zod16.z.boolean().optional()
+      text: import_zod14.z.string(),
+      images: import_zod14.z.array(import_zod14.z.string()).optional(),
+      newTab: import_zod14.z.boolean().optional()
     })
   }),
-  import_zod16.z.object({
-    commandName: import_zod16.z.literal("CancelTask" /* CancelTask */),
-    data: import_zod16.z.string()
+  import_zod14.z.object({
+    commandName: import_zod14.z.literal("CancelTask" /* CancelTask */),
+    data: import_zod14.z.string()
   }),
-  import_zod16.z.object({
-    commandName: import_zod16.z.literal("CloseTask" /* CloseTask */),
-    data: import_zod16.z.string()
+  import_zod14.z.object({
+    commandName: import_zod14.z.literal("CloseTask" /* CloseTask */),
+    data: import_zod14.z.string()
   })
 ]);
-var ipcMessageSchema = import_zod16.z.discriminatedUnion("type", [
-  import_zod16.z.object({
-    type: import_zod16.z.literal("Ack" /* Ack */),
-    origin: import_zod16.z.literal("server" /* Server */),
+var ipcMessageSchema = import_zod14.z.discriminatedUnion("type", [
+  import_zod14.z.object({
+    type: import_zod14.z.literal("Ack" /* Ack */),
+    origin: import_zod14.z.literal("server" /* Server */),
     data: ackSchema
   }),
-  import_zod16.z.object({
-    type: import_zod16.z.literal("TaskCommand" /* TaskCommand */),
-    origin: import_zod16.z.literal("client" /* Client */),
-    clientId: import_zod16.z.string(),
+  import_zod14.z.object({
+    type: import_zod14.z.literal("TaskCommand" /* TaskCommand */),
+    origin: import_zod14.z.literal("client" /* Client */),
+    clientId: import_zod14.z.string(),
     data: taskCommandSchema
   }),
-  import_zod16.z.object({
-    type: import_zod16.z.literal("TaskEvent" /* TaskEvent */),
-    origin: import_zod16.z.literal("server" /* Server */),
-    relayClientId: import_zod16.z.string().optional(),
+  import_zod14.z.object({
+    type: import_zod14.z.literal("TaskEvent" /* TaskEvent */),
+    origin: import_zod14.z.literal("server" /* Server */),
+    relayClientId: import_zod14.z.string().optional(),
     data: taskEventSchema
   })
 ]);
 
+// src/marketplace.ts
+var import_zod15 = require("zod");
+var mcpParameterSchema = import_zod15.z.object({
+  name: import_zod15.z.string().min(1),
+  key: import_zod15.z.string().min(1),
+  placeholder: import_zod15.z.string().optional(),
+  optional: import_zod15.z.boolean().optional().default(false)
+});
+var mcpInstallationMethodSchema = import_zod15.z.object({
+  name: import_zod15.z.string().min(1),
+  content: import_zod15.z.string().min(1),
+  parameters: import_zod15.z.array(mcpParameterSchema).optional(),
+  prerequisites: import_zod15.z.array(import_zod15.z.string()).optional()
+});
+var marketplaceItemTypeSchema = import_zod15.z.enum(["mode", "mcp"]);
+var baseMarketplaceItemSchema = import_zod15.z.object({
+  id: import_zod15.z.string().min(1),
+  name: import_zod15.z.string().min(1, "Name is required"),
+  description: import_zod15.z.string(),
+  author: import_zod15.z.string().optional(),
+  authorUrl: import_zod15.z.string().url("Author URL must be a valid URL").optional(),
+  tags: import_zod15.z.array(import_zod15.z.string()).optional(),
+  prerequisites: import_zod15.z.array(import_zod15.z.string()).optional()
+});
+var modeMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  content: import_zod15.z.string().min(1)
+  // YAML content for modes
+});
+var mcpMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  url: import_zod15.z.string().url(),
+  // Required url field
+  content: import_zod15.z.union([import_zod15.z.string().min(1), import_zod15.z.array(mcpInstallationMethodSchema)]),
+  // Single config or array of methods
+  parameters: import_zod15.z.array(mcpParameterSchema).optional()
+});
+var marketplaceItemSchema = import_zod15.z.discriminatedUnion("type", [
+  // Mode marketplace item
+  modeMarketplaceItemSchema.extend({
+    type: import_zod15.z.literal("mode")
+  }),
+  // MCP marketplace item
+  mcpMarketplaceItemSchema.extend({
+    type: import_zod15.z.literal("mcp")
+  })
+]);
+var installMarketplaceItemOptionsSchema = import_zod15.z.object({
+  target: import_zod15.z.enum(["global", "project"]).optional().default("project"),
+  parameters: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).optional()
+});
+
 // src/mcp.ts
-var import_zod17 = require("zod");
-var mcpExecutionStatusSchema = import_zod17.z.discriminatedUnion("status", [
-  import_zod17.z.object({
-    executionId: import_zod17.z.string(),
-    status: import_zod17.z.literal("started"),
-    serverName: import_zod17.z.string(),
-    toolName: import_zod17.z.string()
+var import_zod16 = require("zod");
+var mcpExecutionStatusSchema = import_zod16.z.discriminatedUnion("status", [
+  import_zod16.z.object({
+    executionId: import_zod16.z.string(),
+    status: import_zod16.z.literal("started"),
+    serverName: import_zod16.z.string(),
+    toolName: import_zod16.z.string()
   }),
-  import_zod17.z.object({
-    executionId: import_zod17.z.string(),
-    status: import_zod17.z.literal("output"),
-    response: import_zod17.z.string()
+  import_zod16.z.object({
+    executionId: import_zod16.z.string(),
+    status: import_zod16.z.literal("output"),
+    response: import_zod16.z.string()
   }),
-  import_zod17.z.object({
-    executionId: import_zod17.z.string(),
-    status: import_zod17.z.literal("completed"),
-    response: import_zod17.z.string().optional()
+  import_zod16.z.object({
+    executionId: import_zod16.z.string(),
+    status: import_zod16.z.literal("completed"),
+    response: import_zod16.z.string().optional()
   }),
-  import_zod17.z.object({
-    executionId: import_zod17.z.string(),
-    status: import_zod17.z.literal("error"),
-    error: import_zod17.z.string().optional()
+  import_zod16.z.object({
+    executionId: import_zod16.z.string(),
+    status: import_zod16.z.literal("error"),
+    error: import_zod16.z.string().optional()
   })
 ]);
 
 // src/todo.ts
-var import_zod18 = require("zod");
-var todoStatusSchema = import_zod18.z.enum(["pending", "in_progress", "completed"]);
-var todoItemSchema = import_zod18.z.object({
-  id: import_zod18.z.string(),
-  content: import_zod18.z.string(),
+var import_zod17 = require("zod");
+var todoStatusSchema = import_zod17.z.enum(["pending", "in_progress", "completed"]);
+var todoItemSchema = import_zod17.z.object({
+  id: import_zod17.z.string(),
+  content: import_zod17.z.string(),
   status: todoStatusSchema
 });
 
 // src/terminal.ts
-var import_zod19 = require("zod");
-var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("started"),
-    pid: import_zod19.z.number().optional(),
-    command: import_zod19.z.string()
+var import_zod18 = require("zod");
+var commandExecutionStatusSchema = import_zod18.z.discriminatedUnion("status", [
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("started"),
+    pid: import_zod18.z.number().optional(),
+    command: import_zod18.z.string()
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("output"),
-    output: import_zod19.z.string()
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("output"),
+    output: import_zod18.z.string()
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("exited"),
-    exitCode: import_zod19.z.number().optional()
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("exited"),
+    exitCode: import_zod18.z.number().optional()
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("fallback")
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("fallback")
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("timeout")
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("timeout")
   })
 ]);
 
@@ -1698,17 +1663,49 @@ var anthropicModels = {
     maxTokens: 64e3,
     // Overridden to 8k if `enableReasoningEffort` is false.
     contextWindow: 2e5,
+    // Default 200K, extendable to 1M with beta flag 'context-1m-2025-08-07'
     supportsImages: true,
     supportsComputerUse: true,
     supportsPromptCache: true,
     inputPrice: 3,
-    // $3 per million input tokens
+    // $3 per million input tokens (≤200K context)
     outputPrice: 15,
-    // $15 per million output tokens
+    // $15 per million output tokens (≤200K context)
     cacheWritesPrice: 3.75,
     // $3.75 per million tokens
     cacheReadsPrice: 0.3,
     // $0.30 per million tokens
+    supportsReasoningBudget: true,
+    // Tiered pricing for extended context (requires beta flag 'context-1m-2025-08-07')
+    tiers: [
+      {
+        contextWindow: 1e6,
+        // 1M tokens with beta flag
+        inputPrice: 6,
+        // $6 per million input tokens (>200K context)
+        outputPrice: 22.5,
+        // $22.50 per million output tokens (>200K context)
+        cacheWritesPrice: 7.5,
+        // $7.50 per million tokens (>200K context)
+        cacheReadsPrice: 0.6
+        // $0.60 per million tokens (>200K context)
+      }
+    ]
+  },
+  "claude-opus-4-1-20250805": {
+    maxTokens: 8192,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsComputerUse: true,
+    supportsPromptCache: true,
+    inputPrice: 15,
+    // $15 per million input tokens
+    outputPrice: 75,
+    // $75 per million output tokens
+    cacheWritesPrice: 18.75,
+    // $18.75 per million tokens
+    cacheReadsPrice: 1.5,
+    // $1.50 per million tokens
     supportsReasoningBudget: true
   },
   "claude-opus-4-20250514": {
@@ -1891,6 +1888,21 @@ var bedrockModels = {
     maxCachePoints: 4,
     cachableFields: ["system", "messages", "tools"]
   },
+  "anthropic.claude-opus-4-1-20250805-v1:0": {
+    maxTokens: 8192,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsComputerUse: true,
+    supportsPromptCache: true,
+    supportsReasoningBudget: true,
+    inputPrice: 15,
+    outputPrice: 75,
+    cacheWritesPrice: 18.75,
+    cacheReadsPrice: 1.5,
+    minTokensPerCachePoint: 1024,
+    maxCachePoints: 4,
+    cachableFields: ["system", "messages", "tools"]
+  },
   "anthropic.claude-opus-4-20250514-v1:0": {
     maxTokens: 8192,
     contextWindow: 2e5,
@@ -2015,6 +2027,26 @@ var bedrockModels = {
     inputPrice: 1.35,
     outputPrice: 5.4
   },
+  "openai.gpt-oss-20b-1:0": {
+    maxTokens: 8192,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsComputerUse: false,
+    supportsPromptCache: false,
+    inputPrice: 0.5,
+    outputPrice: 1.5,
+    description: "GPT-OSS 20B - Optimized for low latency and local/specialized use cases"
+  },
+  "openai.gpt-oss-120b-1:0": {
+    maxTokens: 8192,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsComputerUse: false,
+    supportsPromptCache: false,
+    inputPrice: 2,
+    outputPrice: 6,
+    description: "GPT-OSS 120B - Production-ready, general-purpose, high-reasoning model"
+  },
   "meta.llama3-3-70b-instruct-v1:0": {
     maxTokens: 8192,
     contextWindow: 128e3,
@@ -2263,6 +2295,15 @@ var cerebrasModels = {
     outputPrice: 0,
     description: "SOTA performance with ~1500 tokens/s",
     supportsReasoningEffort: true
+  },
+  "gpt-oss-120b": {
+    maxTokens: 8e3,
+    contextWindow: 64e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0,
+    outputPrice: 0,
+    description: "OpenAI GPT OSS model with ~2800 tokens/s\n\n\u2022 64K context window\n\u2022 Excels at efficient reasoning across science, math, and coding"
   }
 };
 
@@ -2495,6 +2536,24 @@ var chutesModels = {
     inputPrice: 0,
     outputPrice: 0,
     description: "GLM-4.5-FP8 model with 128k token context window, optimized for agent-based applications with MoE architecture."
+  },
+  "Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8": {
+    maxTokens: 32768,
+    contextWindow: 262144,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0,
+    outputPrice: 0,
+    description: "Qwen3 Coder 480B A35B Instruct FP8 model, optimized for coding tasks."
+  },
+  "moonshotai/Kimi-K2-Instruct-75k": {
+    maxTokens: 32768,
+    contextWindow: 75e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.1481,
+    outputPrice: 0.5926,
+    description: "Moonshot AI Kimi K2 Instruct model with 75k context window."
   }
 };
 
@@ -2518,6 +2577,15 @@ var claudeCodeModels = {
     supportsReasoningBudget: false,
     requiredReasoningBudget: false
   },
+  "claude-opus-4-1-20250805": {
+    ...anthropicModels["claude-opus-4-1-20250805"],
+    supportsImages: false,
+    supportsPromptCache: true,
+    // Claude Code does report cache tokens
+    supportsReasoningEffort: false,
+    supportsReasoningBudget: false,
+    requiredReasoningBudget: false
+  },
   "claude-opus-4-20250514": {
     ...anthropicModels["claude-opus-4-20250514"],
     supportsImages: false,
@@ -2991,6 +3059,24 @@ var groqModels = {
     inputPrice: 1,
     outputPrice: 3,
     description: "Moonshot AI Kimi K2 Instruct 1T model, 128K context."
+  },
+  "openai/gpt-oss-120b": {
+    maxTokens: 32766,
+    contextWindow: 131072,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.15,
+    outputPrice: 0.75,
+    description: "GPT-OSS 120B is OpenAI's flagship open source model, built on a Mixture-of-Experts (MoE) architecture with 20 billion parameters and 128 experts."
+  },
+  "openai/gpt-oss-20b": {
+    maxTokens: 32768,
+    contextWindow: 131072,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.1,
+    outputPrice: 0.5,
+    description: "GPT-OSS 20B is OpenAI's flagship open source model, built on a Mixture-of-Experts (MoE) architecture with 20 billion parameters and 32 experts."
   }
 };
 
@@ -3004,6 +3090,41 @@ var HUGGINGFACE_TEMPERATURE_MAX_VALUE = 2;
 var HUGGINGFACE_API_URL = "https://router.huggingface.co/v1/models?collection=roocode";
 var HUGGINGFACE_CACHE_DURATION = 1e3 * 60 * 60;
 
+// src/providers/io-intelligence.ts
+var ioIntelligenceDefaultModelId = "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8";
+var ioIntelligenceDefaultBaseUrl = "https://api.intelligence.io.solutions/api/v1";
+var IO_INTELLIGENCE_CACHE_DURATION = 1e3 * 60 * 60;
+var ioIntelligenceModels = {
+  "deepseek-ai/DeepSeek-R1-0528": {
+    maxTokens: 8192,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    description: "DeepSeek R1 reasoning model"
+  },
+  "meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8": {
+    maxTokens: 8192,
+    contextWindow: 43e4,
+    supportsImages: true,
+    supportsPromptCache: false,
+    description: "Llama 4 Maverick 17B model"
+  },
+  "Intel/Qwen3-Coder-480B-A35B-Instruct-int4-mixed-ar": {
+    maxTokens: 8192,
+    contextWindow: 106e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    description: "Qwen3 Coder 480B specialized for coding"
+  },
+  "openai/gpt-oss-120b": {
+    maxTokens: 8192,
+    contextWindow: 131072,
+    supportsImages: false,
+    supportsPromptCache: false,
+    description: "OpenAI GPT-OSS 120B model"
+  }
+};
+
 // src/providers/lite-llm.ts
 var litellmDefaultModelId = "claude-3-7-sonnet-20250219";
 var litellmDefaultModelInfo = {
@@ -3019,6 +3140,7 @@ var litellmDefaultModelInfo = {
 };
 var LITELLM_COMPUTER_USE_MODELS = /* @__PURE__ */ new Set([
   "claude-3-5-sonnet-latest",
+  "claude-opus-4-1-20250805",
   "claude-opus-4-20250514",
   "claude-sonnet-4-20250514",
   "claude-3-7-sonnet-latest",
@@ -3028,22 +3150,26 @@ var LITELLM_COMPUTER_USE_MODELS = /* @__PURE__ */ new Set([
   "vertex_ai/claude-3-5-sonnet-v2",
   "vertex_ai/claude-3-5-sonnet-v2@20241022",
   "vertex_ai/claude-3-7-sonnet@20250219",
+  "vertex_ai/claude-opus-4-1@20250805",
   "vertex_ai/claude-opus-4@20250514",
   "vertex_ai/claude-sonnet-4@20250514",
   "openrouter/anthropic/claude-3.5-sonnet",
   "openrouter/anthropic/claude-3.5-sonnet:beta",
   "openrouter/anthropic/claude-3.7-sonnet",
   "openrouter/anthropic/claude-3.7-sonnet:beta",
+  "anthropic.claude-opus-4-1-20250805-v1:0",
   "anthropic.claude-opus-4-20250514-v1:0",
   "anthropic.claude-sonnet-4-20250514-v1:0",
   "anthropic.claude-3-7-sonnet-20250219-v1:0",
   "anthropic.claude-3-5-sonnet-20241022-v2:0",
   "us.anthropic.claude-3-5-sonnet-20241022-v2:0",
   "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
+  "us.anthropic.claude-opus-4-1-20250805-v1:0",
   "us.anthropic.claude-opus-4-20250514-v1:0",
   "us.anthropic.claude-sonnet-4-20250514-v1:0",
   "eu.anthropic.claude-3-5-sonnet-20241022-v2:0",
   "eu.anthropic.claude-3-7-sonnet-20250219-v1:0",
+  "eu.anthropic.claude-opus-4-1-20250805-v1:0",
   "eu.anthropic.claude-opus-4-20250514-v1:0",
   "eu.anthropic.claude-sonnet-4-20250514-v1:0",
   "snowflake/claude-3-5-sonnet"
@@ -3180,8 +3306,48 @@ var ollamaDefaultModelInfo = {
 };
 
 // src/providers/openai.ts
-var openAiNativeDefaultModelId = "gpt-4.1";
+var openAiNativeDefaultModelId = "gpt-5-2025-08-07";
 var openAiNativeModels = {
+  "gpt-5-2025-08-07": {
+    maxTokens: 128e3,
+    contextWindow: 4e5,
+    supportsImages: true,
+    supportsPromptCache: true,
+    supportsReasoningEffort: true,
+    reasoningEffort: "medium",
+    inputPrice: 1.25,
+    outputPrice: 10,
+    cacheReadsPrice: 0.13,
+    description: "GPT-5: The best model for coding and agentic tasks across domains",
+    // supportsVerbosity is a new capability; ensure ModelInfo includes it
+    supportsVerbosity: true
+  },
+  "gpt-5-mini-2025-08-07": {
+    maxTokens: 128e3,
+    contextWindow: 4e5,
+    supportsImages: true,
+    supportsPromptCache: true,
+    supportsReasoningEffort: true,
+    reasoningEffort: "medium",
+    inputPrice: 0.25,
+    outputPrice: 2,
+    cacheReadsPrice: 0.03,
+    description: "GPT-5 Mini: A faster, more cost-efficient version of GPT-5 for well-defined tasks",
+    supportsVerbosity: true
+  },
+  "gpt-5-nano-2025-08-07": {
+    maxTokens: 128e3,
+    contextWindow: 4e5,
+    supportsImages: true,
+    supportsPromptCache: true,
+    supportsReasoningEffort: true,
+    reasoningEffort: "medium",
+    inputPrice: 0.05,
+    outputPrice: 0.4,
+    cacheReadsPrice: 0.01,
+    description: "GPT-5 Nano: Fastest, most cost-efficient version of GPT-5",
+    supportsVerbosity: true
+  },
   "gpt-4.1": {
     maxTokens: 32768,
     contextWindow: 1047576,
@@ -3329,15 +3495,6 @@ var openAiNativeModels = {
     outputPrice: 4.4,
     cacheReadsPrice: 0.55
   },
-  "gpt-4.5-preview": {
-    maxTokens: 16384,
-    contextWindow: 128e3,
-    supportsImages: true,
-    supportsPromptCache: true,
-    inputPrice: 75,
-    outputPrice: 150,
-    cacheReadsPrice: 37.5
-  },
   "gpt-4o": {
     maxTokens: 16384,
     contextWindow: 128e3,
@@ -3355,6 +3512,16 @@ var openAiNativeModels = {
     inputPrice: 0.15,
     outputPrice: 0.6,
     cacheReadsPrice: 0.075
+  },
+  "codex-mini-latest": {
+    maxTokens: 16384,
+    contextWindow: 2e5,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 1.5,
+    outputPrice: 6,
+    cacheReadsPrice: 0,
+    description: "Codex Mini: Cloud-based software engineering agent powered by codex-1, a version of o3 optimized for coding tasks. Trained with reinforcement learning to generate human-style code, adhere to instructions, and iteratively run tests."
   }
 };
 var openAiModelInfoSaneDefaults = {
@@ -3367,6 +3534,7 @@ var openAiModelInfoSaneDefaults = {
 };
 var azureOpenAiDefaultApiVersion = "2024-08-01-preview";
 var OPENAI_NATIVE_DEFAULT_TEMPERATURE = 0;
+var GPT5_DEFAULT_TEMPERATURE = 1;
 var OPENAI_AZURE_AI_INFERENCE_PATH = "/models/chat/completions";
 
 // src/providers/openrouter.ts
@@ -3404,6 +3572,7 @@ var OPEN_ROUTER_PROMPT_CACHING_MODELS = /* @__PURE__ */ new Set([
   "anthropic/claude-3.7-sonnet:thinking",
   "anthropic/claude-sonnet-4",
   "anthropic/claude-opus-4",
+  "anthropic/claude-opus-4.1",
   "google/gemini-2.5-flash-preview",
   "google/gemini-2.5-flash-preview:thinking",
   "google/gemini-2.5-flash-preview-05-20",
@@ -3421,7 +3590,8 @@ var OPEN_ROUTER_COMPUTER_USE_MODELS = /* @__PURE__ */ new Set([
   "anthropic/claude-3.7-sonnet:beta",
   "anthropic/claude-3.7-sonnet:thinking",
   "anthropic/claude-sonnet-4",
-  "anthropic/claude-opus-4"
+  "anthropic/claude-opus-4",
+  "anthropic/claude-opus-4.1"
 ]);
 var OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS = /* @__PURE__ */ new Set([
   "anthropic/claude-3.7-sonnet:thinking",
@@ -3431,6 +3601,7 @@ var OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS = /* @__PURE__ */ new Set([
 var OPEN_ROUTER_REASONING_BUDGET_MODELS = /* @__PURE__ */ new Set([
   "anthropic/claude-3.7-sonnet:beta",
   "anthropic/claude-opus-4",
+  "anthropic/claude-opus-4.1",
   "anthropic/claude-sonnet-4",
   "google/gemini-2.5-pro-preview",
   "google/gemini-2.5-pro",
@@ -3721,6 +3892,18 @@ var vertexModels = {
     cacheReadsPrice: 0.3,
     supportsReasoningBudget: true
   },
+  "claude-opus-4-1@20250805": {
+    maxTokens: 8192,
+    contextWindow: 2e5,
+    supportsImages: true,
+    supportsComputerUse: true,
+    supportsPromptCache: true,
+    inputPrice: 15,
+    outputPrice: 75,
+    cacheWritesPrice: 18.75,
+    cacheReadsPrice: 1.5,
+    supportsReasoningBudget: true
+  },
   "claude-opus-4@20250514": {
     maxTokens: 8192,
     contextWindow: 2e5,
@@ -4238,11 +4421,98 @@ var mainlandZAiModels = {
   }
 };
 var ZAI_DEFAULT_TEMPERATURE = 0;
+
+// src/providers/fireworks.ts
+var fireworksDefaultModelId = "accounts/fireworks/models/kimi-k2-instruct";
+var fireworksModels = {
+  "accounts/fireworks/models/kimi-k2-instruct": {
+    maxTokens: 16384,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.6,
+    outputPrice: 2.5,
+    description: "Kimi K2 is a state-of-the-art mixture-of-experts (MoE) language model with 32 billion activated parameters and 1 trillion total parameters. Trained with the Muon optimizer, Kimi K2 achieves exceptional performance across frontier knowledge, reasoning, and coding tasks while being meticulously optimized for agentic capabilities."
+  },
+  "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507": {
+    maxTokens: 32768,
+    contextWindow: 256e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.22,
+    outputPrice: 0.88,
+    description: "Latest Qwen3 thinking model, competitive against the best closed source models in Jul 2025."
+  },
+  "accounts/fireworks/models/qwen3-coder-480b-a35b-instruct": {
+    maxTokens: 32768,
+    contextWindow: 256e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.45,
+    outputPrice: 1.8,
+    description: "Qwen3's most agentic code model to date."
+  },
+  "accounts/fireworks/models/deepseek-r1-0528": {
+    maxTokens: 20480,
+    contextWindow: 16e4,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 3,
+    outputPrice: 8,
+    description: "05/28 updated checkpoint of Deepseek R1. Its overall performance is now approaching that of leading models, such as O3 and Gemini 2.5 Pro. Compared to the previous version, the upgraded model shows significant improvements in handling complex reasoning tasks, and this version also offers a reduced hallucination rate, enhanced support for function calling, and better experience for vibe coding. Note that fine-tuning for this model is only available through contacting fireworks at https://fireworks.ai/company/contact-us."
+  },
+  "accounts/fireworks/models/deepseek-v3": {
+    maxTokens: 16384,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.9,
+    outputPrice: 0.9,
+    description: "A strong Mixture-of-Experts (MoE) language model with 671B total parameters with 37B activated for each token from Deepseek. Note that fine-tuning for this model is only available through contacting fireworks at https://fireworks.ai/company/contact-us."
+  },
+  "accounts/fireworks/models/glm-4p5": {
+    maxTokens: 16384,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.55,
+    outputPrice: 2.19,
+    description: "Z.ai GLM-4.5 with 355B total parameters and 32B active parameters. Features unified reasoning, coding, and intelligent agent capabilities."
+  },
+  "accounts/fireworks/models/glm-4p5-air": {
+    maxTokens: 16384,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.55,
+    outputPrice: 2.19,
+    description: "Z.ai GLM-4.5-Air with 106B total parameters and 12B active parameters. Features unified reasoning, coding, and intelligent agent capabilities."
+  },
+  "accounts/fireworks/models/gpt-oss-20b": {
+    maxTokens: 16384,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.07,
+    outputPrice: 0.3,
+    description: "OpenAI gpt-oss-20b: Compact model for local/edge deployments. Optimized for low-latency and resource-constrained environments with chain-of-thought output, adjustable reasoning, and agentic workflows."
+  },
+  "accounts/fireworks/models/gpt-oss-120b": {
+    maxTokens: 16384,
+    contextWindow: 128e3,
+    supportsImages: false,
+    supportsPromptCache: false,
+    inputPrice: 0.15,
+    outputPrice: 0.6,
+    description: "OpenAI gpt-oss-120b: Production-grade, general-purpose model that fits on a single H100 GPU. Features complex reasoning, configurable effort, full chain-of-thought transparency, and supports function calling, tool use, and structured outputs."
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ANTHROPIC_DEFAULT_MAX_TOKENS,
   ANTHROPIC_STYLE_PROVIDERS,
   AWS_INFERENCE_PROFILE_MAPPING,
+  BEDROCK_CLAUDE_SONNET_4_MODEL_ID,
   BEDROCK_DEFAULT_CONTEXT,
   BEDROCK_DEFAULT_TEMPERATURE,
   BEDROCK_MAX_TOKENS,
@@ -4253,6 +4523,7 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
   DEFAULT_MODES,
   DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT,
+  DEFAULT_USAGE_COLLECTION_TIMEOUT_MS,
   DEFAULT_WRITE_DELAY_MS,
   DOUBAO_API_BASE_URL,
   DOUBAO_API_CHAT_PATH,
@@ -4261,6 +4532,7 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   GLAMA_DEFAULT_TEMPERATURE,
   GLOBAL_SETTINGS_KEYS,
   GLOBAL_STATE_KEYS,
+  GPT5_DEFAULT_TEMPERATURE,
   HUGGINGFACE_API_URL,
   HUGGINGFACE_CACHE_DURATION,
   HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
@@ -4269,6 +4541,7 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   HUGGINGFACE_SLIDER_MIN,
   HUGGINGFACE_SLIDER_STEP,
   HUGGINGFACE_TEMPERATURE_MAX_VALUE,
+  IO_INTELLIGENCE_CACHE_DURATION,
   IpcMessageType,
   IpcOrigin,
   LITELLM_COMPUTER_USE_MODELS,
@@ -4283,8 +4556,6 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   OPEN_ROUTER_PROMPT_CACHING_MODELS,
   OPEN_ROUTER_REASONING_BUDGET_MODELS,
   OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS,
-  ORGANIZATION_ALLOW_ALL,
-  ORGANIZATION_DEFAULT,
   PROVIDER_SETTINGS_KEYS,
   RooCodeEventName,
   SECRET_STATE_KEYS,
@@ -4332,6 +4603,9 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   experimentIds,
   experimentIdsSchema,
   experimentsSchema,
+  extendedReasoningEffortsSchema,
+  fireworksDefaultModelId,
+  fireworksModels,
   followUpDataSchema,
   geminiDefaultModelId,
   geminiModels,
@@ -4350,6 +4624,9 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   installMarketplaceItemOptionsSchema,
   internationalZAiDefaultModelId,
   internationalZAiModels,
+  ioIntelligenceDefaultBaseUrl,
+  ioIntelligenceDefaultModelId,
+  ioIntelligenceModels,
   ipcMessageSchema,
   isBlockingAsk,
   isGlobalStateKey,
@@ -4386,10 +4663,6 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   openAiNativeModels,
   openRouterDefaultModelId,
   openRouterDefaultModelInfo,
-  organizationAllowListSchema,
-  organizationCloudSettingsSchema,
-  organizationDefaultSettingsSchema,
-  organizationSettingsSchema,
   promptComponentSchema,
   providerNames,
   providerNamesSchema,
@@ -4406,7 +4679,6 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   rooCodeTelemetryEventSchema,
   sambaNovaDefaultModelId,
   sambaNovaModels,
-  shareResponseSchema,
   suggestionItemSchema,
   taskCommandSchema,
   taskEventSchema,
@@ -4426,6 +4698,8 @@ var ZAI_DEFAULT_TEMPERATURE = 0;
   toolUsageSchema,
   unboundDefaultModelId,
   unboundDefaultModelInfo,
+  verbosityLevels,
+  verbosityLevelsSchema,
   vertexDefaultModelId,
   vertexModels,
   vscodeLlmDefaultModelId,