@roo-code/types 1.45.0 → 1.47.0

package/dist/index.js

@@ -1,56 +1,5 @@
-// src/cloud.ts
-import { z as z13 } from "zod";
-
-// src/global-settings.ts
-import { z as z11 } from "zod";
-
-// src/provider-settings.ts
-import { z as z3 } from "zod";
-
-// src/model.ts
-import { z } from "zod";
-var reasoningEfforts = ["low", "medium", "high"];
-var reasoningEffortsSchema = z.enum(reasoningEfforts);
-var verbosityLevels = ["low", "medium", "high"];
-var verbosityLevelsSchema = z.enum(verbosityLevels);
-var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
-var modelParametersSchema = z.enum(modelParameters);
-var isModelParameter = (value) => modelParameters.includes(value);
-var modelInfoSchema = z.object({
-  maxTokens: z.number().nullish(),
-  maxThinkingTokens: z.number().nullish(),
-  contextWindow: z.number(),
-  supportsImages: z.boolean().optional(),
-  supportsComputerUse: z.boolean().optional(),
-  supportsPromptCache: z.boolean(),
-  // Capability flag to indicate whether the model supports an output verbosity parameter
-  supportsVerbosity: z.boolean().optional(),
-  supportsReasoningBudget: z.boolean().optional(),
-  requiredReasoningBudget: z.boolean().optional(),
-  supportsReasoningEffort: z.boolean().optional(),
-  supportedParameters: z.array(modelParametersSchema).optional(),
-  inputPrice: z.number().optional(),
-  outputPrice: z.number().optional(),
-  cacheWritesPrice: z.number().optional(),
-  cacheReadsPrice: z.number().optional(),
-  description: z.string().optional(),
-  reasoningEffort: reasoningEffortsSchema.optional(),
-  minTokensPerCachePoint: z.number().optional(),
-  maxCachePoints: z.number().optional(),
-  cachableFields: z.array(z.string()).optional(),
-  tiers: z.array(
-    z.object({
-      contextWindow: z.number(),
-      inputPrice: z.number().optional(),
-      outputPrice: z.number().optional(),
-      cacheWritesPrice: z.number().optional(),
-      cacheReadsPrice: z.number().optional()
-    })
-  ).optional()
-});
-
 // src/codebase-index.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 var CODEBASE_INDEX_DEFAULTS = {
   MIN_SEARCH_RESULTS: 10,
   MAX_SEARCH_RESULTS: 200,
@@ -61,38 +10,397 @@ var CODEBASE_INDEX_DEFAULTS = {
   DEFAULT_SEARCH_MIN_SCORE: 0.4,
   SEARCH_SCORE_STEP: 0.05
 };
