@roo-code/types 1.63.0 → 1.64.0

package/dist/index.cjs

@@ -30,6 +30,7 @@ __export(index_exports, {
   BEDROCK_REGIONS: () => BEDROCK_REGIONS,
   CLAUDE_CODE_DEFAULT_MAX_OUTPUT_TOKENS: () => CLAUDE_CODE_DEFAULT_MAX_OUTPUT_TOKENS,
   CODEBASE_INDEX_DEFAULTS: () => CODEBASE_INDEX_DEFAULTS,
+  ConnectionState: () => ConnectionState,
   DEEP_SEEK_DEFAULT_TEMPERATURE: () => DEEP_SEEK_DEFAULT_TEMPERATURE,
   DEFAULT_CONSECUTIVE_MISTAKE_LIMIT: () => DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
   DEFAULT_MODES: () => DEFAULT_MODES,
@@ -39,10 +40,14 @@ __export(index_exports, {
   DOUBAO_API_CHAT_PATH: () => DOUBAO_API_CHAT_PATH,
   EVALS_SETTINGS: () => EVALS_SETTINGS,
   EVALS_TIMEOUT: () => EVALS_TIMEOUT,
+  ExtensionBridgeCommandName: () => ExtensionBridgeCommandName,
+  ExtensionBridgeEventName: () => ExtensionBridgeEventName,
+  ExtensionSocketEvents: () => ExtensionSocketEvents,
   GLAMA_DEFAULT_TEMPERATURE: () => GLAMA_DEFAULT_TEMPERATURE,
   GLOBAL_SETTINGS_KEYS: () => GLOBAL_SETTINGS_KEYS,
   GLOBAL_STATE_KEYS: () => GLOBAL_STATE_KEYS,
   GPT5_DEFAULT_TEMPERATURE: () => GPT5_DEFAULT_TEMPERATURE,
+  HEARTBEAT_INTERVAL_MS: () => HEARTBEAT_INTERVAL_MS,
   HUGGINGFACE_API_URL: () => HUGGINGFACE_API_URL,
   HUGGINGFACE_CACHE_DURATION: () => HUGGINGFACE_CACHE_DURATION,
   HUGGINGFACE_DEFAULT_CONTEXT_WINDOW: () => HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
@@ -51,6 +56,7 @@ __export(index_exports, {
   HUGGINGFACE_SLIDER_MIN: () => HUGGINGFACE_SLIDER_MIN,
   HUGGINGFACE_SLIDER_STEP: () => HUGGINGFACE_SLIDER_STEP,
   HUGGINGFACE_TEMPERATURE_MAX_VALUE: () => HUGGINGFACE_TEMPERATURE_MAX_VALUE,
+  INSTANCE_TTL_SECONDS: () => INSTANCE_TTL_SECONDS,
   IO_INTELLIGENCE_CACHE_DURATION: () => IO_INTELLIGENCE_CACHE_DURATION,
   IpcMessageType: () => IpcMessageType,
   IpcOrigin: () => IpcOrigin,
@@ -67,10 +73,15 @@ __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,
+  TaskBridgeCommandName: () => TaskBridgeCommandName,
+  TaskBridgeEventName: () => TaskBridgeEventName,
   TaskCommandName: () => TaskCommandName,
+  TaskSocketEvents: () => TaskSocketEvents,
   TaskStatus: () => TaskStatus,
   TelemetryEventName: () => TelemetryEventName,
   VERCEL_AI_GATEWAY_DEFAULT_TEMPERATURE: () => VERCEL_AI_GATEWAY_DEFAULT_TEMPERATURE,
@@ -121,6 +132,9 @@ __export(index_exports, {
   experimentIds: () => experimentIds,
   experimentIdsSchema: () => experimentIdsSchema,
   experimentsSchema: () => experimentsSchema,
+  extensionBridgeCommandSchema: () => extensionBridgeCommandSchema,
+  extensionBridgeEventSchema: () => extensionBridgeEventSchema,
+  extensionInstanceSchema: () => extensionInstanceSchema,
   featherlessDefaultModelId: () => featherlessDefaultModelId,
   featherlessModels: () => featherlessModels,
   fireworksDefaultModelId: () => fireworksDefaultModelId,
@@ -187,6 +201,10 @@ __export(index_exports, {
   openAiNativeModels: () => openAiNativeModels,
   openRouterDefaultModelId: () => openRouterDefaultModelId,
   openRouterDefaultModelInfo: () => openRouterDefaultModelInfo,
+  organizationAllowListSchema: () => organizationAllowListSchema,
+  organizationCloudSettingsSchema: () => organizationCloudSettingsSchema,
+  organizationDefaultSettingsSchema: () => organizationDefaultSettingsSchema,
+  organizationSettingsSchema: () => organizationSettingsSchema,
   promptComponentSchema: () => promptComponentSchema,
   providerNames: () => providerNames,
   providerNamesSchema: () => providerNamesSchema,
@@ -209,9 +227,12 @@ __export(index_exports, {
   rooModels: () => rooModels,
   sambaNovaDefaultModelId: () => sambaNovaDefaultModelId,
   sambaNovaModels: () => sambaNovaModels,
+  shareResponseSchema: () => shareResponseSchema,
   shouldUseSingleFileRead: () => shouldUseSingleFileRead,
   staticAppPropertiesSchema: () => staticAppPropertiesSchema,
   suggestionItemSchema: () => suggestionItemSchema,
+  taskBridgeCommandSchema: () => taskBridgeCommandSchema,
+  taskBridgeEventSchema: () => taskBridgeEventSchema,
   taskCommandSchema: () => taskCommandSchema,
   taskEventSchema: () => taskEventSchema,
   taskMetadataSchema: () => taskMetadataSchema,
@@ -231,6 +252,9 @@ __export(index_exports, {
   toolUsageSchema: () => toolUsageSchema,
   unboundDefaultModelId: () => unboundDefaultModelId,
   unboundDefaultModelInfo: () => unboundDefaultModelInfo,
+  userFeaturesSchema: () => userFeaturesSchema,
+  userSettingsConfigSchema: () => userSettingsConfigSchema,
+  userSettingsDataSchema: () => userSettingsDataSchema,
   verbosityLevels: () => verbosityLevels,
   verbosityLevelsSchema: () => verbosityLevelsSchema,
   vercelAiGatewayDefaultModelId: () => vercelAiGatewayDefaultModelId,
@@ -244,55 +268,14 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/codebase-index.ts
-var import_zod = require("zod");
-var CODEBASE_INDEX_DEFAULTS = {
-  MIN_SEARCH_RESULTS: 10,
-  MAX_SEARCH_RESULTS: 200,
-  DEFAULT_SEARCH_RESULTS: 50,
-  SEARCH_RESULTS_STEP: 10,
-  MIN_SEARCH_SCORE: 0,
-  MAX_SEARCH_SCORE: 1,
-  DEFAULT_SEARCH_MIN_SCORE: 0.4,
-  SEARCH_SCORE_STEP: 0.05
-};
-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", "vercel-ai-gateway"]).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_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(),
-  "vercel-ai-gateway": 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(),
-  codebaseIndexVercelAiGatewayApiKey: import_zod.z.string().optional()
-});
+// src/cloud.ts
+var import_zod15 = require("zod");
 
 // src/events.ts
-var import_zod4 = require("zod");
+var import_zod3 = require("zod");
 
 // src/message.ts
-var import_zod2 = require("zod");
+var import_zod = require("zod");
 var clineAsks = [
   "followup",
   "command",
@@ -307,7 +290,7 @@ var clineAsks = [
   "use_mcp_server",
   "auto_approval_max_req_reached"
 ];
-var clineAskSchema = import_zod2.z.enum(clineAsks);
+var clineAskSchema = import_zod.z.enum(clineAsks);
 var idleAsks = [
   "completion_result",
   "api_req_failed",
@@ -358,53 +341,53 @@ var clineSays = [
   "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 clineSaySchema = import_zod.z.enum(clineSays);
+var toolProgressStatusSchema = import_zod.z.object({
+  icon: import_zod.z.string().optional(),
+  text: import_zod.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 contextCondenseSchema = import_zod.z.object({
+  cost: import_zod.z.number(),
+  prevContextTokens: import_zod.z.number(),
+  newContextTokens: import_zod.z.number(),
+  summary: import_zod.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")]),
+var clineMessageSchema = import_zod.z.object({
+  ts: import_zod.z.number(),
+  type: import_zod.z.union([import_zod.z.literal("ask"), import_zod.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(),
+  text: import_zod.z.string().optional(),
+  images: import_zod.z.array(import_zod.z.string()).optional(),
+  partial: import_zod.z.boolean().optional(),
+  reasoning: import_zod.z.string().optional(),
+  conversationHistoryIndex: import_zod.z.number().optional(),
+  checkpoint: import_zod.z.record(import_zod.z.string(), import_zod.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()
+  isProtected: import_zod.z.boolean().optional(),
+  apiProtocol: import_zod.z.union([import_zod.z.literal("openai"), import_zod.z.literal("anthropic")]).optional(),
+  metadata: import_zod.z.object({
+    gpt5: import_zod.z.object({
+      previous_response_id: import_zod.z.string().optional(),
+      instructions: import_zod.z.string().optional(),
+      reasoning_summary: import_zod.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()
+var tokenUsageSchema = import_zod.z.object({
+  totalTokensIn: import_zod.z.number(),
+  totalTokensOut: import_zod.z.number(),
+  totalCacheWrites: import_zod.z.number().optional(),
+  totalCacheReads: import_zod.z.number().optional(),
+  totalCost: import_zod.z.number(),
+  contextTokens: import_zod.z.number()
 });
 
 // src/tool.ts
-var import_zod3 = require("zod");
+var import_zod2 = require("zod");
 var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
-var toolGroupsSchema = import_zod3.z.enum(toolGroups);
+var toolGroupsSchema = import_zod2.z.enum(toolGroups);
 var toolNames = [
   "execute_command",
   "read_file",
@@ -427,12 +410,12 @@ var toolNames = [
   "update_todo_list",
   "generate_image"
 ];
-var toolNamesSchema = import_zod3.z.enum(toolNames);
-var toolUsageSchema = import_zod3.z.record(
+var toolNamesSchema = import_zod2.z.enum(toolNames);
+var toolUsageSchema = import_zod2.z.record(
   toolNamesSchema,
-  import_zod3.z.object({
-    attempts: import_zod3.z.number(),
-    failures: import_zod3.z.number()
+  import_zod2.z.object({
+    attempts: import_zod2.z.number(),
+    failures: import_zod2.z.number()
   })
 );
 
@@ -460,226 +443,258 @@ var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
   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(),
+var rooCodeEventsSchema = import_zod3.z.object({
+  ["taskCreated" /* TaskCreated */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskStarted" /* TaskStarted */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskCompleted" /* TaskCompleted */]: import_zod3.z.tuple([
+    import_zod3.z.string(),
     tokenUsageSchema,
     toolUsageSchema,
-    import_zod4.z.object({
-      isSubtask: import_zod4.z.boolean()
+    import_zod3.z.object({
+      isSubtask: import_zod3.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()]),
-  ["taskInteractive" /* TaskInteractive */]: import_zod4.z.tuple([import_zod4.z.string()]),
-  ["taskResumable" /* TaskResumable */]: 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")]),
+  ["taskAborted" /* TaskAborted */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskFocused" /* TaskFocused */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskUnfocused" /* TaskUnfocused */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskActive" /* TaskActive */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskInteractive" /* TaskInteractive */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskResumable" /* TaskResumable */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskIdle" /* TaskIdle */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskPaused" /* TaskPaused */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskUnpaused" /* TaskUnpaused */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskSpawned" /* TaskSpawned */]: import_zod3.z.tuple([import_zod3.z.string(), import_zod3.z.string()]),
+  ["message" /* Message */]: import_zod3.z.tuple([
+    import_zod3.z.object({
+      taskId: import_zod3.z.string(),
+      action: import_zod3.z.union([import_zod3.z.literal("created"), import_zod3.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])
+  ["taskModeSwitched" /* TaskModeSwitched */]: import_zod3.z.tuple([import_zod3.z.string(), import_zod3.z.string()]),
+  ["taskAskResponded" /* TaskAskResponded */]: import_zod3.z.tuple([import_zod3.z.string()]),
+  ["taskToolFailed" /* TaskToolFailed */]: import_zod3.z.tuple([import_zod3.z.string(), toolNamesSchema, import_zod3.z.string()]),
+  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: import_zod3.z.tuple([import_zod3.z.string(), tokenUsageSchema])
 });
-var taskEventSchema = import_zod4.z.discriminatedUnion("eventName", [
+var taskEventSchema = import_zod3.z.discriminatedUnion("eventName", [
   // Task Provider Lifecycle
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskCreated" /* TaskCreated */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskCreated" /* TaskCreated */),
     payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
   // Task Lifecycle
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskStarted" /* TaskStarted */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskStarted" /* TaskStarted */),
     payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskCompleted" /* TaskCompleted */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskCompleted" /* TaskCompleted */),
     payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskAborted" /* TaskAborted */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskAborted" /* TaskAborted */),
     payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskFocused" /* TaskFocused */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskFocused" /* TaskFocused */),
     payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskUnfocused" /* TaskUnfocused */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskUnfocused" /* TaskUnfocused */),
     payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskActive" /* TaskActive */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskActive" /* TaskActive */),
     payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskInteractive" /* TaskInteractive */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskInteractive" /* TaskInteractive */),
     payload: rooCodeEventsSchema.shape["taskInteractive" /* TaskInteractive */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskResumable" /* TaskResumable */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskResumable" /* TaskResumable */),
     payload: rooCodeEventsSchema.shape["taskResumable" /* TaskResumable */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskIdle" /* TaskIdle */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskIdle" /* TaskIdle */),
     payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
   // Subtask Lifecycle
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskPaused" /* TaskPaused */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskPaused" /* TaskPaused */),
     payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskUnpaused" /* TaskUnpaused */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskUnpaused" /* TaskUnpaused */),
     payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskSpawned" /* TaskSpawned */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskSpawned" /* TaskSpawned */),
     payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
   // Task Execution
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("message" /* Message */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("message" /* Message */),
     payload: rooCodeEventsSchema.shape["message" /* Message */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskModeSwitched" /* TaskModeSwitched */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskModeSwitched" /* TaskModeSwitched */),
     payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskAskResponded" /* TaskAskResponded */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskAskResponded" /* TaskAskResponded */),
     payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
   // Task Analytics
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskToolFailed" /* TaskToolFailed */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskToolFailed" /* TaskToolFailed */),
     payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.z.number().optional()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
     payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
-    taskId: import_zod4.z.number().optional()
+    taskId: import_zod3.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_zod3.z.object({
+    eventName: import_zod3.z.literal("evalPass" /* EvalPass */),
+    payload: import_zod3.z.undefined(),
+    taskId: import_zod3.z.number()
   }),
-  import_zod4.z.object({
-    eventName: import_zod4.z.literal("evalFail" /* EvalFail */),
-    payload: import_zod4.z.undefined(),
-    taskId: import_zod4.z.number()
+  import_zod3.z.object({
+    eventName: import_zod3.z.literal("evalFail" /* EvalFail */),
+    payload: import_zod3.z.undefined(),
+    taskId: import_zod3.z.number()
   })
 ]);
 
-// src/experiment.ts
-var import_zod5 = require("zod");
-var experimentIds = [
-  "powerSteering",
-  "multiFileApplyDiff",
-  "preventFocusDisruption",
-  "imageGeneration"
-];
-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(),
-  imageGeneration: import_zod5.z.boolean().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/task.ts
+var import_zod4 = require("zod");
+var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
+  TaskStatus2["Running"] = "running";
+  TaskStatus2["Interactive"] = "interactive";
+  TaskStatus2["Resumable"] = "resumable";
+  TaskStatus2["Idle"] = "idle";
+  TaskStatus2["None"] = "none";
+  return TaskStatus2;
+})(TaskStatus || {});
+var taskMetadataSchema = import_zod4.z.object({
+  task: import_zod4.z.string().optional(),
+  images: import_zod4.z.array(import_zod4.z.string()).optional()
 });
 
 // src/global-settings.ts
 var import_zod13 = require("zod");
 
 // src/provider-settings.ts
-var import_zod8 = require("zod");
+var import_zod7 = require("zod");
 
 // src/model.ts
-var import_zod7 = require("zod");
+var import_zod5 = require("zod");
 var reasoningEfforts = ["low", "medium", "high"];
-var reasoningEffortsSchema = import_zod7.z.enum(reasoningEfforts);
-var reasoningEffortWithMinimalSchema = import_zod7.z.union([reasoningEffortsSchema, import_zod7.z.literal("minimal")]);
+var reasoningEffortsSchema = import_zod5.z.enum(reasoningEfforts);
+var reasoningEffortWithMinimalSchema = import_zod5.z.union([reasoningEffortsSchema, import_zod5.z.literal("minimal")]);
 var verbosityLevels = ["low", "medium", "high"];
-var verbosityLevelsSchema = import_zod7.z.enum(verbosityLevels);
+var verbosityLevelsSchema = import_zod5.z.enum(verbosityLevels);
 var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
-var modelParametersSchema = import_zod7.z.enum(modelParameters);
+var modelParametersSchema = import_zod5.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(),
+var modelInfoSchema = import_zod5.z.object({
+  maxTokens: import_zod5.z.number().nullish(),
+  maxThinkingTokens: import_zod5.z.number().nullish(),
+  contextWindow: import_zod5.z.number(),
+  supportsImages: import_zod5.z.boolean().optional(),
+  supportsComputerUse: import_zod5.z.boolean().optional(),
+  supportsPromptCache: import_zod5.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(),
+  supportsVerbosity: import_zod5.z.boolean().optional(),
+  supportsReasoningBudget: import_zod5.z.boolean().optional(),
   // Capability flag to indicate whether the model supports temperature parameter
-  supportsTemperature: 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(),
+  supportsTemperature: import_zod5.z.boolean().optional(),
+  requiredReasoningBudget: import_zod5.z.boolean().optional(),
+  supportsReasoningEffort: import_zod5.z.boolean().optional(),
+  supportedParameters: import_zod5.z.array(modelParametersSchema).optional(),
+  inputPrice: import_zod5.z.number().optional(),
+  outputPrice: import_zod5.z.number().optional(),
+  cacheWritesPrice: import_zod5.z.number().optional(),
+  cacheReadsPrice: import_zod5.z.number().optional(),
+  description: import_zod5.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()
+  minTokensPerCachePoint: import_zod5.z.number().optional(),
+  maxCachePoints: import_zod5.z.number().optional(),
+  cachableFields: import_zod5.z.array(import_zod5.z.string()).optional(),
+  tiers: import_zod5.z.array(
+    import_zod5.z.object({
+      contextWindow: import_zod5.z.number(),
+      inputPrice: import_zod5.z.number().optional(),
+      outputPrice: import_zod5.z.number().optional(),
+      cacheWritesPrice: import_zod5.z.number().optional(),
+      cacheReadsPrice: import_zod5.z.number().optional()
     })
   ).optional()
 });
 
+// src/codebase-index.ts
+var import_zod6 = require("zod");
+var CODEBASE_INDEX_DEFAULTS = {
+  MIN_SEARCH_RESULTS: 10,
+  MAX_SEARCH_RESULTS: 200,
+  DEFAULT_SEARCH_RESULTS: 50,
+  SEARCH_RESULTS_STEP: 10,
+  MIN_SEARCH_SCORE: 0,
+  MAX_SEARCH_SCORE: 1,
+  DEFAULT_SEARCH_MIN_SCORE: 0.4,
+  SEARCH_SCORE_STEP: 0.05
+};
+var codebaseIndexConfigSchema = import_zod6.z.object({
+  codebaseIndexEnabled: import_zod6.z.boolean().optional(),
+  codebaseIndexQdrantUrl: import_zod6.z.string().optional(),
+  codebaseIndexEmbedderProvider: import_zod6.z.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral", "vercel-ai-gateway"]).optional(),
+  codebaseIndexEmbedderBaseUrl: import_zod6.z.string().optional(),
+  codebaseIndexEmbedderModelId: import_zod6.z.string().optional(),
+  codebaseIndexEmbedderModelDimension: import_zod6.z.number().optional(),
+  codebaseIndexSearchMinScore: import_zod6.z.number().min(0).max(1).optional(),
+  codebaseIndexSearchMaxResults: import_zod6.z.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
+  // OpenAI Compatible specific fields
+  codebaseIndexOpenAiCompatibleBaseUrl: import_zod6.z.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: import_zod6.z.number().optional()
+});
+var codebaseIndexModelsSchema = import_zod6.z.object({
+  openai: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.object({ dimension: import_zod6.z.number() })).optional(),
+  ollama: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.object({ dimension: import_zod6.z.number() })).optional(),
+  "openai-compatible": import_zod6.z.record(import_zod6.z.string(), import_zod6.z.object({ dimension: import_zod6.z.number() })).optional(),
+  gemini: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.object({ dimension: import_zod6.z.number() })).optional(),
+  mistral: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.object({ dimension: import_zod6.z.number() })).optional(),
+  "vercel-ai-gateway": import_zod6.z.record(import_zod6.z.string(), import_zod6.z.object({ dimension: import_zod6.z.number() })).optional()
+});
+var codebaseIndexProviderSchema = import_zod6.z.object({
+  codeIndexOpenAiKey: import_zod6.z.string().optional(),
+  codeIndexQdrantApiKey: import_zod6.z.string().optional(),
+  codebaseIndexOpenAiCompatibleBaseUrl: import_zod6.z.string().optional(),
+  codebaseIndexOpenAiCompatibleApiKey: import_zod6.z.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: import_zod6.z.number().optional(),
+  codebaseIndexGeminiApiKey: import_zod6.z.string().optional(),
+  codebaseIndexMistralApiKey: import_zod6.z.string().optional(),
+  codebaseIndexVercelAiGatewayApiKey: import_zod6.z.string().optional()
+});
+
 // src/providers/anthropic.ts
 var anthropicDefaultModelId = "claude-sonnet-4-20250514";
 var anthropicModels = {
@@ -3859,253 +3874,253 @@ var providerNames = [
   "roo",
   "vercel-ai-gateway"
 ];
-var providerNamesSchema = import_zod8.z.enum(providerNames);
-var providerSettingsEntrySchema = import_zod8.z.object({
-  id: import_zod8.z.string(),
-  name: import_zod8.z.string(),
+var providerNamesSchema = import_zod7.z.enum(providerNames);
+var providerSettingsEntrySchema = import_zod7.z.object({
+  id: import_zod7.z.string(),
+  name: import_zod7.z.string(),
   apiProvider: providerNamesSchema.optional(),
-  modelId: import_zod8.z.string().optional()
+  modelId: import_zod7.z.string().optional()
 });
 var DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3;
-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(),
+var baseProviderSettingsSchema = import_zod7.z.object({
+  includeMaxTokens: import_zod7.z.boolean().optional(),
+  diffEnabled: import_zod7.z.boolean().optional(),
+  todoListEnabled: import_zod7.z.boolean().optional(),
+  fuzzyMatchThreshold: import_zod7.z.number().optional(),
+  modelTemperature: import_zod7.z.number().nullish(),
+  rateLimitSeconds: import_zod7.z.number().optional(),
+  consecutiveMistakeLimit: import_zod7.z.number().min(0).optional(),
   // Model reasoning.
-  enableReasoningEffort: import_zod8.z.boolean().optional(),
+  enableReasoningEffort: import_zod7.z.boolean().optional(),
   reasoningEffort: reasoningEffortWithMinimalSchema.optional(),
-  modelMaxTokens: import_zod8.z.number().optional(),
-  modelMaxThinkingTokens: import_zod8.z.number().optional(),
+  modelMaxTokens: import_zod7.z.number().optional(),
+  modelMaxThinkingTokens: import_zod7.z.number().optional(),
   // Model verbosity.
   verbosity: verbosityLevelsSchema.optional()
 });
 var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
-  apiModelId: import_zod8.z.string().optional()
+  apiModelId: import_zod7.z.string().optional()
 });
 var anthropicSchema = apiModelIdProviderModelSchema.extend({
-  apiKey: import_zod8.z.string().optional(),
-  anthropicBaseUrl: import_zod8.z.string().optional(),
-  anthropicUseAuthToken: import_zod8.z.boolean().optional(),
-  anthropicBeta1MContext: import_zod8.z.boolean().optional()
+  apiKey: import_zod7.z.string().optional(),
+  anthropicBaseUrl: import_zod7.z.string().optional(),
+  anthropicUseAuthToken: import_zod7.z.boolean().optional(),
+  anthropicBeta1MContext: import_zod7.z.boolean().optional()
   // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var claudeCodeSchema = apiModelIdProviderModelSchema.extend({
-  claudeCodePath: import_zod8.z.string().optional(),
-  claudeCodeMaxOutputTokens: import_zod8.z.number().int().min(1).max(2e5).optional()
+  claudeCodePath: import_zod7.z.string().optional(),
+  claudeCodeMaxOutputTokens: import_zod7.z.number().int().min(1).max(2e5).optional()
 });
 var glamaSchema = baseProviderSettingsSchema.extend({
-  glamaModelId: import_zod8.z.string().optional(),
-  glamaApiKey: import_zod8.z.string().optional()
+  glamaModelId: import_zod7.z.string().optional(),
+  glamaApiKey: import_zod7.z.string().optional()
 });
 var openRouterSchema = baseProviderSettingsSchema.extend({
-  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(),
+  openRouterApiKey: import_zod7.z.string().optional(),
+  openRouterModelId: import_zod7.z.string().optional(),
+  openRouterBaseUrl: import_zod7.z.string().optional(),
+  openRouterSpecificProvider: import_zod7.z.string().optional(),
+  openRouterUseMiddleOutTransform: import_zod7.z.boolean().optional(),
   // Image generation settings (experimental)
-  openRouterImageGenerationSettings: import_zod8.z.object({
-    openRouterApiKey: import_zod8.z.string().optional(),
-    selectedModel: import_zod8.z.string().optional()
+  openRouterImageGenerationSettings: import_zod7.z.object({
+    openRouterApiKey: import_zod7.z.string().optional(),
+    selectedModel: import_zod7.z.string().optional()
   }).optional()
 });
 var bedrockSchema = apiModelIdProviderModelSchema.extend({
-  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()
+  awsAccessKey: import_zod7.z.string().optional(),
+  awsSecretKey: import_zod7.z.string().optional(),
+  awsSessionToken: import_zod7.z.string().optional(),
+  awsRegion: import_zod7.z.string().optional(),
+  awsUseCrossRegionInference: import_zod7.z.boolean().optional(),
+  awsUsePromptCache: import_zod7.z.boolean().optional(),
+  awsProfile: import_zod7.z.string().optional(),
+  awsUseProfile: import_zod7.z.boolean().optional(),
+  awsApiKey: import_zod7.z.string().optional(),
+  awsUseApiKey: import_zod7.z.boolean().optional(),
+  awsCustomArn: import_zod7.z.string().optional(),
+  awsModelContextWindow: import_zod7.z.number().optional(),
+  awsBedrockEndpointEnabled: import_zod7.z.boolean().optional(),
+  awsBedrockEndpoint: import_zod7.z.string().optional(),
+  awsBedrock1MContext: import_zod7.z.boolean().optional()
   // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var vertexSchema = apiModelIdProviderModelSchema.extend({
-  vertexKeyFile: import_zod8.z.string().optional(),
-  vertexJsonCredentials: import_zod8.z.string().optional(),
-  vertexProjectId: import_zod8.z.string().optional(),
-  vertexRegion: import_zod8.z.string().optional(),
-  enableUrlContext: import_zod8.z.boolean().optional(),
-  enableGrounding: import_zod8.z.boolean().optional()
+  vertexKeyFile: import_zod7.z.string().optional(),
+  vertexJsonCredentials: import_zod7.z.string().optional(),
+  vertexProjectId: import_zod7.z.string().optional(),
+  vertexRegion: import_zod7.z.string().optional(),
+  enableUrlContext: import_zod7.z.boolean().optional(),
+  enableGrounding: import_zod7.z.boolean().optional()
 });
 var openAiSchema = baseProviderSettingsSchema.extend({
-  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(),
+  openAiBaseUrl: import_zod7.z.string().optional(),
+  openAiApiKey: import_zod7.z.string().optional(),
+  openAiLegacyFormat: import_zod7.z.boolean().optional(),
+  openAiR1FormatEnabled: import_zod7.z.boolean().optional(),
+  openAiModelId: import_zod7.z.string().optional(),
   openAiCustomModelInfo: modelInfoSchema.nullish(),
-  openAiUseAzure: import_zod8.z.boolean().optional(),
-  azureApiVersion: import_zod8.z.string().optional(),
-  openAiStreamingEnabled: import_zod8.z.boolean().optional(),
-  openAiHostHeader: import_zod8.z.string().optional(),
+  openAiUseAzure: import_zod7.z.boolean().optional(),
+  azureApiVersion: import_zod7.z.string().optional(),
+  openAiStreamingEnabled: import_zod7.z.boolean().optional(),
+  openAiHostHeader: import_zod7.z.string().optional(),
   // Keep temporarily for backward compatibility during migration.
-  openAiHeaders: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional()
+  openAiHeaders: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.string()).optional()
 });
 var ollamaSchema = baseProviderSettingsSchema.extend({
-  ollamaModelId: import_zod8.z.string().optional(),
-  ollamaBaseUrl: import_zod8.z.string().optional()
+  ollamaModelId: import_zod7.z.string().optional(),
+  ollamaBaseUrl: import_zod7.z.string().optional()
 });
 var vsCodeLmSchema = baseProviderSettingsSchema.extend({
-  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()
+  vsCodeLmModelSelector: import_zod7.z.object({
+    vendor: import_zod7.z.string().optional(),
+    family: import_zod7.z.string().optional(),
+    version: import_zod7.z.string().optional(),
+    id: import_zod7.z.string().optional()
   }).optional()
 });
 var lmStudioSchema = baseProviderSettingsSchema.extend({
-  lmStudioModelId: import_zod8.z.string().optional(),
-  lmStudioBaseUrl: import_zod8.z.string().optional(),
-  lmStudioDraftModelId: import_zod8.z.string().optional(),
-  lmStudioSpeculativeDecodingEnabled: import_zod8.z.boolean().optional()
+  lmStudioModelId: import_zod7.z.string().optional(),
+  lmStudioBaseUrl: import_zod7.z.string().optional(),
+  lmStudioDraftModelId: import_zod7.z.string().optional(),
+  lmStudioSpeculativeDecodingEnabled: import_zod7.z.boolean().optional()
 });
 var geminiSchema = apiModelIdProviderModelSchema.extend({
-  geminiApiKey: import_zod8.z.string().optional(),
-  googleGeminiBaseUrl: import_zod8.z.string().optional(),
-  enableUrlContext: import_zod8.z.boolean().optional(),
-  enableGrounding: import_zod8.z.boolean().optional()
+  geminiApiKey: import_zod7.z.string().optional(),
+  googleGeminiBaseUrl: import_zod7.z.string().optional(),
+  enableUrlContext: import_zod7.z.boolean().optional(),
+  enableGrounding: import_zod7.z.boolean().optional()
 });
 var geminiCliSchema = apiModelIdProviderModelSchema.extend({
-  geminiCliOAuthPath: import_zod8.z.string().optional(),
-  geminiCliProjectId: import_zod8.z.string().optional()
+  geminiCliOAuthPath: import_zod7.z.string().optional(),
+  geminiCliProjectId: import_zod7.z.string().optional()
 });
 var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
-  openAiNativeApiKey: import_zod8.z.string().optional(),
-  openAiNativeBaseUrl: import_zod8.z.string().optional()
+  openAiNativeApiKey: import_zod7.z.string().optional(),
+  openAiNativeBaseUrl: import_zod7.z.string().optional()
 });
 var mistralSchema = apiModelIdProviderModelSchema.extend({
-  mistralApiKey: import_zod8.z.string().optional(),
-  mistralCodestralUrl: import_zod8.z.string().optional()
+  mistralApiKey: import_zod7.z.string().optional(),
+  mistralCodestralUrl: import_zod7.z.string().optional()
 });
 var deepSeekSchema = apiModelIdProviderModelSchema.extend({
-  deepSeekBaseUrl: import_zod8.z.string().optional(),
-  deepSeekApiKey: import_zod8.z.string().optional()
+  deepSeekBaseUrl: import_zod7.z.string().optional(),
+  deepSeekApiKey: import_zod7.z.string().optional()
 });
 var doubaoSchema = apiModelIdProviderModelSchema.extend({
-  doubaoBaseUrl: import_zod8.z.string().optional(),
-  doubaoApiKey: import_zod8.z.string().optional()
+  doubaoBaseUrl: import_zod7.z.string().optional(),
+  doubaoApiKey: import_zod7.z.string().optional()
 });
 var moonshotSchema = apiModelIdProviderModelSchema.extend({
-  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()
+  moonshotBaseUrl: import_zod7.z.union([import_zod7.z.literal("https://api.moonshot.ai/v1"), import_zod7.z.literal("https://api.moonshot.cn/v1")]).optional(),
+  moonshotApiKey: import_zod7.z.string().optional()
 });
 var unboundSchema = baseProviderSettingsSchema.extend({
-  unboundApiKey: import_zod8.z.string().optional(),
-  unboundModelId: import_zod8.z.string().optional()
+  unboundApiKey: import_zod7.z.string().optional(),
+  unboundModelId: import_zod7.z.string().optional()
 });
 var requestySchema = baseProviderSettingsSchema.extend({
-  requestyBaseUrl: import_zod8.z.string().optional(),
-  requestyApiKey: import_zod8.z.string().optional(),
-  requestyModelId: import_zod8.z.string().optional()
+  requestyBaseUrl: import_zod7.z.string().optional(),
+  requestyApiKey: import_zod7.z.string().optional(),
+  requestyModelId: import_zod7.z.string().optional()
 });
 var humanRelaySchema = baseProviderSettingsSchema;
 var fakeAiSchema = baseProviderSettingsSchema.extend({
-  fakeAi: import_zod8.z.unknown().optional()
+  fakeAi: import_zod7.z.unknown().optional()
 });
 var xaiSchema = apiModelIdProviderModelSchema.extend({
-  xaiApiKey: import_zod8.z.string().optional()
+  xaiApiKey: import_zod7.z.string().optional()
 });
 var groqSchema = apiModelIdProviderModelSchema.extend({
-  groqApiKey: import_zod8.z.string().optional()
+  groqApiKey: import_zod7.z.string().optional()
 });
 var huggingFaceSchema = baseProviderSettingsSchema.extend({
-  huggingFaceApiKey: import_zod8.z.string().optional(),
-  huggingFaceModelId: import_zod8.z.string().optional(),
-  huggingFaceInferenceProvider: import_zod8.z.string().optional()
+  huggingFaceApiKey: import_zod7.z.string().optional(),
+  huggingFaceModelId: import_zod7.z.string().optional(),
+  huggingFaceInferenceProvider: import_zod7.z.string().optional()
 });
 var chutesSchema = apiModelIdProviderModelSchema.extend({
-  chutesApiKey: import_zod8.z.string().optional()
+  chutesApiKey: import_zod7.z.string().optional()
 });
 var litellmSchema = baseProviderSettingsSchema.extend({
-  litellmBaseUrl: import_zod8.z.string().optional(),
-  litellmApiKey: import_zod8.z.string().optional(),
-  litellmModelId: import_zod8.z.string().optional(),
-  litellmUsePromptCache: import_zod8.z.boolean().optional()
+  litellmBaseUrl: import_zod7.z.string().optional(),
+  litellmApiKey: import_zod7.z.string().optional(),
+  litellmModelId: import_zod7.z.string().optional(),
+  litellmUsePromptCache: import_zod7.z.boolean().optional()
 });
 var cerebrasSchema = apiModelIdProviderModelSchema.extend({
-  cerebrasApiKey: import_zod8.z.string().optional()
+  cerebrasApiKey: import_zod7.z.string().optional()
 });
 var sambaNovaSchema = apiModelIdProviderModelSchema.extend({
-  sambaNovaApiKey: import_zod8.z.string().optional()
+  sambaNovaApiKey: import_zod7.z.string().optional()
 });
 var zaiSchema = apiModelIdProviderModelSchema.extend({
-  zaiApiKey: import_zod8.z.string().optional(),
-  zaiApiLine: import_zod8.z.union([import_zod8.z.literal("china"), import_zod8.z.literal("international")]).optional()
+  zaiApiKey: import_zod7.z.string().optional(),
+  zaiApiLine: import_zod7.z.union([import_zod7.z.literal("china"), import_zod7.z.literal("international")]).optional()
 });
 var fireworksSchema = apiModelIdProviderModelSchema.extend({
-  fireworksApiKey: import_zod8.z.string().optional()
+  fireworksApiKey: import_zod7.z.string().optional()
 });
 var featherlessSchema = apiModelIdProviderModelSchema.extend({
-  featherlessApiKey: import_zod8.z.string().optional()
+  featherlessApiKey: import_zod7.z.string().optional()
 });
 var ioIntelligenceSchema = apiModelIdProviderModelSchema.extend({
-  ioIntelligenceModelId: import_zod8.z.string().optional(),
-  ioIntelligenceApiKey: import_zod8.z.string().optional()
+  ioIntelligenceModelId: import_zod7.z.string().optional(),
+  ioIntelligenceApiKey: import_zod7.z.string().optional()
 });
 var qwenCodeSchema = apiModelIdProviderModelSchema.extend({
-  qwenCodeOauthPath: import_zod8.z.string().optional()
+  qwenCodeOauthPath: import_zod7.z.string().optional()
 });
 var rooSchema = apiModelIdProviderModelSchema.extend({
   // No additional fields needed - uses cloud authentication
 });
 var vercelAiGatewaySchema = baseProviderSettingsSchema.extend({
-  vercelAiGatewayApiKey: import_zod8.z.string().optional(),
-  vercelAiGatewayModelId: import_zod8.z.string().optional()
+  vercelAiGatewayApiKey: import_zod7.z.string().optional(),
+  vercelAiGatewayModelId: import_zod7.z.string().optional()
 });
-var defaultSchema = import_zod8.z.object({
-  apiProvider: import_zod8.z.undefined()
+var defaultSchema = import_zod7.z.object({
+  apiProvider: import_zod7.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") })),
-  featherlessSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("featherless") })),
-  ioIntelligenceSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("io-intelligence") })),
-  qwenCodeSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("qwen-code") })),
-  rooSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("roo") })),
-  vercelAiGatewaySchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("vercel-ai-gateway") })),
+var providerSettingsSchemaDiscriminated = import_zod7.z.discriminatedUnion("apiProvider", [
+  anthropicSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("anthropic") })),
+  claudeCodeSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("claude-code") })),
+  glamaSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("glama") })),
+  openRouterSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("openrouter") })),
+  bedrockSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("bedrock") })),
+  vertexSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("vertex") })),
+  openAiSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("openai") })),
+  ollamaSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("ollama") })),
+  vsCodeLmSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("vscode-lm") })),
+  lmStudioSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("lmstudio") })),
+  geminiSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("gemini") })),
+  geminiCliSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("gemini-cli") })),
+  openAiNativeSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("openai-native") })),
+  mistralSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("mistral") })),
+  deepSeekSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("deepseek") })),
+  doubaoSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("doubao") })),
+  moonshotSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("moonshot") })),
+  unboundSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("unbound") })),
+  requestySchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("requesty") })),
+  humanRelaySchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("human-relay") })),
+  fakeAiSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("fake-ai") })),
+  xaiSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("xai") })),
+  groqSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("groq") })),
+  huggingFaceSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("huggingface") })),
+  chutesSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("chutes") })),
+  litellmSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("litellm") })),
+  cerebrasSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("cerebras") })),
+  sambaNovaSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("sambanova") })),
+  zaiSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("zai") })),
+  fireworksSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("fireworks") })),
+  featherlessSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("featherless") })),
+  ioIntelligenceSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("io-intelligence") })),
+  qwenCodeSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("qwen-code") })),
+  rooSchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("roo") })),
+  vercelAiGatewaySchema.merge(import_zod7.z.object({ apiProvider: import_zod7.z.literal("vercel-ai-gateway") })),
   defaultSchema
 ]);
-var providerSettingsSchema = import_zod8.z.object({
+var providerSettingsSchema = import_zod7.z.object({
   apiProvider: providerNamesSchema.optional(),
   ...anthropicSchema.shape,
   ...claudeCodeSchema.shape,
@@ -4144,9 +4159,9 @@ var providerSettingsSchema = import_zod8.z.object({
   ...vercelAiGatewaySchema.shape,
   ...codebaseIndexProviderSchema.shape
 });
-var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: import_zod8.z.string().optional() });
+var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: import_zod7.z.string().optional() });
 var discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
-  import_zod8.z.object({ id: import_zod8.z.string().optional() })
+  import_zod7.z.object({ id: import_zod7.z.string().optional() })
 );
 var PROVIDER_SETTINGS_KEYS = providerSettingsSchema.keyof().options;
 var MODEL_ID_KEYS = [
@@ -4285,20 +4300,36 @@ var dynamicProviders = [
 var isDynamicProvider = (key) => dynamicProviders.includes(key);
 
 // src/history.ts
+var import_zod8 = require("zod");
+var historyItemSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  number: import_zod8.z.number(),
+  ts: import_zod8.z.number(),
+  task: import_zod8.z.string(),
+  tokensIn: import_zod8.z.number(),
+  tokensOut: import_zod8.z.number(),
+  cacheWrites: import_zod8.z.number().optional(),
+  cacheReads: import_zod8.z.number().optional(),
+  totalCost: import_zod8.z.number(),
+  size: import_zod8.z.number().optional(),
+  workspace: import_zod8.z.string().optional(),
+  mode: import_zod8.z.string().optional()
+});
+
+// src/experiment.ts
 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()