-var codebaseIndexConfigSchema = z2.object({
-  codebaseIndexEnabled: z2.boolean().optional(),
-  codebaseIndexQdrantUrl: z2.string().optional(),
-  codebaseIndexEmbedderProvider: z2.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral"]).optional(),
-  codebaseIndexEmbedderBaseUrl: z2.string().optional(),
-  codebaseIndexEmbedderModelId: z2.string().optional(),
-  codebaseIndexEmbedderModelDimension: z2.number().optional(),
-  codebaseIndexSearchMinScore: z2.number().min(0).max(1).optional(),
-  codebaseIndexSearchMaxResults: z2.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
+var codebaseIndexConfigSchema = z.object({
+  codebaseIndexEnabled: z.boolean().optional(),
+  codebaseIndexQdrantUrl: z.string().optional(),
+  codebaseIndexEmbedderProvider: z.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral"]).optional(),
+  codebaseIndexEmbedderBaseUrl: z.string().optional(),
+  codebaseIndexEmbedderModelId: z.string().optional(),
+  codebaseIndexEmbedderModelDimension: z.number().optional(),
+  codebaseIndexSearchMinScore: z.number().min(0).max(1).optional(),
+  codebaseIndexSearchMaxResults: z.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
   // OpenAI Compatible specific fields
-  codebaseIndexOpenAiCompatibleBaseUrl: z2.string().optional(),
-  codebaseIndexOpenAiCompatibleModelDimension: z2.number().optional()
+  codebaseIndexOpenAiCompatibleBaseUrl: z.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: z.number().optional()
+});
+var codebaseIndexModelsSchema = z.object({
+  openai: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+  ollama: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+  "openai-compatible": z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+  gemini: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+  mistral: z.record(z.string(), z.object({ dimension: z.number() })).optional()
+});
+var codebaseIndexProviderSchema = z.object({
+  codeIndexOpenAiKey: z.string().optional(),
+  codeIndexQdrantApiKey: z.string().optional(),
+  codebaseIndexOpenAiCompatibleBaseUrl: z.string().optional(),
+  codebaseIndexOpenAiCompatibleApiKey: z.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: z.number().optional(),
+  codebaseIndexGeminiApiKey: z.string().optional(),
+  codebaseIndexMistralApiKey: z.string().optional()
+});
+
+// src/events.ts
+import { z as z4 } from "zod";
+
+// src/message.ts
+import { z as z2 } from "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 = z2.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 = z2.enum(clineSays);
+var toolProgressStatusSchema = z2.object({
+  icon: z2.string().optional(),
+  text: z2.string().optional()
+});
+var contextCondenseSchema = z2.object({
+  cost: z2.number(),
+  prevContextTokens: z2.number(),
+  newContextTokens: z2.number(),
+  summary: z2.string()
+});
+var clineMessageSchema = z2.object({
+  ts: z2.number(),
+  type: z2.union([z2.literal("ask"), z2.literal("say")]),
+  ask: clineAskSchema.optional(),
+  say: clineSaySchema.optional(),
+  text: z2.string().optional(),
+  images: z2.array(z2.string()).optional(),
+  partial: z2.boolean().optional(),
+  reasoning: z2.string().optional(),
+  conversationHistoryIndex: z2.number().optional(),
+  checkpoint: z2.record(z2.string(), z2.unknown()).optional(),
+  progressStatus: toolProgressStatusSchema.optional(),
+  contextCondense: contextCondenseSchema.optional(),
+  isProtected: z2.boolean().optional(),
+  apiProtocol: z2.union([z2.literal("openai"), z2.literal("anthropic")]).optional(),
+  metadata: z2.object({
+    gpt5: z2.object({
+      previous_response_id: z2.string().optional(),
+      instructions: z2.string().optional(),
+      reasoning_summary: z2.string().optional()
+    }).optional()
+  }).optional()
+});
+var tokenUsageSchema = z2.object({
+  totalTokensIn: z2.number(),
+  totalTokensOut: z2.number(),
+  totalCacheWrites: z2.number().optional(),
+  totalCacheReads: z2.number().optional(),
+  totalCost: z2.number(),
+  contextTokens: z2.number()
+});
+
+// src/tool.ts
+import { z as z3 } from "zod";
+var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
+var toolGroupsSchema = z3.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 = z3.enum(toolNames);
+var toolUsageSchema = z3.record(
+  toolNamesSchema,
+  z3.object({
+    attempts: z3.number(),
+    failures: z3.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 = z4.object({
+  ["taskCreated" /* TaskCreated */]: z4.tuple([z4.string()]),
+  ["taskStarted" /* TaskStarted */]: z4.tuple([z4.string()]),
+  ["taskCompleted" /* TaskCompleted */]: z4.tuple([
+    z4.string(),
+    tokenUsageSchema,
+    toolUsageSchema,
+    z4.object({
+      isSubtask: z4.boolean()
+    })
+  ]),
+  ["taskAborted" /* TaskAborted */]: z4.tuple([z4.string()]),
+  ["taskFocused" /* TaskFocused */]: z4.tuple([z4.string()]),
+  ["taskUnfocused" /* TaskUnfocused */]: z4.tuple([z4.string()]),
+  ["taskActive" /* TaskActive */]: z4.tuple([z4.string()]),
+  ["taskIdle" /* TaskIdle */]: z4.tuple([z4.string()]),
+  ["taskPaused" /* TaskPaused */]: z4.tuple([z4.string()]),
+  ["taskUnpaused" /* TaskUnpaused */]: z4.tuple([z4.string()]),
+  ["taskSpawned" /* TaskSpawned */]: z4.tuple([z4.string(), z4.string()]),
+  ["message" /* Message */]: z4.tuple([
+    z4.object({
+      taskId: z4.string(),
+      action: z4.union([z4.literal("created"), z4.literal("updated")]),
+      message: clineMessageSchema
+    })
+  ]),
+  ["taskModeSwitched" /* TaskModeSwitched */]: z4.tuple([z4.string(), z4.string()]),
+  ["taskAskResponded" /* TaskAskResponded */]: z4.tuple([z4.string()]),
+  ["taskToolFailed" /* TaskToolFailed */]: z4.tuple([z4.string(), toolNamesSchema, z4.string()]),
+  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z4.tuple([z4.string(), tokenUsageSchema])
+});
+var taskEventSchema = z4.discriminatedUnion("eventName", [
+  // Task Provider Lifecycle
+  z4.object({
+    eventName: z4.literal("taskCreated" /* TaskCreated */),
+    payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
+    taskId: z4.number().optional()
+  }),
+  // Task Lifecycle
+  z4.object({
+    eventName: z4.literal("taskStarted" /* TaskStarted */),
+    payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskCompleted" /* TaskCompleted */),
+    payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskAborted" /* TaskAborted */),
+    payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskFocused" /* TaskFocused */),
+    payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskUnfocused" /* TaskUnfocused */),
+    payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskActive" /* TaskActive */),
+    payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskIdle" /* TaskIdle */),
+    payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
+    taskId: z4.number().optional()
+  }),
+  // Subtask Lifecycle
+  z4.object({
+    eventName: z4.literal("taskPaused" /* TaskPaused */),
+    payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskUnpaused" /* TaskUnpaused */),
+    payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskSpawned" /* TaskSpawned */),
+    payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
+    taskId: z4.number().optional()
+  }),
+  // Task Execution
+  z4.object({
+    eventName: z4.literal("message" /* Message */),
+    payload: rooCodeEventsSchema.shape["message" /* Message */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskModeSwitched" /* TaskModeSwitched */),
+    payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskAskResponded" /* TaskAskResponded */),
+    payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
+    taskId: z4.number().optional()
+  }),
+  // Task Analytics
+  z4.object({
+    eventName: z4.literal("taskToolFailed" /* TaskToolFailed */),
+    payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
+    taskId: z4.number().optional()
+  }),
+  z4.object({
+    eventName: z4.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
+    payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
+    taskId: z4.number().optional()
+  }),
+  // Evals
+  z4.object({
+    eventName: z4.literal("evalPass" /* EvalPass */),
+    payload: z4.undefined(),
+    taskId: z4.number()
+  }),
+  z4.object({
+    eventName: z4.literal("evalFail" /* EvalFail */),
+    payload: z4.undefined(),
+    taskId: z4.number()
+  })
+]);
+
+// src/experiment.ts
+import { z as z5 } from "zod";
+var experimentIds = ["powerSteering", "multiFileApplyDiff", "preventFocusDisruption", "assistantMessageParser"];
+var experimentIdsSchema = z5.enum(experimentIds);
+var experimentsSchema = z5.object({
+  powerSteering: z5.boolean().optional(),
+  multiFileApplyDiff: z5.boolean().optional(),
+  preventFocusDisruption: z5.boolean().optional(),
+  assistantMessageParser: z5.boolean().optional()
+});
+
+// src/followup.ts
+import { z as z6 } from "zod";
+var suggestionItemSchema = z6.object({
+  answer: z6.string(),
+  mode: z6.string().optional()
 });
-var codebaseIndexModelsSchema = z2.object({
-  openai: z2.record(z2.string(), z2.object({ dimension: z2.number() })).optional(),
-  ollama: z2.record(z2.string(), z2.object({ dimension: z2.number() })).optional(),
-  "openai-compatible": z2.record(z2.string(), z2.object({ dimension: z2.number() })).optional(),
-  gemini: z2.record(z2.string(), z2.object({ dimension: z2.number() })).optional(),
-  mistral: z2.record(z2.string(), z2.object({ dimension: z2.number() })).optional()
+var followUpDataSchema = z6.object({
+  question: z6.string().optional(),
+  suggest: z6.array(suggestionItemSchema).optional()
 });
-var codebaseIndexProviderSchema = z2.object({
-  codeIndexOpenAiKey: z2.string().optional(),
-  codeIndexQdrantApiKey: z2.string().optional(),
-  codebaseIndexOpenAiCompatibleBaseUrl: z2.string().optional(),
-  codebaseIndexOpenAiCompatibleApiKey: z2.string().optional(),
-  codebaseIndexOpenAiCompatibleModelDimension: z2.number().optional(),
-  codebaseIndexGeminiApiKey: z2.string().optional(),
-  codebaseIndexMistralApiKey: z2.string().optional()
+
+// src/global-settings.ts
+import { z as z13 } from "zod";
+
+// src/provider-settings.ts
+import { z as z8 } from "zod";
+
+// src/model.ts
+import { z as z7 } from "zod";
+var reasoningEfforts = ["low", "medium", "high"];
+var reasoningEffortsSchema = z7.enum(reasoningEfforts);
+var verbosityLevels = ["low", "medium", "high"];
+var verbosityLevelsSchema = z7.enum(verbosityLevels);
+var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
+var modelParametersSchema = z7.enum(modelParameters);
+var isModelParameter = (value) => modelParameters.includes(value);
+var modelInfoSchema = z7.object({
+  maxTokens: z7.number().nullish(),
+  maxThinkingTokens: z7.number().nullish(),
+  contextWindow: z7.number(),
+  supportsImages: z7.boolean().optional(),
+  supportsComputerUse: z7.boolean().optional(),
+  supportsPromptCache: z7.boolean(),
+  // Capability flag to indicate whether the model supports an output verbosity parameter
+  supportsVerbosity: z7.boolean().optional(),
+  supportsReasoningBudget: z7.boolean().optional(),
+  requiredReasoningBudget: z7.boolean().optional(),
+  supportsReasoningEffort: z7.boolean().optional(),
+  supportedParameters: z7.array(modelParametersSchema).optional(),
+  inputPrice: z7.number().optional(),
+  outputPrice: z7.number().optional(),
+  cacheWritesPrice: z7.number().optional(),
+  cacheReadsPrice: z7.number().optional(),
+  description: z7.string().optional(),
+  reasoningEffort: reasoningEffortsSchema.optional(),
+  minTokensPerCachePoint: z7.number().optional(),
+  maxCachePoints: z7.number().optional(),
+  cachableFields: z7.array(z7.string()).optional(),
+  tiers: z7.array(
+    z7.object({
+      contextWindow: z7.number(),
+      inputPrice: z7.number().optional(),
+      outputPrice: z7.number().optional(),
+      cacheWritesPrice: z7.number().optional(),
+      cacheReadsPrice: z7.number().optional()
+    })
+  ).optional()
 });
 
 // src/provider-settings.ts
-var extendedReasoningEffortsSchema = z3.union([reasoningEffortsSchema, z3.literal("minimal")]);
+var BEDROCK_CLAUDE_SONNET_4_MODEL_ID = "anthropic.claude-sonnet-4-20250514-v1:0";
+var extendedReasoningEffortsSchema = z8.union([reasoningEffortsSchema, z8.literal("minimal")]);
 var providerNames = [
   "anthropic",
   "claude-code",
@@ -123,220 +431,231 @@ var providerNames = [
   "cerebras",
   "sambanova",
   "zai",
-  "fireworks"
+  "fireworks",
+  "io-intelligence"
 ];
-var providerNamesSchema = z3.enum(providerNames);
-var providerSettingsEntrySchema = z3.object({
-  id: z3.string(),
-  name: z3.string(),
+var providerNamesSchema = z8.enum(providerNames);
+var providerSettingsEntrySchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
   apiProvider: providerNamesSchema.optional()
 });
 var DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3;
-var baseProviderSettingsSchema = z3.object({
-  includeMaxTokens: z3.boolean().optional(),
-  diffEnabled: z3.boolean().optional(),
-  todoListEnabled: z3.boolean().optional(),
-  fuzzyMatchThreshold: z3.number().optional(),
-  modelTemperature: z3.number().nullish(),
-  rateLimitSeconds: z3.number().optional(),
-  consecutiveMistakeLimit: z3.number().min(0).optional(),
+var baseProviderSettingsSchema = z8.object({
+  includeMaxTokens: z8.boolean().optional(),
+  diffEnabled: z8.boolean().optional(),
+  todoListEnabled: z8.boolean().optional(),
+  fuzzyMatchThreshold: z8.number().optional(),
+  modelTemperature: z8.number().nullish(),
+  rateLimitSeconds: z8.number().optional(),
+  consecutiveMistakeLimit: z8.number().min(0).optional(),
   // Model reasoning.
-  enableReasoningEffort: z3.boolean().optional(),
+  enableReasoningEffort: z8.boolean().optional(),
   reasoningEffort: extendedReasoningEffortsSchema.optional(),
-  modelMaxTokens: z3.number().optional(),
-  modelMaxThinkingTokens: z3.number().optional(),
+  modelMaxTokens: z8.number().optional(),
+  modelMaxThinkingTokens: z8.number().optional(),
   // Model verbosity.
   verbosity: verbosityLevelsSchema.optional()
 });
 var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
-  apiModelId: z3.string().optional()
+  apiModelId: z8.string().optional()
 });
 var anthropicSchema = apiModelIdProviderModelSchema.extend({
-  apiKey: z3.string().optional(),
-  anthropicBaseUrl: z3.string().optional(),
-  anthropicUseAuthToken: z3.boolean().optional()
+  apiKey: z8.string().optional(),
+  anthropicBaseUrl: z8.string().optional(),
+  anthropicUseAuthToken: z8.boolean().optional(),
+  anthropicBeta1MContext: z8.boolean().optional()
+  // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var claudeCodeSchema = apiModelIdProviderModelSchema.extend({
-  claudeCodePath: z3.string().optional(),
-  claudeCodeMaxOutputTokens: z3.number().int().min(1).max(2e5).optional()
+  claudeCodePath: z8.string().optional(),
+  claudeCodeMaxOutputTokens: z8.number().int().min(1).max(2e5).optional()
 });
 var glamaSchema = baseProviderSettingsSchema.extend({
-  glamaModelId: z3.string().optional(),
-  glamaApiKey: z3.string().optional()
+  glamaModelId: z8.string().optional(),
+  glamaApiKey: z8.string().optional()
 });
 var openRouterSchema = baseProviderSettingsSchema.extend({
-  openRouterApiKey: z3.string().optional(),
-  openRouterModelId: z3.string().optional(),
-  openRouterBaseUrl: z3.string().optional(),
-  openRouterSpecificProvider: z3.string().optional(),
-  openRouterUseMiddleOutTransform: z3.boolean().optional()
+  openRouterApiKey: z8.string().optional(),
+  openRouterModelId: z8.string().optional(),
+  openRouterBaseUrl: z8.string().optional(),
+  openRouterSpecificProvider: z8.string().optional(),
+  openRouterUseMiddleOutTransform: z8.boolean().optional()
 });
 var bedrockSchema = apiModelIdProviderModelSchema.extend({
-  awsAccessKey: z3.string().optional(),
-  awsSecretKey: z3.string().optional(),
-  awsSessionToken: z3.string().optional(),
-  awsRegion: z3.string().optional(),
-  awsUseCrossRegionInference: z3.boolean().optional(),
-  awsUsePromptCache: z3.boolean().optional(),
-  awsProfile: z3.string().optional(),
-  awsUseProfile: z3.boolean().optional(),
-  awsApiKey: z3.string().optional(),
-  awsUseApiKey: z3.boolean().optional(),
-  awsCustomArn: z3.string().optional(),
-  awsModelContextWindow: z3.number().optional(),
-  awsBedrockEndpointEnabled: z3.boolean().optional(),
-  awsBedrockEndpoint: z3.string().optional()
+  awsAccessKey: z8.string().optional(),
+  awsSecretKey: z8.string().optional(),
+  awsSessionToken: z8.string().optional(),
+  awsRegion: z8.string().optional(),
+  awsUseCrossRegionInference: z8.boolean().optional(),
+  awsUsePromptCache: z8.boolean().optional(),
+  awsProfile: z8.string().optional(),
+  awsUseProfile: z8.boolean().optional(),
+  awsApiKey: z8.string().optional(),
+  awsUseApiKey: z8.boolean().optional(),
+  awsCustomArn: z8.string().optional(),
+  awsModelContextWindow: z8.number().optional(),
+  awsBedrockEndpointEnabled: z8.boolean().optional(),
+  awsBedrockEndpoint: z8.string().optional(),
+  awsBedrock1MContext: z8.boolean().optional()
+  // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var vertexSchema = apiModelIdProviderModelSchema.extend({
-  vertexKeyFile: z3.string().optional(),
-  vertexJsonCredentials: z3.string().optional(),
-  vertexProjectId: z3.string().optional(),
-  vertexRegion: z3.string().optional()
+  vertexKeyFile: z8.string().optional(),
+  vertexJsonCredentials: z8.string().optional(),
+  vertexProjectId: z8.string().optional(),
+  vertexRegion: z8.string().optional()
 });
 var openAiSchema = baseProviderSettingsSchema.extend({
-  openAiBaseUrl: z3.string().optional(),
-  openAiApiKey: z3.string().optional(),
-  openAiLegacyFormat: z3.boolean().optional(),
-  openAiR1FormatEnabled: z3.boolean().optional(),
-  openAiModelId: z3.string().optional(),
+  openAiBaseUrl: z8.string().optional(),
+  openAiApiKey: z8.string().optional(),
+  openAiLegacyFormat: z8.boolean().optional(),
+  openAiR1FormatEnabled: z8.boolean().optional(),
+  openAiModelId: z8.string().optional(),
   openAiCustomModelInfo: modelInfoSchema.nullish(),
-  openAiUseAzure: z3.boolean().optional(),
-  azureApiVersion: z3.string().optional(),
-  openAiStreamingEnabled: z3.boolean().optional(),
-  openAiHostHeader: z3.string().optional(),
+  openAiUseAzure: z8.boolean().optional(),
+  azureApiVersion: z8.string().optional(),
+  openAiStreamingEnabled: z8.boolean().optional(),
+  openAiHostHeader: z8.string().optional(),
   // Keep temporarily for backward compatibility during migration.
-  openAiHeaders: z3.record(z3.string(), z3.string()).optional()
+  openAiHeaders: z8.record(z8.string(), z8.string()).optional()
 });
 var ollamaSchema = baseProviderSettingsSchema.extend({
-  ollamaModelId: z3.string().optional(),
-  ollamaBaseUrl: z3.string().optional()
+  ollamaModelId: z8.string().optional(),
+  ollamaBaseUrl: z8.string().optional()
 });
 var vsCodeLmSchema = baseProviderSettingsSchema.extend({
-  vsCodeLmModelSelector: z3.object({
-    vendor: z3.string().optional(),
-    family: z3.string().optional(),
-    version: z3.string().optional(),
-    id: z3.string().optional()
+  vsCodeLmModelSelector: z8.object({
+    vendor: z8.string().optional(),
+    family: z8.string().optional(),
+    version: z8.string().optional(),
+    id: z8.string().optional()
   }).optional()
 });
 var lmStudioSchema = baseProviderSettingsSchema.extend({
-  lmStudioModelId: z3.string().optional(),
-  lmStudioBaseUrl: z3.string().optional(),
-  lmStudioDraftModelId: z3.string().optional(),
-  lmStudioSpeculativeDecodingEnabled: z3.boolean().optional()
+  lmStudioModelId: z8.string().optional(),
+  lmStudioBaseUrl: z8.string().optional(),
+  lmStudioDraftModelId: z8.string().optional(),
+  lmStudioSpeculativeDecodingEnabled: z8.boolean().optional()
 });
 var geminiSchema = apiModelIdProviderModelSchema.extend({
-  geminiApiKey: z3.string().optional(),
-  googleGeminiBaseUrl: z3.string().optional(),
-  enableUrlContext: z3.boolean().optional(),
-  enableGrounding: z3.boolean().optional()
+  geminiApiKey: z8.string().optional(),
+  googleGeminiBaseUrl: z8.string().optional(),
+  enableUrlContext: z8.boolean().optional(),
+  enableGrounding: z8.boolean().optional()
 });
 var geminiCliSchema = apiModelIdProviderModelSchema.extend({
-  geminiCliOAuthPath: z3.string().optional(),
-  geminiCliProjectId: z3.string().optional()
+  geminiCliOAuthPath: z8.string().optional(),
+  geminiCliProjectId: z8.string().optional()
 });
 var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
-  openAiNativeApiKey: z3.string().optional(),
-  openAiNativeBaseUrl: z3.string().optional()
+  openAiNativeApiKey: z8.string().optional(),
+  openAiNativeBaseUrl: z8.string().optional()
 });
 var mistralSchema = apiModelIdProviderModelSchema.extend({
-  mistralApiKey: z3.string().optional(),
-  mistralCodestralUrl: z3.string().optional()
+  mistralApiKey: z8.string().optional(),
+  mistralCodestralUrl: z8.string().optional()
 });
 var deepSeekSchema = apiModelIdProviderModelSchema.extend({
-  deepSeekBaseUrl: z3.string().optional(),
-  deepSeekApiKey: z3.string().optional()
+  deepSeekBaseUrl: z8.string().optional(),
+  deepSeekApiKey: z8.string().optional()
 });
 var doubaoSchema = apiModelIdProviderModelSchema.extend({
-  doubaoBaseUrl: z3.string().optional(),
-  doubaoApiKey: z3.string().optional()
+  doubaoBaseUrl: z8.string().optional(),
+  doubaoApiKey: z8.string().optional()
 });
 var moonshotSchema = apiModelIdProviderModelSchema.extend({
-  moonshotBaseUrl: z3.union([z3.literal("https://api.moonshot.ai/v1"), z3.literal("https://api.moonshot.cn/v1")]).optional(),
-  moonshotApiKey: z3.string().optional()
+  moonshotBaseUrl: z8.union([z8.literal("https://api.moonshot.ai/v1"), z8.literal("https://api.moonshot.cn/v1")]).optional(),
+  moonshotApiKey: z8.string().optional()
 });
 var unboundSchema = baseProviderSettingsSchema.extend({
-  unboundApiKey: z3.string().optional(),
-  unboundModelId: z3.string().optional()
+  unboundApiKey: z8.string().optional(),
+  unboundModelId: z8.string().optional()
 });
 var requestySchema = baseProviderSettingsSchema.extend({
-  requestyApiKey: z3.string().optional(),
-  requestyModelId: z3.string().optional()
+  requestyBaseUrl: z8.string().optional(),
+  requestyApiKey: z8.string().optional(),
+  requestyModelId: z8.string().optional()
 });
 var humanRelaySchema = baseProviderSettingsSchema;
 var fakeAiSchema = baseProviderSettingsSchema.extend({
-  fakeAi: z3.unknown().optional()
+  fakeAi: z8.unknown().optional()
 });
 var xaiSchema = apiModelIdProviderModelSchema.extend({
-  xaiApiKey: z3.string().optional()
+  xaiApiKey: z8.string().optional()
 });
 var groqSchema = apiModelIdProviderModelSchema.extend({
-  groqApiKey: z3.string().optional()
+  groqApiKey: z8.string().optional()
 });
 var huggingFaceSchema = baseProviderSettingsSchema.extend({
-  huggingFaceApiKey: z3.string().optional(),
-  huggingFaceModelId: z3.string().optional(),
-  huggingFaceInferenceProvider: z3.string().optional()
+  huggingFaceApiKey: z8.string().optional(),
+  huggingFaceModelId: z8.string().optional(),
+  huggingFaceInferenceProvider: z8.string().optional()
 });
 var chutesSchema = apiModelIdProviderModelSchema.extend({
-  chutesApiKey: z3.string().optional()
+  chutesApiKey: z8.string().optional()
 });
 var litellmSchema = baseProviderSettingsSchema.extend({
-  litellmBaseUrl: z3.string().optional(),
-  litellmApiKey: z3.string().optional(),
-  litellmModelId: z3.string().optional(),
-  litellmUsePromptCache: z3.boolean().optional()
+  litellmBaseUrl: z8.string().optional(),
+  litellmApiKey: z8.string().optional(),
+  litellmModelId: z8.string().optional(),
+  litellmUsePromptCache: z8.boolean().optional()
 });
 var cerebrasSchema = apiModelIdProviderModelSchema.extend({
-  cerebrasApiKey: z3.string().optional()
+  cerebrasApiKey: z8.string().optional()
 });
 var sambaNovaSchema = apiModelIdProviderModelSchema.extend({
-  sambaNovaApiKey: z3.string().optional()
+  sambaNovaApiKey: z8.string().optional()
 });
 var zaiSchema = apiModelIdProviderModelSchema.extend({
-  zaiApiKey: z3.string().optional(),
-  zaiApiLine: z3.union([z3.literal("china"), z3.literal("international")]).optional()
+  zaiApiKey: z8.string().optional(),
+  zaiApiLine: z8.union([z8.literal("china"), z8.literal("international")]).optional()
 });
 var fireworksSchema = apiModelIdProviderModelSchema.extend({
-  fireworksApiKey: z3.string().optional()
+  fireworksApiKey: z8.string().optional()
 });
-var defaultSchema = z3.object({
-  apiProvider: z3.undefined()
+var ioIntelligenceSchema = apiModelIdProviderModelSchema.extend({
+  ioIntelligenceModelId: z8.string().optional(),
+  ioIntelligenceApiKey: z8.string().optional()
 });
-var providerSettingsSchemaDiscriminated = z3.discriminatedUnion("apiProvider", [
-  anthropicSchema.merge(z3.object({ apiProvider: z3.literal("anthropic") })),
-  claudeCodeSchema.merge(z3.object({ apiProvider: z3.literal("claude-code") })),
-  glamaSchema.merge(z3.object({ apiProvider: z3.literal("glama") })),
-  openRouterSchema.merge(z3.object({ apiProvider: z3.literal("openrouter") })),
-  bedrockSchema.merge(z3.object({ apiProvider: z3.literal("bedrock") })),
-  vertexSchema.merge(z3.object({ apiProvider: z3.literal("vertex") })),
-  openAiSchema.merge(z3.object({ apiProvider: z3.literal("openai") })),
-  ollamaSchema.merge(z3.object({ apiProvider: z3.literal("ollama") })),
-  vsCodeLmSchema.merge(z3.object({ apiProvider: z3.literal("vscode-lm") })),
-  lmStudioSchema.merge(z3.object({ apiProvider: z3.literal("lmstudio") })),
-  geminiSchema.merge(z3.object({ apiProvider: z3.literal("gemini") })),
-  geminiCliSchema.merge(z3.object({ apiProvider: z3.literal("gemini-cli") })),
-  openAiNativeSchema.merge(z3.object({ apiProvider: z3.literal("openai-native") })),
-  mistralSchema.merge(z3.object({ apiProvider: z3.literal("mistral") })),
-  deepSeekSchema.merge(z3.object({ apiProvider: z3.literal("deepseek") })),
-  doubaoSchema.merge(z3.object({ apiProvider: z3.literal("doubao") })),
-  moonshotSchema.merge(z3.object({ apiProvider: z3.literal("moonshot") })),
-  unboundSchema.merge(z3.object({ apiProvider: z3.literal("unbound") })),
-  requestySchema.merge(z3.object({ apiProvider: z3.literal("requesty") })),
-  humanRelaySchema.merge(z3.object({ apiProvider: z3.literal("human-relay") })),
-  fakeAiSchema.merge(z3.object({ apiProvider: z3.literal("fake-ai") })),
-  xaiSchema.merge(z3.object({ apiProvider: z3.literal("xai") })),
-  groqSchema.merge(z3.object({ apiProvider: z3.literal("groq") })),
-  huggingFaceSchema.merge(z3.object({ apiProvider: z3.literal("huggingface") })),
-  chutesSchema.merge(z3.object({ apiProvider: z3.literal("chutes") })),
-  litellmSchema.merge(z3.object({ apiProvider: z3.literal("litellm") })),
-  cerebrasSchema.merge(z3.object({ apiProvider: z3.literal("cerebras") })),
-  sambaNovaSchema.merge(z3.object({ apiProvider: z3.literal("sambanova") })),
-  zaiSchema.merge(z3.object({ apiProvider: z3.literal("zai") })),
-  fireworksSchema.merge(z3.object({ apiProvider: z3.literal("fireworks") })),
+var defaultSchema = z8.object({
+  apiProvider: z8.undefined()
+});
+var providerSettingsSchemaDiscriminated = z8.discriminatedUnion("apiProvider", [
+  anthropicSchema.merge(z8.object({ apiProvider: z8.literal("anthropic") })),
+  claudeCodeSchema.merge(z8.object({ apiProvider: z8.literal("claude-code") })),
+  glamaSchema.merge(z8.object({ apiProvider: z8.literal("glama") })),
+  openRouterSchema.merge(z8.object({ apiProvider: z8.literal("openrouter") })),
+  bedrockSchema.merge(z8.object({ apiProvider: z8.literal("bedrock") })),
+  vertexSchema.merge(z8.object({ apiProvider: z8.literal("vertex") })),
+  openAiSchema.merge(z8.object({ apiProvider: z8.literal("openai") })),
+  ollamaSchema.merge(z8.object({ apiProvider: z8.literal("ollama") })),
+  vsCodeLmSchema.merge(z8.object({ apiProvider: z8.literal("vscode-lm") })),
+  lmStudioSchema.merge(z8.object({ apiProvider: z8.literal("lmstudio") })),
+  geminiSchema.merge(z8.object({ apiProvider: z8.literal("gemini") })),
+  geminiCliSchema.merge(z8.object({ apiProvider: z8.literal("gemini-cli") })),
+  openAiNativeSchema.merge(z8.object({ apiProvider: z8.literal("openai-native") })),
+  mistralSchema.merge(z8.object({ apiProvider: z8.literal("mistral") })),
+  deepSeekSchema.merge(z8.object({ apiProvider: z8.literal("deepseek") })),
+  doubaoSchema.merge(z8.object({ apiProvider: z8.literal("doubao") })),
+  moonshotSchema.merge(z8.object({ apiProvider: z8.literal("moonshot") })),
+  unboundSchema.merge(z8.object({ apiProvider: z8.literal("unbound") })),
+  requestySchema.merge(z8.object({ apiProvider: z8.literal("requesty") })),
+  humanRelaySchema.merge(z8.object({ apiProvider: z8.literal("human-relay") })),
+  fakeAiSchema.merge(z8.object({ apiProvider: z8.literal("fake-ai") })),
+  xaiSchema.merge(z8.object({ apiProvider: z8.literal("xai") })),
+  groqSchema.merge(z8.object({ apiProvider: z8.literal("groq") })),
+  huggingFaceSchema.merge(z8.object({ apiProvider: z8.literal("huggingface") })),
+  chutesSchema.merge(z8.object({ apiProvider: z8.literal("chutes") })),
+  litellmSchema.merge(z8.object({ apiProvider: z8.literal("litellm") })),
+  cerebrasSchema.merge(z8.object({ apiProvider: z8.literal("cerebras") })),
+  sambaNovaSchema.merge(z8.object({ apiProvider: z8.literal("sambanova") })),
+  zaiSchema.merge(z8.object({ apiProvider: z8.literal("zai") })),
+  fireworksSchema.merge(z8.object({ apiProvider: z8.literal("fireworks") })),
+  ioIntelligenceSchema.merge(z8.object({ apiProvider: z8.literal("io-intelligence") })),
   defaultSchema
 ]);
-var providerSettingsSchema = z3.object({
+var providerSettingsSchema = z8.object({
   apiProvider: providerNamesSchema.optional(),
   ...anthropicSchema.shape,
   ...claudeCodeSchema.shape,
@@ -368,11 +687,12 @@ var providerSettingsSchema = z3.object({
   ...sambaNovaSchema.shape,
   ...zaiSchema.shape,
   ...fireworksSchema.shape,
+  ...ioIntelligenceSchema.shape,
   ...codebaseIndexProviderSchema.shape
 });
-var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: z3.string().optional() });
+var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: z8.string().optional() });
 var discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
-  z3.object({ id: z3.string().optional() })
+  z8.object({ id: z8.string().optional() })
 );
 var PROVIDER_SETTINGS_KEYS = providerSettingsSchema.keyof().options;
 var MODEL_ID_KEYS = [
@@ -386,7 +706,8 @@ var MODEL_ID_KEYS = [
   "unboundModelId",
   "requestyModelId",
   "litellmModelId",
-  "huggingFaceModelId"
+  "huggingFaceModelId",
+  "ioIntelligenceModelId"
 ];
 var getModelId = (settings) => {
   const modelIdKey = MODEL_ID_KEYS.find((key) => settings[key]);
@@ -404,138 +725,26 @@ var getApiProtocol = (provider, modelId) => {
 };
 
 // src/history.ts
-import { z as z4 } from "zod";
-var historyItemSchema = z4.object({
-  id: z4.string(),
-  number: z4.number(),
-  ts: z4.number(),
-  task: z4.string(),
-  tokensIn: z4.number(),
-  tokensOut: z4.number(),
-  cacheWrites: z4.number().optional(),
-  cacheReads: z4.number().optional(),
-  totalCost: z4.number(),
-  size: z4.number().optional(),
-  workspace: z4.string().optional(),
-  mode: z4.string().optional()
-});
-
-// src/experiment.ts
-import { z as z5 } from "zod";
-var experimentIds = ["powerSteering", "multiFileApplyDiff", "preventFocusDisruption", "assistantMessageParser"];
-var experimentIdsSchema = z5.enum(experimentIds);
-var experimentsSchema = z5.object({
-  powerSteering: z5.boolean().optional(),
-  multiFileApplyDiff: z5.boolean().optional(),
-  preventFocusDisruption: z5.boolean().optional(),
-  assistantMessageParser: z5.boolean().optional()
-});
-
-// src/telemetry.ts
-import { z as z7 } from "zod";
-
-// src/message.ts
-import { z as z6 } from "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 = z6.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 = z6.enum(clineSays);
-var toolProgressStatusSchema = z6.object({
-  icon: z6.string().optional(),
-  text: z6.string().optional()
-});
-var contextCondenseSchema = z6.object({
-  cost: z6.number(),
-  prevContextTokens: z6.number(),
-  newContextTokens: z6.number(),
-  summary: z6.string()
-});
-var clineMessageSchema = z6.object({
-  ts: z6.number(),
-  type: z6.union([z6.literal("ask"), z6.literal("say")]),
-  ask: clineAskSchema.optional(),
-  say: clineSaySchema.optional(),
-  text: z6.string().optional(),
-  images: z6.array(z6.string()).optional(),
-  partial: z6.boolean().optional(),
-  reasoning: z6.string().optional(),
-  conversationHistoryIndex: z6.number().optional(),
-  checkpoint: z6.record(z6.string(), z6.unknown()).optional(),
-  progressStatus: toolProgressStatusSchema.optional(),
-  contextCondense: contextCondenseSchema.optional(),
-  isProtected: z6.boolean().optional(),
-  apiProtocol: z6.union([z6.literal("openai"), z6.literal("anthropic")]).optional(),
-  metadata: z6.object({
-    gpt5: z6.object({
-      previous_response_id: z6.string().optional(),
-      instructions: z6.string().optional(),
-      reasoning_summary: z6.string().optional()
-    }).optional()
-  }).optional()
-});
-var tokenUsageSchema = z6.object({
-  totalTokensIn: z6.number(),
-  totalTokensOut: z6.number(),
-  totalCacheWrites: z6.number().optional(),
-  totalCacheReads: z6.number().optional(),
-  totalCost: z6.number(),
-  contextTokens: z6.number()
+import { z as z9 } from "zod";
+var historyItemSchema = z9.object({
+  id: z9.string(),
+  number: z9.number(),
+  ts: z9.number(),
+  task: z9.string(),
+  tokensIn: z9.number(),
+  tokensOut: z9.number(),
+  cacheWrites: z9.number().optional(),
+  cacheReads: z9.number().optional(),
+  totalCost: z9.number(),
+  size: z9.number().optional(),
+  workspace: z9.string().optional(),
+  mode: z9.string().optional()
 });
 
 // src/telemetry.ts
+import { z as z10 } from "zod";
 var telemetrySettings = ["unset", "enabled", "disabled"];
-var telemetrySettingsSchema = z7.enum(telemetrySettings);
+var telemetrySettingsSchema = z10.enum(telemetrySettings);
 var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
   TelemetryEventName2["TASK_CREATED"] = "Task Created";
   TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
@@ -577,42 +786,42 @@ var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
   TelemetryEventName2["CODE_INDEX_ERROR"] = "Code Index Error";
   return TelemetryEventName2;
 })(TelemetryEventName || {});
-var appPropertiesSchema = z7.object({
-  appName: z7.string(),
-  appVersion: z7.string(),
-  vscodeVersion: z7.string(),
-  platform: z7.string(),
-  editorName: z7.string(),
-  language: z7.string(),
-  mode: z7.string(),
-  cloudIsAuthenticated: z7.boolean().optional()
+var appPropertiesSchema = z10.object({
+  appName: z10.string(),
+  appVersion: z10.string(),
+  vscodeVersion: z10.string(),
+  platform: z10.string(),
+  editorName: z10.string(),
+  language: z10.string(),
+  mode: z10.string(),
+  cloudIsAuthenticated: z10.boolean().optional()
 });
-var taskPropertiesSchema = z7.object({
-  taskId: z7.string().optional(),
-  apiProvider: z7.enum(providerNames).optional(),
-  modelId: z7.string().optional(),
-  diffStrategy: z7.string().optional(),
-  isSubtask: z7.boolean().optional(),
-  todos: z7.object({
-    total: z7.number(),
-    completed: z7.number(),
-    inProgress: z7.number(),
-    pending: z7.number()
+var taskPropertiesSchema = z10.object({
+  taskId: z10.string().optional(),
+  apiProvider: z10.enum(providerNames).optional(),
+  modelId: z10.string().optional(),
+  diffStrategy: z10.string().optional(),
+  isSubtask: z10.boolean().optional(),
+  todos: z10.object({
+    total: z10.number(),
+    completed: z10.number(),
+    inProgress: z10.number(),
+    pending: z10.number()
   }).optional()
 });
-var gitPropertiesSchema = z7.object({
-  repositoryUrl: z7.string().optional(),
-  repositoryName: z7.string().optional(),
-  defaultBranch: z7.string().optional()
+var gitPropertiesSchema = z10.object({
+  repositoryUrl: z10.string().optional(),
+  repositoryName: z10.string().optional(),
+  defaultBranch: z10.string().optional()
 });
-var telemetryPropertiesSchema = z7.object({
+var telemetryPropertiesSchema = z10.object({
   ...appPropertiesSchema.shape,
   ...taskPropertiesSchema.shape,
   ...gitPropertiesSchema.shape
 });
-var rooCodeTelemetryEventSchema = z7.discriminatedUnion("type", [
-  z7.object({
-    type: z7.enum([
+var rooCodeTelemetryEventSchema = z10.discriminatedUnion("type", [
+  z10.object({
+    type: z10.enum([
       "Task Created" /* TASK_CREATED */,
       "Task Reopened" /* TASK_RESTARTED */,
       "Task Completed" /* TASK_COMPLETED */,
@@ -648,71 +857,35 @@ var rooCodeTelemetryEventSchema = z7.discriminatedUnion("type", [
       "Sliding Window Truncation" /* SLIDING_WINDOW_TRUNCATION */,
       "Tab Shown" /* TAB_SHOWN */,
       "Mode Setting Changed" /* MODE_SETTINGS_CHANGED */,
-      "Custom Mode Created" /* CUSTOM_MODE_CREATED */
-    ]),
-    properties: telemetryPropertiesSchema
-  }),
-  z7.object({
-    type: z7.literal("Task Message" /* TASK_MESSAGE */),
-    properties: z7.object({
-      ...telemetryPropertiesSchema.shape,
-      taskId: z7.string(),
-      message: clineMessageSchema
-    })
-  }),
-  z7.object({
-    type: z7.literal("LLM Completion" /* LLM_COMPLETION */),
-    properties: z7.object({
-      ...telemetryPropertiesSchema.shape,
-      inputTokens: z7.number(),
-      outputTokens: z7.number(),
-      cacheReadTokens: z7.number().optional(),
-      cacheWriteTokens: z7.number().optional(),
-      cost: z7.number().optional()
-    })
-  })
-]);
-
-// src/mode.ts
-import { z as z9 } from "zod";
-
-// src/tool.ts
-import { z as z8 } from "zod";
-var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
-var toolGroupsSchema = z8.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 = z8.enum(toolNames);
-var toolUsageSchema = z8.record(
-  toolNamesSchema,
-  z8.object({
-    attempts: z8.number(),
-    failures: z8.number()
+      "Custom Mode Created" /* CUSTOM_MODE_CREATED */
+    ]),
+    properties: telemetryPropertiesSchema
+  }),
+  z10.object({
+    type: z10.literal("Task Message" /* TASK_MESSAGE */),
+    properties: z10.object({
+      ...telemetryPropertiesSchema.shape,
+      taskId: z10.string(),
+      message: clineMessageSchema
+    })
+  }),
+  z10.object({
+    type: z10.literal("LLM Completion" /* LLM_COMPLETION */),
+    properties: z10.object({
+      ...telemetryPropertiesSchema.shape,
+      inputTokens: z10.number(),
+      outputTokens: z10.number(),
+      cacheReadTokens: z10.number().optional(),
+      cacheWriteTokens: z10.number().optional(),
+      cost: z10.number().optional()
+    })
   })
-);
+]);
 
 // src/mode.ts
-var groupOptionsSchema = z9.object({
-  fileRegex: z9.string().optional().refine(
+import { z as z11 } from "zod";
+var groupOptionsSchema = z11.object({
+  fileRegex: z11.string().optional().refine(
     (pattern) => {
       if (!pattern) {
         return true;
@@ -726,10 +899,10 @@ var groupOptionsSchema = z9.object({
     },
     { message: "Invalid regular expression pattern" }
   ),
-  description: z9.string().optional()
+  description: z11.string().optional()
 });
-var groupEntrySchema = z9.union([toolGroupsSchema, z9.tuple([toolGroupsSchema, groupOptionsSchema])]);
-var groupEntryArraySchema = z9.array(groupEntrySchema).refine(
+var groupEntrySchema = z11.union([toolGroupsSchema, z11.tuple([toolGroupsSchema, groupOptionsSchema])]);
+var groupEntryArraySchema = z11.array(groupEntrySchema).refine(
   (groups) => {
     const seen = /* @__PURE__ */ new Set();
     return groups.every((group) => {
@@ -743,18 +916,18 @@ var groupEntryArraySchema = z9.array(groupEntrySchema).refine(
   },
   { message: "Duplicate groups are not allowed" }
 );
-var modeConfigSchema = z9.object({
-  slug: z9.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
-  name: z9.string().min(1, "Name is required"),
-  roleDefinition: z9.string().min(1, "Role definition is required"),
-  whenToUse: z9.string().optional(),
-  description: z9.string().optional(),
-  customInstructions: z9.string().optional(),
+var modeConfigSchema = z11.object({
+  slug: z11.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
+  name: z11.string().min(1, "Name is required"),
+  roleDefinition: z11.string().min(1, "Role definition is required"),
+  whenToUse: z11.string().optional(),
+  description: z11.string().optional(),
+  customInstructions: z11.string().optional(),
   groups: groupEntryArraySchema,
-  source: z9.enum(["global", "project"]).optional()
+  source: z11.enum(["global", "project"]).optional()
 });
-var customModesSettingsSchema = z9.object({
-  customModes: z9.array(modeConfigSchema).refine(
+var customModesSettingsSchema = z11.object({
+  customModes: z11.array(modeConfigSchema).refine(
     (modes) => {
       const slugs = /* @__PURE__ */ new Set();
       return modes.every((mode) => {
@@ -770,14 +943,14 @@ var customModesSettingsSchema = z9.object({
     }
   )
 });
-var promptComponentSchema = z9.object({
-  roleDefinition: z9.string().optional(),
-  whenToUse: z9.string().optional(),
-  description: z9.string().optional(),
-  customInstructions: z9.string().optional()
+var promptComponentSchema = z11.object({
+  roleDefinition: z11.string().optional(),
+  whenToUse: z11.string().optional(),
+  description: z11.string().optional(),
+  customInstructions: z11.string().optional()
 });
-var customModePromptsSchema = z9.record(z9.string(), promptComponentSchema.optional());
-var customSupportPromptsSchema = z9.record(z9.string(), z9.string().optional());
+var customModePromptsSchema = z11.record(z11.string(), promptComponentSchema.optional());
+var customSupportPromptsSchema = z11.record(z11.string(), z11.string().optional());
 var DEFAULT_MODES = [
   {
     slug: "architect",
@@ -826,7 +999,7 @@ var DEFAULT_MODES = [
 ];
 
 // src/vscode.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 var codeActionIds = ["explainCode", "fixCode", "improveCode", "addToContext", "newTask"];
 var terminalActionIds = ["terminalAddToContext", "terminalFixCommand", "terminalExplainCommand"];
 var commandIds = [
@@ -871,110 +1044,110 @@ var languages = [
   "zh-CN",
   "zh-TW"
 ];
-var languagesSchema = z10.enum(languages);
+var languagesSchema = z12.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 = z11.object({
-  currentApiConfigName: z11.string().optional(),
-  listApiConfigMeta: z11.array(providerSettingsEntrySchema).optional(),
-  pinnedApiConfigs: z11.record(z11.string(), z11.boolean()).optional(),
-  lastShownAnnouncementId: z11.string().optional(),
-  customInstructions: z11.string().optional(),
-  taskHistory: z11.array(historyItemSchema).optional(),
-  condensingApiConfigId: z11.string().optional(),
-  customCondensingPrompt: z11.string().optional(),
-  autoApprovalEnabled: z11.boolean().optional(),
-  alwaysAllowReadOnly: z11.boolean().optional(),
-  alwaysAllowReadOnlyOutsideWorkspace: z11.boolean().optional(),
-  alwaysAllowWrite: z11.boolean().optional(),
-  alwaysAllowWriteOutsideWorkspace: z11.boolean().optional(),
-  alwaysAllowWriteProtected: z11.boolean().optional(),
-  writeDelayMs: z11.number().min(0).optional(),
-  alwaysAllowBrowser: z11.boolean().optional(),
-  alwaysApproveResubmit: z11.boolean().optional(),
-  requestDelaySeconds: z11.number().optional(),
-  alwaysAllowMcp: z11.boolean().optional(),
-  alwaysAllowModeSwitch: z11.boolean().optional(),
-  alwaysAllowSubtasks: z11.boolean().optional(),
-  alwaysAllowExecute: z11.boolean().optional(),
-  alwaysAllowFollowupQuestions: z11.boolean().optional(),
-  followupAutoApproveTimeoutMs: z11.number().optional(),
-  alwaysAllowUpdateTodoList: z11.boolean().optional(),
-  allowedCommands: z11.array(z11.string()).optional(),
-  deniedCommands: z11.array(z11.string()).optional(),
-  commandExecutionTimeout: z11.number().optional(),
-  commandTimeoutAllowlist: z11.array(z11.string()).optional(),
-  preventCompletionWithOpenTodos: z11.boolean().optional(),
-  allowedMaxRequests: z11.number().nullish(),
-  allowedMaxCost: z11.number().nullish(),
-  autoCondenseContext: z11.boolean().optional(),
-  autoCondenseContextPercent: z11.number().optional(),
-  maxConcurrentFileReads: z11.number().optional(),
+var globalSettingsSchema = z13.object({
+  currentApiConfigName: z13.string().optional(),
+  listApiConfigMeta: z13.array(providerSettingsEntrySchema).optional(),
+  pinnedApiConfigs: z13.record(z13.string(), z13.boolean()).optional(),
+  lastShownAnnouncementId: z13.string().optional(),
+  customInstructions: z13.string().optional(),
+  taskHistory: z13.array(historyItemSchema).optional(),
+  condensingApiConfigId: z13.string().optional(),
+  customCondensingPrompt: z13.string().optional(),
+  autoApprovalEnabled: z13.boolean().optional(),
+  alwaysAllowReadOnly: z13.boolean().optional(),
+  alwaysAllowReadOnlyOutsideWorkspace: z13.boolean().optional(),
+  alwaysAllowWrite: z13.boolean().optional(),
+  alwaysAllowWriteOutsideWorkspace: z13.boolean().optional(),
+  alwaysAllowWriteProtected: z13.boolean().optional(),
+  writeDelayMs: z13.number().min(0).optional(),
+  alwaysAllowBrowser: z13.boolean().optional(),
+  alwaysApproveResubmit: z13.boolean().optional(),
+  requestDelaySeconds: z13.number().optional(),
+  alwaysAllowMcp: z13.boolean().optional(),
+  alwaysAllowModeSwitch: z13.boolean().optional(),
+  alwaysAllowSubtasks: z13.boolean().optional(),
+  alwaysAllowExecute: z13.boolean().optional(),
+  alwaysAllowFollowupQuestions: z13.boolean().optional(),
+  followupAutoApproveTimeoutMs: z13.number().optional(),
+  alwaysAllowUpdateTodoList: z13.boolean().optional(),
+  allowedCommands: z13.array(z13.string()).optional(),
+  deniedCommands: z13.array(z13.string()).optional(),
+  commandExecutionTimeout: z13.number().optional(),
+  commandTimeoutAllowlist: z13.array(z13.string()).optional(),
+  preventCompletionWithOpenTodos: z13.boolean().optional(),
+  allowedMaxRequests: z13.number().nullish(),
+  allowedMaxCost: z13.number().nullish(),
+  autoCondenseContext: z13.boolean().optional(),
+  autoCondenseContextPercent: z13.number().optional(),
+  maxConcurrentFileReads: z13.number().optional(),
   /**
    * Whether to include diagnostic messages (errors, warnings) in tool outputs
    * @default true
    */
-  includeDiagnosticMessages: z11.boolean().optional(),
+  includeDiagnosticMessages: z13.boolean().optional(),
   /**
    * Maximum number of diagnostic messages to include in tool outputs
    * @default 50
    */
-  maxDiagnosticMessages: z11.number().optional(),
-  browserToolEnabled: z11.boolean().optional(),
-  browserViewportSize: z11.string().optional(),
-  screenshotQuality: z11.number().optional(),
-  remoteBrowserEnabled: z11.boolean().optional(),
-  remoteBrowserHost: z11.string().optional(),
-  cachedChromeHostUrl: z11.string().optional(),
-  enableCheckpoints: z11.boolean().optional(),
-  ttsEnabled: z11.boolean().optional(),
-  ttsSpeed: z11.number().optional(),
-  soundEnabled: z11.boolean().optional(),
-  soundVolume: z11.number().optional(),
-  maxOpenTabsContext: z11.number().optional(),
-  maxWorkspaceFiles: z11.number().optional(),
-  showRooIgnoredFiles: z11.boolean().optional(),
-  maxReadFileLine: z11.number().optional(),
-  maxImageFileSize: z11.number().optional(),
-  maxTotalImageSize: z11.number().optional(),
-  terminalOutputLineLimit: z11.number().optional(),
-  terminalOutputCharacterLimit: z11.number().optional(),
-  terminalShellIntegrationTimeout: z11.number().optional(),
-  terminalShellIntegrationDisabled: z11.boolean().optional(),
-  terminalCommandDelay: z11.number().optional(),
-  terminalPowershellCounter: z11.boolean().optional(),
-  terminalZshClearEolMark: z11.boolean().optional(),
-  terminalZshOhMy: z11.boolean().optional(),
-  terminalZshP10k: z11.boolean().optional(),
-  terminalZdotdir: z11.boolean().optional(),
-  terminalCompressProgressBar: z11.boolean().optional(),
-  diagnosticsEnabled: z11.boolean().optional(),
-  rateLimitSeconds: z11.number().optional(),
-  diffEnabled: z11.boolean().optional(),
-  fuzzyMatchThreshold: z11.number().optional(),
+  maxDiagnosticMessages: z13.number().optional(),
+  browserToolEnabled: z13.boolean().optional(),
+  browserViewportSize: z13.string().optional(),
+  screenshotQuality: z13.number().optional(),
+  remoteBrowserEnabled: z13.boolean().optional(),
+  remoteBrowserHost: z13.string().optional(),
+  cachedChromeHostUrl: z13.string().optional(),
+  enableCheckpoints: z13.boolean().optional(),
+  ttsEnabled: z13.boolean().optional(),
+  ttsSpeed: z13.number().optional(),
+  soundEnabled: z13.boolean().optional(),
+  soundVolume: z13.number().optional(),
+  maxOpenTabsContext: z13.number().optional(),
+  maxWorkspaceFiles: z13.number().optional(),
+  showRooIgnoredFiles: z13.boolean().optional(),
+  maxReadFileLine: z13.number().optional(),
+  maxImageFileSize: z13.number().optional(),
+  maxTotalImageSize: z13.number().optional(),
+  terminalOutputLineLimit: z13.number().optional(),
+  terminalOutputCharacterLimit: z13.number().optional(),
+  terminalShellIntegrationTimeout: z13.number().optional(),
+  terminalShellIntegrationDisabled: z13.boolean().optional(),
+  terminalCommandDelay: z13.number().optional(),
+  terminalPowershellCounter: z13.boolean().optional(),
+  terminalZshClearEolMark: z13.boolean().optional(),
+  terminalZshOhMy: z13.boolean().optional(),
+  terminalZshP10k: z13.boolean().optional(),
+  terminalZdotdir: z13.boolean().optional(),
+  terminalCompressProgressBar: z13.boolean().optional(),
+  diagnosticsEnabled: z13.boolean().optional(),
+  rateLimitSeconds: z13.number().optional(),
+  diffEnabled: z13.boolean().optional(),
+  fuzzyMatchThreshold: z13.number().optional(),
   experiments: experimentsSchema.optional(),
   codebaseIndexModels: codebaseIndexModelsSchema.optional(),
   codebaseIndexConfig: codebaseIndexConfigSchema.optional(),
   language: languagesSchema.optional(),
   telemetrySetting: telemetrySettingsSchema.optional(),
-  mcpEnabled: z11.boolean().optional(),
-  enableMcpServerCreation: z11.boolean().optional(),
-  remoteControlEnabled: z11.boolean().optional(),
-  mode: z11.string().optional(),
-  modeApiConfigs: z11.record(z11.string(), z11.string()).optional(),
-  customModes: z11.array(modeConfigSchema).optional(),
+  mcpEnabled: z13.boolean().optional(),
+  enableMcpServerCreation: z13.boolean().optional(),
+  remoteControlEnabled: z13.boolean().optional(),
+  mode: z13.string().optional(),
+  modeApiConfigs: z13.record(z13.string(), z13.string()).optional(),
+  customModes: z13.array(modeConfigSchema).optional(),
   customModePrompts: customModePromptsSchema.optional(),
   customSupportPrompts: customSupportPromptsSchema.optional(),
-  enhancementApiConfigId: z11.string().optional(),
-  includeTaskHistoryInEnhance: z11.boolean().optional(),
-  historyPreviewCollapsed: z11.boolean().optional(),
-  profileThresholds: z11.record(z11.string(), z11.number()).optional(),
-  hasOpenedModeSelector: z11.boolean().optional(),
-  lastModeExportPath: z11.string().optional(),
-  lastModeImportPath: z11.string().optional()
+  enhancementApiConfigId: z13.string().optional(),
+  includeTaskHistoryInEnhance: z13.boolean().optional(),
+  historyPreviewCollapsed: z13.boolean().optional(),
+  profileThresholds: z13.record(z13.string(), z13.number()).optional(),
+  hasOpenedModeSelector: z13.boolean().optional(),
+  lastModeExportPath: z13.string().optional(),
+  lastModeImportPath: z13.string().optional()
 });
 var GLOBAL_SETTINGS_KEYS = globalSettingsSchema.keyof().options;
 var rooCodeSettingsSchema = providerSettingsSchema.merge(globalSettingsSchema);
@@ -1006,7 +1179,8 @@ var SECRET_STATE_KEYS = [
   "codebaseIndexMistralApiKey",
   "huggingFaceApiKey",
   "sambaNovaApiKey",
-  "fireworksApiKey"
+  "fireworksApiKey",
+  "ioIntelligenceApiKey"
 ];
 var isSecretStateKey = (key) => SECRET_STATE_KEYS.includes(key);
 var GLOBAL_STATE_KEYS = [...GLOBAL_SETTINGS_KEYS, ...PROVIDER_SETTINGS_KEYS].filter(
@@ -1080,294 +1254,8 @@ var EVALS_SETTINGS = {
 };
 var EVALS_TIMEOUT = 5 * 60 * 1e3;
 
-// src/marketplace.ts
-import { z as z12 } from "zod";
-var mcpParameterSchema = z12.object({
-  name: z12.string().min(1),
-  key: z12.string().min(1),
-  placeholder: z12.string().optional(),
-  optional: z12.boolean().optional().default(false)
-});
-var mcpInstallationMethodSchema = z12.object({
-  name: z12.string().min(1),
-  content: z12.string().min(1),
-  parameters: z12.array(mcpParameterSchema).optional(),
-  prerequisites: z12.array(z12.string()).optional()
-});
-var marketplaceItemTypeSchema = z12.enum(["mode", "mcp"]);
-var baseMarketplaceItemSchema = z12.object({
-  id: z12.string().min(1),
-  name: z12.string().min(1, "Name is required"),
-  description: z12.string(),
-  author: z12.string().optional(),
-  authorUrl: z12.string().url("Author URL must be a valid URL").optional(),
-  tags: z12.array(z12.string()).optional(),
-  prerequisites: z12.array(z12.string()).optional()
-});
-var modeMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
-  content: z12.string().min(1)
-  // YAML content for modes
-});
-var mcpMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
-  url: z12.string().url(),
-  // Required url field
-  content: z12.union([z12.string().min(1), z12.array(mcpInstallationMethodSchema)]),
-  // Single config or array of methods
-  parameters: z12.array(mcpParameterSchema).optional()
-});
-var marketplaceItemSchema = z12.discriminatedUnion("type", [
-  // Mode marketplace item
-  modeMarketplaceItemSchema.extend({
-    type: z12.literal("mode")
-  }),
-  // MCP marketplace item
-  mcpMarketplaceItemSchema.extend({
-    type: z12.literal("mcp")
-  })
-]);
-var installMarketplaceItemOptionsSchema = z12.object({
-  target: z12.enum(["global", "project"]).optional().default("project"),
-  parameters: z12.record(z12.string(), z12.any()).optional()
-});
-
-// src/cloud.ts
-var organizationAllowListSchema = z13.object({
-  allowAll: z13.boolean(),
-  providers: z13.record(
-    z13.object({
-      allowAll: z13.boolean(),
-      models: z13.array(z13.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(
-  z13.object({
-    maxOpenTabsContext: z13.number().int().nonnegative().optional(),
-    maxReadFileLine: z13.number().int().gte(-1).optional(),
-    maxWorkspaceFiles: z13.number().int().nonnegative().optional(),
-    terminalCommandDelay: z13.number().int().nonnegative().optional(),
-    terminalOutputLineLimit: z13.number().int().nonnegative().optional(),
-    terminalShellIntegrationTimeout: z13.number().int().nonnegative().optional()
-  })
-);
-var organizationCloudSettingsSchema = z13.object({
-  recordTaskMessages: z13.boolean().optional(),
-  enableTaskSharing: z13.boolean().optional(),
-  taskShareExpirationDays: z13.number().int().positive().optional(),
-  allowMembersViewAllTasks: z13.boolean().optional()
-});
-var organizationSettingsSchema = z13.object({
-  version: z13.number(),
-  cloudSettings: organizationCloudSettingsSchema.optional(),
-  defaultSettings: organizationDefaultSettingsSchema,
-  allowList: organizationAllowListSchema,
-  hiddenMcps: z13.array(z13.string()).optional(),
-  hideMarketplaceMcps: z13.boolean().optional(),
-  mcps: z13.array(mcpMarketplaceItemSchema).optional(),
-  providerProfiles: z13.record(z13.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 = z13.object({
-  success: z13.boolean(),
-  shareUrl: z13.string().optional(),
-  error: z13.string().optional(),
-  isNewShare: z13.boolean().optional(),
-  manageUrl: z13.string().optional()
-});
-
-// src/events.ts
-import { z as z14 } from "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 = z14.object({
-  ["taskCreated" /* TaskCreated */]: z14.tuple([z14.string()]),
-  ["taskStarted" /* TaskStarted */]: z14.tuple([z14.string()]),
-  ["taskCompleted" /* TaskCompleted */]: z14.tuple([
-    z14.string(),
-    tokenUsageSchema,
-    toolUsageSchema,
-    z14.object({
-      isSubtask: z14.boolean()
-    })
-  ]),
-  ["taskAborted" /* TaskAborted */]: z14.tuple([z14.string()]),
-  ["taskFocused" /* TaskFocused */]: z14.tuple([z14.string()]),
-  ["taskUnfocused" /* TaskUnfocused */]: z14.tuple([z14.string()]),
-  ["taskActive" /* TaskActive */]: z14.tuple([z14.string()]),
-  ["taskIdle" /* TaskIdle */]: z14.tuple([z14.string()]),
-  ["taskPaused" /* TaskPaused */]: z14.tuple([z14.string()]),
-  ["taskUnpaused" /* TaskUnpaused */]: z14.tuple([z14.string()]),
-  ["taskSpawned" /* TaskSpawned */]: z14.tuple([z14.string(), z14.string()]),
-  ["message" /* Message */]: z14.tuple([
-    z14.object({
-      taskId: z14.string(),
-      action: z14.union([z14.literal("created"), z14.literal("updated")]),
-      message: clineMessageSchema
-    })
-  ]),
-  ["taskModeSwitched" /* TaskModeSwitched */]: z14.tuple([z14.string(), z14.string()]),
-  ["taskAskResponded" /* TaskAskResponded */]: z14.tuple([z14.string()]),
-  ["taskToolFailed" /* TaskToolFailed */]: z14.tuple([z14.string(), toolNamesSchema, z14.string()]),
-  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z14.tuple([z14.string(), tokenUsageSchema])
-});
-var taskEventSchema = z14.discriminatedUnion("eventName", [
-  // Task Provider Lifecycle
-  z14.object({
-    eventName: z14.literal("taskCreated" /* TaskCreated */),
-    payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
-    taskId: z14.number().optional()
-  }),
-  // Task Lifecycle
-  z14.object({
-    eventName: z14.literal("taskStarted" /* TaskStarted */),
-    payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskCompleted" /* TaskCompleted */),
-    payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskAborted" /* TaskAborted */),
-    payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskFocused" /* TaskFocused */),
-    payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskUnfocused" /* TaskUnfocused */),
-    payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskActive" /* TaskActive */),
-    payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskIdle" /* TaskIdle */),
-    payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
-    taskId: z14.number().optional()
-  }),
-  // Subtask Lifecycle
-  z14.object({
-    eventName: z14.literal("taskPaused" /* TaskPaused */),
-    payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskUnpaused" /* TaskUnpaused */),
-    payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskSpawned" /* TaskSpawned */),
-    payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
-    taskId: z14.number().optional()
-  }),
-  // Task Execution
-  z14.object({
-    eventName: z14.literal("message" /* Message */),
-    payload: rooCodeEventsSchema.shape["message" /* Message */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskModeSwitched" /* TaskModeSwitched */),
-    payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskAskResponded" /* TaskAskResponded */),
-    payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
-    taskId: z14.number().optional()
-  }),
-  // Task Analytics
-  z14.object({
-    eventName: z14.literal("taskToolFailed" /* TaskToolFailed */),
-    payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
-    taskId: z14.number().optional()
-  }),
-  z14.object({
-    eventName: z14.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
-    payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
-    taskId: z14.number().optional()
-  }),
-  // Evals
-  z14.object({
-    eventName: z14.literal("evalPass" /* EvalPass */),
-    payload: z14.undefined(),
-    taskId: z14.number()
-  }),
-  z14.object({
-    eventName: z14.literal("evalFail" /* EvalFail */),
-    payload: z14.undefined(),
-    taskId: z14.number()
-  })
-]);
-
-// src/followup.ts
-import { z as z15 } from "zod";
-var suggestionItemSchema = z15.object({
-  answer: z15.string(),
-  mode: z15.string().optional()
-});
-var followUpDataSchema = z15.object({
-  question: z15.string().optional(),
-  suggest: z15.array(suggestionItemSchema).optional()
-});
-
 // src/ipc.ts
-import { z as z16 } from "zod";
+import { z as z14 } from "zod";
 var IpcMessageType = /* @__PURE__ */ ((IpcMessageType2) => {
   IpcMessageType2["Connect"] = "Connect";
   IpcMessageType2["Disconnect"] = "Disconnect";
@@ -1381,10 +1269,10 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
   IpcOrigin2["Server"] = "server";
   return IpcOrigin2;
 })(IpcOrigin || {});
-var ackSchema = z16.object({
-  clientId: z16.string(),
-  pid: z16.number(),
-  ppid: z16.number()
+var ackSchema = z14.object({
+  clientId: z14.string(),
+  pid: z14.number(),
+  ppid: z14.number()
 });
 var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -1392,106 +1280,156 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["CloseTask"] = "CloseTask";
   return TaskCommandName2;
 })(TaskCommandName || {});
-var taskCommandSchema = z16.discriminatedUnion("commandName", [
-  z16.object({
-    commandName: z16.literal("StartNewTask" /* StartNewTask */),
-    data: z16.object({
+var taskCommandSchema = z14.discriminatedUnion("commandName", [
+  z14.object({
+    commandName: z14.literal("StartNewTask" /* StartNewTask */),
+    data: z14.object({
       configuration: rooCodeSettingsSchema,
-      text: z16.string(),
-      images: z16.array(z16.string()).optional(),
-      newTab: z16.boolean().optional()
+      text: z14.string(),
+      images: z14.array(z14.string()).optional(),
+      newTab: z14.boolean().optional()
     })
   }),
-  z16.object({
-    commandName: z16.literal("CancelTask" /* CancelTask */),
-    data: z16.string()
+  z14.object({
+    commandName: z14.literal("CancelTask" /* CancelTask */),
+    data: z14.string()
   }),
-  z16.object({
-    commandName: z16.literal("CloseTask" /* CloseTask */),
-    data: z16.string()
+  z14.object({
+    commandName: z14.literal("CloseTask" /* CloseTask */),
+    data: z14.string()
   })
 ]);
-var ipcMessageSchema = z16.discriminatedUnion("type", [
-  z16.object({
-    type: z16.literal("Ack" /* Ack */),
-    origin: z16.literal("server" /* Server */),
+var ipcMessageSchema = z14.discriminatedUnion("type", [
+  z14.object({
+    type: z14.literal("Ack" /* Ack */),
+    origin: z14.literal("server" /* Server */),
     data: ackSchema
   }),
-  z16.object({
-    type: z16.literal("TaskCommand" /* TaskCommand */),
-    origin: z16.literal("client" /* Client */),
-    clientId: z16.string(),
+  z14.object({
+    type: z14.literal("TaskCommand" /* TaskCommand */),
+    origin: z14.literal("client" /* Client */),
+    clientId: z14.string(),
     data: taskCommandSchema
   }),
-  z16.object({
-    type: z16.literal("TaskEvent" /* TaskEvent */),
-    origin: z16.literal("server" /* Server */),
-    relayClientId: z16.string().optional(),
+  z14.object({
+    type: z14.literal("TaskEvent" /* TaskEvent */),
+    origin: z14.literal("server" /* Server */),
+    relayClientId: z14.string().optional(),
     data: taskEventSchema
   })
 ]);
 
+// src/marketplace.ts
+import { z as z15 } from "zod";
+var mcpParameterSchema = z15.object({
+  name: z15.string().min(1),
+  key: z15.string().min(1),
+  placeholder: z15.string().optional(),
+  optional: z15.boolean().optional().default(false)
+});
+var mcpInstallationMethodSchema = z15.object({
+  name: z15.string().min(1),
+  content: z15.string().min(1),
+  parameters: z15.array(mcpParameterSchema).optional(),
+  prerequisites: z15.array(z15.string()).optional()
+});
+var marketplaceItemTypeSchema = z15.enum(["mode", "mcp"]);
+var baseMarketplaceItemSchema = z15.object({
+  id: z15.string().min(1),
+  name: z15.string().min(1, "Name is required"),
+  description: z15.string(),
+  author: z15.string().optional(),
+  authorUrl: z15.string().url("Author URL must be a valid URL").optional(),
+  tags: z15.array(z15.string()).optional(),
+  prerequisites: z15.array(z15.string()).optional()
+});
+var modeMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  content: z15.string().min(1)
+  // YAML content for modes
+});
+var mcpMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  url: z15.string().url(),
+  // Required url field
+  content: z15.union([z15.string().min(1), z15.array(mcpInstallationMethodSchema)]),
+  // Single config or array of methods
+  parameters: z15.array(mcpParameterSchema).optional()
+});
+var marketplaceItemSchema = z15.discriminatedUnion("type", [
+  // Mode marketplace item
+  modeMarketplaceItemSchema.extend({
+    type: z15.literal("mode")
+  }),
+  // MCP marketplace item
+  mcpMarketplaceItemSchema.extend({
+    type: z15.literal("mcp")
+  })
+]);
+var installMarketplaceItemOptionsSchema = z15.object({
+  target: z15.enum(["global", "project"]).optional().default("project"),
+  parameters: z15.record(z15.string(), z15.any()).optional()
+});
+
 // src/mcp.ts
-import { z as z17 } from "zod";
-var mcpExecutionStatusSchema = z17.discriminatedUnion("status", [
-  z17.object({
-    executionId: z17.string(),
-    status: z17.literal("started"),
-    serverName: z17.string(),
-    toolName: z17.string()
+import { z as z16 } from "zod";
+var mcpExecutionStatusSchema = z16.discriminatedUnion("status", [
+  z16.object({
+    executionId: z16.string(),
+    status: z16.literal("started"),
+    serverName: z16.string(),
+    toolName: z16.string()
   }),
-  z17.object({
-    executionId: z17.string(),
-    status: z17.literal("output"),
-    response: z17.string()
+  z16.object({
+    executionId: z16.string(),
+    status: z16.literal("output"),
+    response: z16.string()
   }),
-  z17.object({
-    executionId: z17.string(),
-    status: z17.literal("completed"),
-    response: z17.string().optional()
+  z16.object({
+    executionId: z16.string(),
+    status: z16.literal("completed"),
+    response: z16.string().optional()
   }),
-  z17.object({
-    executionId: z17.string(),
-    status: z17.literal("error"),
-    error: z17.string().optional()
+  z16.object({
+    executionId: z16.string(),
+    status: z16.literal("error"),
+    error: z16.string().optional()
   })
 ]);
 
 // src/todo.ts
-import { z as z18 } from "zod";
-var todoStatusSchema = z18.enum(["pending", "in_progress", "completed"]);
-var todoItemSchema = z18.object({
-  id: z18.string(),
-  content: z18.string(),
+import { z as z17 } from "zod";
+var todoStatusSchema = z17.enum(["pending", "in_progress", "completed"]);
+var todoItemSchema = z17.object({
+  id: z17.string(),
+  content: z17.string(),
   status: todoStatusSchema
 });
 
 // src/terminal.ts
-import { z as z19 } from "zod";
-var commandExecutionStatusSchema = z19.discriminatedUnion("status", [
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("started"),
-    pid: z19.number().optional(),
-    command: z19.string()
+import { z as z18 } from "zod";
+var commandExecutionStatusSchema = z18.discriminatedUnion("status", [
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("started"),
+    pid: z18.number().optional(),
+    command: z18.string()
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("output"),
-    output: z19.string()
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("output"),
+    output: z18.string()
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("exited"),
-    exitCode: z19.number().optional()
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("exited"),
+    exitCode: z18.number().optional()
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("fallback")
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("fallback")
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("timeout")
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("timeout")
   })
 ]);
 
@@ -1502,18 +1440,34 @@ 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
+    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,
@@ -1850,6 +1804,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,
@@ -2339,6 +2313,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."
   }
 };
 
@@ -2875,6 +2867,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 = {
@@ -3245,15 +3272,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,
@@ -3271,6 +3289,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 = {
@@ -4260,6 +4288,7 @@ export {
   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,
@@ -4287,6 +4316,7 @@ export {
   HUGGINGFACE_SLIDER_MIN,
   HUGGINGFACE_SLIDER_STEP,
   HUGGINGFACE_TEMPERATURE_MAX_VALUE,
+  IO_INTELLIGENCE_CACHE_DURATION,
   IpcMessageType,
   IpcOrigin,
   LITELLM_COMPUTER_USE_MODELS,
@@ -4301,8 +4331,6 @@ export {
   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,
@@ -4371,6 +4399,9 @@ export {
   installMarketplaceItemOptionsSchema,
   internationalZAiDefaultModelId,
   internationalZAiModels,
+  ioIntelligenceDefaultBaseUrl,
+  ioIntelligenceDefaultModelId,
+  ioIntelligenceModels,
   ipcMessageSchema,
   isBlockingAsk,
   isGlobalStateKey,
@@ -4407,10 +4438,6 @@ export {
   openAiNativeModels,
   openRouterDefaultModelId,
   openRouterDefaultModelInfo,
-  organizationAllowListSchema,
-  organizationCloudSettingsSchema,
-  organizationDefaultSettingsSchema,
-  organizationSettingsSchema,
   promptComponentSchema,
   providerNames,
   providerNamesSchema,
@@ -4427,7 +4454,6 @@ export {
   rooCodeTelemetryEventSchema,
   sambaNovaDefaultModelId,
   sambaNovaModels,
-  shareResponseSchema,
   suggestionItemSchema,
   taskCommandSchema,
   taskEventSchema,