+var experimentIds = [
+  "powerSteering",
+  "multiFileApplyDiff",
+  "preventFocusDisruption",
+  "imageGeneration"
+];
+var experimentIdsSchema = import_zod9.z.enum(experimentIds);
+var experimentsSchema = import_zod9.z.object({
+  powerSteering: import_zod9.z.boolean().optional(),
+  multiFileApplyDiff: import_zod9.z.boolean().optional(),
+  preventFocusDisruption: import_zod9.z.boolean().optional(),
+  imageGeneration: import_zod9.z.boolean().optional()
 });
 
 // src/telemetry.ts
@@ -4828,8 +4859,376 @@ var EVALS_SETTINGS = {
 };
 var EVALS_TIMEOUT = 5 * 60 * 1e3;
 
-// src/ipc.ts
+// src/marketplace.ts
 var import_zod14 = require("zod");
+var mcpParameterSchema = import_zod14.z.object({
+  name: import_zod14.z.string().min(1),
+  key: import_zod14.z.string().min(1),
+  placeholder: import_zod14.z.string().optional(),
+  optional: import_zod14.z.boolean().optional().default(false)
+});
+var mcpInstallationMethodSchema = import_zod14.z.object({
+  name: import_zod14.z.string().min(1),
+  content: import_zod14.z.string().min(1),
+  parameters: import_zod14.z.array(mcpParameterSchema).optional(),
+  prerequisites: import_zod14.z.array(import_zod14.z.string()).optional()
+});
+var marketplaceItemTypeSchema = import_zod14.z.enum(["mode", "mcp"]);
+var baseMarketplaceItemSchema = import_zod14.z.object({
+  id: import_zod14.z.string().min(1),
+  name: import_zod14.z.string().min(1, "Name is required"),
+  description: import_zod14.z.string(),
+  author: import_zod14.z.string().optional(),
+  authorUrl: import_zod14.z.string().url("Author URL must be a valid URL").optional(),
+  tags: import_zod14.z.array(import_zod14.z.string()).optional(),
+  prerequisites: import_zod14.z.array(import_zod14.z.string()).optional()
+});
+var modeMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  content: import_zod14.z.string().min(1)
+  // YAML content for modes
+});
+var mcpMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  url: import_zod14.z.string().url(),
+  // Required url field
+  content: import_zod14.z.union([import_zod14.z.string().min(1), import_zod14.z.array(mcpInstallationMethodSchema)]),
+  // Single config or array of methods
+  parameters: import_zod14.z.array(mcpParameterSchema).optional()
+});
+var marketplaceItemSchema = import_zod14.z.discriminatedUnion("type", [
+  // Mode marketplace item
+  modeMarketplaceItemSchema.extend({
+    type: import_zod14.z.literal("mode")
+  }),
+  // MCP marketplace item
+  mcpMarketplaceItemSchema.extend({
+    type: import_zod14.z.literal("mcp")
+  })
+]);
+var installMarketplaceItemOptionsSchema = import_zod14.z.object({
+  target: import_zod14.z.enum(["global", "project"]).optional().default("project"),
+  parameters: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.any()).optional()
+});
+
+// src/cloud.ts
+var organizationAllowListSchema = import_zod15.z.object({
+  allowAll: import_zod15.z.boolean(),
+  providers: import_zod15.z.record(
+    import_zod15.z.object({
+      allowAll: import_zod15.z.boolean(),
+      models: import_zod15.z.array(import_zod15.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_zod15.z.object({
+    maxOpenTabsContext: import_zod15.z.number().int().nonnegative().optional(),
+    maxReadFileLine: import_zod15.z.number().int().gte(-1).optional(),
+    maxWorkspaceFiles: import_zod15.z.number().int().nonnegative().optional(),
+    terminalCommandDelay: import_zod15.z.number().int().nonnegative().optional(),
+    terminalOutputLineLimit: import_zod15.z.number().int().nonnegative().optional(),
+    terminalShellIntegrationTimeout: import_zod15.z.number().int().nonnegative().optional()
+  })
+);
+var organizationCloudSettingsSchema = import_zod15.z.object({
+  recordTaskMessages: import_zod15.z.boolean().optional(),
+  enableTaskSharing: import_zod15.z.boolean().optional(),
+  taskShareExpirationDays: import_zod15.z.number().int().positive().optional(),
+  allowMembersViewAllTasks: import_zod15.z.boolean().optional()
+});
+var organizationSettingsSchema = import_zod15.z.object({
+  version: import_zod15.z.number(),
+  cloudSettings: organizationCloudSettingsSchema.optional(),
+  defaultSettings: organizationDefaultSettingsSchema,
+  allowList: organizationAllowListSchema,
+  hiddenMcps: import_zod15.z.array(import_zod15.z.string()).optional(),
+  hideMarketplaceMcps: import_zod15.z.boolean().optional(),
+  mcps: import_zod15.z.array(mcpMarketplaceItemSchema).optional(),
+  providerProfiles: import_zod15.z.record(import_zod15.z.string(), providerSettingsWithIdSchema).optional()
+});
+var userFeaturesSchema = import_zod15.z.object({
+  roomoteControlEnabled: import_zod15.z.boolean().optional()
+});
+var userSettingsConfigSchema = import_zod15.z.object({
+  extensionBridgeEnabled: import_zod15.z.boolean().optional()
+});
+var userSettingsDataSchema = import_zod15.z.object({
+  features: userFeaturesSchema,
+  settings: userSettingsConfigSchema,
+  version: import_zod15.z.number()
+});
+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_zod15.z.object({
+  success: import_zod15.z.boolean(),
+  shareUrl: import_zod15.z.string().optional(),
+  error: import_zod15.z.string().optional(),
+  isNewShare: import_zod15.z.boolean().optional(),
+  manageUrl: import_zod15.z.string().optional()
+});
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["RETRYING"] = "retrying";
+  ConnectionState2["FAILED"] = "failed";
+  return ConnectionState2;
+})(ConnectionState || {});
+var HEARTBEAT_INTERVAL_MS = 2e4;
+var INSTANCE_TTL_SECONDS = 60;
+var extensionTaskSchema = import_zod15.z.object({
+  taskId: import_zod15.z.string(),
+  taskStatus: import_zod15.z.nativeEnum(TaskStatus),
+  ...taskMetadataSchema.shape
+});
+var extensionInstanceSchema = import_zod15.z.object({
+  instanceId: import_zod15.z.string(),
+  userId: import_zod15.z.string(),
+  workspacePath: import_zod15.z.string(),
+  appProperties: staticAppPropertiesSchema,
+  gitProperties: gitPropertiesSchema.optional(),
+  lastHeartbeat: import_zod15.z.coerce.number(),
+  task: extensionTaskSchema,
+  taskAsk: clineMessageSchema.optional(),
+  taskHistory: import_zod15.z.array(import_zod15.z.string())
+});
+var ExtensionBridgeEventName = ((ExtensionBridgeEventName2) => {
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskCreated"] = "taskCreated" /* TaskCreated */] = "TaskCreated";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskStarted"] = "taskStarted" /* TaskStarted */] = "TaskStarted";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskCompleted"] = "taskCompleted" /* TaskCompleted */] = "TaskCompleted";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskAborted"] = "taskAborted" /* TaskAborted */] = "TaskAborted";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskFocused"] = "taskFocused" /* TaskFocused */] = "TaskFocused";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskUnfocused"] = "taskUnfocused" /* TaskUnfocused */] = "TaskUnfocused";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskActive"] = "taskActive" /* TaskActive */] = "TaskActive";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskInteractive"] = "taskInteractive" /* TaskInteractive */] = "TaskInteractive";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskResumable"] = "taskResumable" /* TaskResumable */] = "TaskResumable";
+  ExtensionBridgeEventName2[ExtensionBridgeEventName2["TaskIdle"] = "taskIdle" /* TaskIdle */] = "TaskIdle";
+  ExtensionBridgeEventName2["InstanceRegistered"] = "instance_registered";
+  ExtensionBridgeEventName2["InstanceUnregistered"] = "instance_unregistered";
+  ExtensionBridgeEventName2["HeartbeatUpdated"] = "heartbeat_updated";
+  return ExtensionBridgeEventName2;
+})(ExtensionBridgeEventName || {});
+var extensionBridgeEventSchema = import_zod15.z.discriminatedUnion("type", [
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskCreated),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskStarted),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskCompleted),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskAborted),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskFocused),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskUnfocused),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskActive),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskInteractive),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskResumable),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(ExtensionBridgeEventName.TaskIdle),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("instance_registered" /* InstanceRegistered */),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("instance_unregistered" /* InstanceUnregistered */),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("heartbeat_updated" /* HeartbeatUpdated */),
+    instance: extensionInstanceSchema,
+    timestamp: import_zod15.z.number()
+  })
+]);
+var ExtensionBridgeCommandName = /* @__PURE__ */ ((ExtensionBridgeCommandName2) => {
+  ExtensionBridgeCommandName2["StartTask"] = "start_task";
+  ExtensionBridgeCommandName2["StopTask"] = "stop_task";
+  ExtensionBridgeCommandName2["ResumeTask"] = "resume_task";
+  return ExtensionBridgeCommandName2;
+})(ExtensionBridgeCommandName || {});
+var extensionBridgeCommandSchema = import_zod15.z.discriminatedUnion("type", [
+  import_zod15.z.object({
+    type: import_zod15.z.literal("start_task" /* StartTask */),
+    instanceId: import_zod15.z.string(),
+    payload: import_zod15.z.object({
+      text: import_zod15.z.string(),
+      images: import_zod15.z.array(import_zod15.z.string()).optional()
+    }),
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("stop_task" /* StopTask */),
+    instanceId: import_zod15.z.string(),
+    payload: import_zod15.z.object({ taskId: import_zod15.z.string() }),
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("resume_task" /* ResumeTask */),
+    instanceId: import_zod15.z.string(),
+    payload: import_zod15.z.object({
+      taskId: import_zod15.z.string()
+    }),
+    timestamp: import_zod15.z.number()
+  })
+]);
+var TaskBridgeEventName = ((TaskBridgeEventName2) => {
+  TaskBridgeEventName2[TaskBridgeEventName2["Message"] = "message" /* Message */] = "Message";
+  TaskBridgeEventName2[TaskBridgeEventName2["TaskModeSwitched"] = "taskModeSwitched" /* TaskModeSwitched */] = "TaskModeSwitched";
+  TaskBridgeEventName2[TaskBridgeEventName2["TaskInteractive"] = "taskInteractive" /* TaskInteractive */] = "TaskInteractive";
+  return TaskBridgeEventName2;
+})(TaskBridgeEventName || {});
+var taskBridgeEventSchema = import_zod15.z.discriminatedUnion("type", [
+  import_zod15.z.object({
+    type: import_zod15.z.literal(TaskBridgeEventName.Message),
+    taskId: import_zod15.z.string(),
+    action: import_zod15.z.string(),
+    message: clineMessageSchema
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(TaskBridgeEventName.TaskModeSwitched),
+    taskId: import_zod15.z.string(),
+    mode: import_zod15.z.string()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal(TaskBridgeEventName.TaskInteractive),
+    taskId: import_zod15.z.string()
+  })
+]);
+var TaskBridgeCommandName = /* @__PURE__ */ ((TaskBridgeCommandName2) => {
+  TaskBridgeCommandName2["Message"] = "message";
+  TaskBridgeCommandName2["ApproveAsk"] = "approve_ask";
+  TaskBridgeCommandName2["DenyAsk"] = "deny_ask";
+  return TaskBridgeCommandName2;
+})(TaskBridgeCommandName || {});
+var taskBridgeCommandSchema = import_zod15.z.discriminatedUnion("type", [
+  import_zod15.z.object({
+    type: import_zod15.z.literal("message" /* Message */),
+    taskId: import_zod15.z.string(),
+    payload: import_zod15.z.object({
+      text: import_zod15.z.string(),
+      images: import_zod15.z.array(import_zod15.z.string()).optional()
+    }),
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("approve_ask" /* ApproveAsk */),
+    taskId: import_zod15.z.string(),
+    payload: import_zod15.z.object({
+      text: import_zod15.z.string().optional(),
+      images: import_zod15.z.array(import_zod15.z.string()).optional()
+    }),
+    timestamp: import_zod15.z.number()
+  }),
+  import_zod15.z.object({
+    type: import_zod15.z.literal("deny_ask" /* DenyAsk */),
+    taskId: import_zod15.z.string(),
+    payload: import_zod15.z.object({
+      text: import_zod15.z.string().optional(),
+      images: import_zod15.z.array(import_zod15.z.string()).optional()
+    }),
+    timestamp: import_zod15.z.number()
+  })
+]);
+var ExtensionSocketEvents = {
+  CONNECTED: "extension:connected",
+  REGISTER: "extension:register",
+  UNREGISTER: "extension:unregister",
+  HEARTBEAT: "extension:heartbeat",
+  EVENT: "extension:event",
+  // event from extension instance
+  RELAYED_EVENT: "extension:relayed_event",
+  // relay from server
+  COMMAND: "extension:command",
+  // command from user
+  RELAYED_COMMAND: "extension:relayed_command"
+  // relay from server
+};
+var TaskSocketEvents = {
+  JOIN: "task:join",
+  LEAVE: "task:leave",
+  EVENT: "task:event",
+  // event from extension task
+  RELAYED_EVENT: "task:relayed_event",
+  // relay from server
+  COMMAND: "task:command",
+  // command from user
+  RELAYED_COMMAND: "task:relayed_command"
+  // relay from server
+};
+
+// src/followup.ts
+var import_zod16 = require("zod");
+var suggestionItemSchema = import_zod16.z.object({
+  answer: import_zod16.z.string(),
+  mode: import_zod16.z.string().optional()
+});
+var followUpDataSchema = import_zod16.z.object({
+  question: import_zod16.z.string().optional(),
+  suggest: import_zod16.z.array(suggestionItemSchema).optional()
+});
+
+// src/ipc.ts
+var import_zod17 = require("zod");
 var IpcMessageType = /* @__PURE__ */ ((IpcMessageType2) => {
   IpcMessageType2["Connect"] = "Connect";
   IpcMessageType2["Disconnect"] = "Disconnect";
@@ -4843,10 +5242,10 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
   IpcOrigin2["Server"] = "server";
   return IpcOrigin2;
 })(IpcOrigin || {});
-var ackSchema = import_zod14.z.object({
-  clientId: import_zod14.z.string(),
-  pid: import_zod14.z.number(),
-  ppid: import_zod14.z.number()
+var ackSchema = import_zod17.z.object({
+  clientId: import_zod17.z.string(),
+  pid: import_zod17.z.number(),
+  ppid: import_zod17.z.number()
 });
 var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -4855,122 +5254,72 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["ResumeTask"] = "ResumeTask";
   return TaskCommandName2;
 })(TaskCommandName || {});
-var taskCommandSchema = import_zod14.z.discriminatedUnion("commandName", [
-  import_zod14.z.object({
-    commandName: import_zod14.z.literal("StartNewTask" /* StartNewTask */),
-    data: import_zod14.z.object({
+var taskCommandSchema = import_zod17.z.discriminatedUnion("commandName", [
+  import_zod17.z.object({
+    commandName: import_zod17.z.literal("StartNewTask" /* StartNewTask */),
+    data: import_zod17.z.object({
       configuration: rooCodeSettingsSchema,
-      text: import_zod14.z.string(),
-      images: import_zod14.z.array(import_zod14.z.string()).optional(),
-      newTab: import_zod14.z.boolean().optional()
+      text: import_zod17.z.string(),
+      images: import_zod17.z.array(import_zod17.z.string()).optional(),
+      newTab: import_zod17.z.boolean().optional()
     })
   }),
-  import_zod14.z.object({
-    commandName: import_zod14.z.literal("CancelTask" /* CancelTask */),
-    data: import_zod14.z.string()
+  import_zod17.z.object({
+    commandName: import_zod17.z.literal("CancelTask" /* CancelTask */),
+    data: import_zod17.z.string()
   }),
-  import_zod14.z.object({
-    commandName: import_zod14.z.literal("CloseTask" /* CloseTask */),
-    data: import_zod14.z.string()
+  import_zod17.z.object({
+    commandName: import_zod17.z.literal("CloseTask" /* CloseTask */),
+    data: import_zod17.z.string()
   }),
-  import_zod14.z.object({
-    commandName: import_zod14.z.literal("ResumeTask" /* ResumeTask */),
-    data: import_zod14.z.string()
+  import_zod17.z.object({
+    commandName: import_zod17.z.literal("ResumeTask" /* ResumeTask */),
+    data: import_zod17.z.string()
   })
 ]);
-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 */),
+var ipcMessageSchema = import_zod17.z.discriminatedUnion("type", [
+  import_zod17.z.object({
+    type: import_zod17.z.literal("Ack" /* Ack */),
+    origin: import_zod17.z.literal("server" /* Server */),
     data: ackSchema
   }),
-  import_zod14.z.object({
-    type: import_zod14.z.literal("TaskCommand" /* TaskCommand */),
-    origin: import_zod14.z.literal("client" /* Client */),
-    clientId: import_zod14.z.string(),
+  import_zod17.z.object({
+    type: import_zod17.z.literal("TaskCommand" /* TaskCommand */),
+    origin: import_zod17.z.literal("client" /* Client */),
+    clientId: import_zod17.z.string(),
     data: taskCommandSchema
   }),
-  import_zod14.z.object({
-    type: import_zod14.z.literal("TaskEvent" /* TaskEvent */),
-    origin: import_zod14.z.literal("server" /* Server */),
-    relayClientId: import_zod14.z.string().optional(),
+  import_zod17.z.object({
+    type: import_zod17.z.literal("TaskEvent" /* TaskEvent */),
+    origin: import_zod17.z.literal("server" /* Server */),
+    relayClientId: import_zod17.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_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()
+var import_zod18 = require("zod");
+var mcpExecutionStatusSchema = import_zod18.z.discriminatedUnion("status", [
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("started"),
+    serverName: import_zod18.z.string(),
+    toolName: import_zod18.z.string()
   }),
-  import_zod16.z.object({
-    executionId: import_zod16.z.string(),
-    status: import_zod16.z.literal("output"),
-    response: import_zod16.z.string()
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("output"),
+    response: import_zod18.z.string()
   }),
-  import_zod16.z.object({
-    executionId: import_zod16.z.string(),
-    status: import_zod16.z.literal("completed"),
-    response: import_zod16.z.string().optional()
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("completed"),
+    response: import_zod18.z.string().optional()
   }),
-  import_zod16.z.object({
-    executionId: import_zod16.z.string(),
-    status: import_zod16.z.literal("error"),
-    error: import_zod16.z.string().optional()
+  import_zod18.z.object({
+    executionId: import_zod18.z.string(),
+    status: import_zod18.z.literal("error"),
+    error: import_zod18.z.string().optional()
   })
 ]);
 
@@ -4979,56 +5328,41 @@ function shouldUseSingleFileRead(modelId) {
   return modelId.includes("grok-code-fast-1");
 }
 
-// src/task.ts
-var import_zod17 = require("zod");
-var TaskStatus = /* @__PURE__ */ ((TaskStatus2) => {
-  TaskStatus2["Running"] = "running";
-  TaskStatus2["Interactive"] = "interactive";
-  TaskStatus2["Resumable"] = "resumable";
-  TaskStatus2["Idle"] = "idle";
-  TaskStatus2["None"] = "none";
-  return TaskStatus2;
-})(TaskStatus || {});
-var taskMetadataSchema = import_zod17.z.object({
-  task: import_zod17.z.string().optional(),
-  images: import_zod17.z.array(import_zod17.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_zod19 = require("zod");
+var todoStatusSchema = import_zod19.z.enum(["pending", "in_progress", "completed"]);
+var todoItemSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  content: import_zod19.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_zod20 = require("zod");
+var commandExecutionStatusSchema = import_zod20.z.discriminatedUnion("status", [
+  import_zod20.z.object({
+    executionId: import_zod20.z.string(),
+    status: import_zod20.z.literal("started"),
+    pid: import_zod20.z.number().optional(),
+    command: import_zod20.z.string()
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("output"),
-    output: import_zod19.z.string()
+  import_zod20.z.object({
+    executionId: import_zod20.z.string(),
+    status: import_zod20.z.literal("output"),
+    output: import_zod20.z.string()
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("exited"),
-    exitCode: import_zod19.z.number().optional()
+  import_zod20.z.object({
+    executionId: import_zod20.z.string(),
+    status: import_zod20.z.literal("exited"),
+    exitCode: import_zod20.z.number().optional()
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("fallback")
+  import_zod20.z.object({
+    executionId: import_zod20.z.string(),
+    status: import_zod20.z.literal("fallback")
   }),
-  import_zod19.z.object({
-    executionId: import_zod19.z.string(),
-    status: import_zod19.z.literal("timeout")
+  import_zod20.z.object({
+    executionId: import_zod20.z.string(),
+    status: import_zod20.z.literal("timeout")
   })
 ]);
 // Annotate the CommonJS export names for ESM import in node:
@@ -5043,6 +5377,7 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   BEDROCK_REGIONS,
   CLAUDE_CODE_DEFAULT_MAX_OUTPUT_TOKENS,
   CODEBASE_INDEX_DEFAULTS,
+  ConnectionState,
   DEEP_SEEK_DEFAULT_TEMPERATURE,
   DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
   DEFAULT_MODES,
@@ -5052,10 +5387,14 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   DOUBAO_API_CHAT_PATH,
   EVALS_SETTINGS,
   EVALS_TIMEOUT,
+  ExtensionBridgeCommandName,
+  ExtensionBridgeEventName,
+  ExtensionSocketEvents,
   GLAMA_DEFAULT_TEMPERATURE,
   GLOBAL_SETTINGS_KEYS,
   GLOBAL_STATE_KEYS,
   GPT5_DEFAULT_TEMPERATURE,
+  HEARTBEAT_INTERVAL_MS,
   HUGGINGFACE_API_URL,
   HUGGINGFACE_CACHE_DURATION,
   HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
@@ -5064,6 +5403,7 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   HUGGINGFACE_SLIDER_MIN,
   HUGGINGFACE_SLIDER_STEP,
   HUGGINGFACE_TEMPERATURE_MAX_VALUE,
+  INSTANCE_TTL_SECONDS,
   IO_INTELLIGENCE_CACHE_DURATION,
   IpcMessageType,
   IpcOrigin,
@@ -5080,10 +5420,15 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   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,
+  TaskBridgeCommandName,
+  TaskBridgeEventName,
   TaskCommandName,
+  TaskSocketEvents,
   TaskStatus,
   TelemetryEventName,
   VERCEL_AI_GATEWAY_DEFAULT_TEMPERATURE,
@@ -5134,6 +5479,9 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   experimentIds,
   experimentIdsSchema,
   experimentsSchema,
+  extensionBridgeCommandSchema,
+  extensionBridgeEventSchema,
+  extensionInstanceSchema,
   featherlessDefaultModelId,
   featherlessModels,
   fireworksDefaultModelId,
@@ -5200,6 +5548,10 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   openAiNativeModels,
   openRouterDefaultModelId,
   openRouterDefaultModelInfo,
+  organizationAllowListSchema,
+  organizationCloudSettingsSchema,
+  organizationDefaultSettingsSchema,
+  organizationSettingsSchema,
   promptComponentSchema,
   providerNames,
   providerNamesSchema,
@@ -5222,9 +5574,12 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   rooModels,
   sambaNovaDefaultModelId,
   sambaNovaModels,
+  shareResponseSchema,
   shouldUseSingleFileRead,
   staticAppPropertiesSchema,
   suggestionItemSchema,
+  taskBridgeCommandSchema,
+  taskBridgeEventSchema,
   taskCommandSchema,
   taskEventSchema,
   taskMetadataSchema,
@@ -5244,6 +5599,9 @@ var commandExecutionStatusSchema = import_zod19.z.discriminatedUnion("status", [
   toolUsageSchema,
   unboundDefaultModelId,
   unboundDefaultModelInfo,
+  userFeaturesSchema,
+  userSettingsConfigSchema,
+  userSettingsDataSchema,
   verbosityLevels,
   verbosityLevelsSchema,
   vercelAiGatewayDefaultModelId,