@roo-code/types 1.63.0 → 1.65.0

package/dist/index.js

@@ -1,52 +1,11 @@
-// src/codebase-index.ts
-import { z } from "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 = z.object({
-  codebaseIndexEnabled: z.boolean().optional(),
-  codebaseIndexQdrantUrl: z.string().optional(),
-  codebaseIndexEmbedderProvider: z.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral", "vercel-ai-gateway"]).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: 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(),
-  "vercel-ai-gateway": 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(),
-  codebaseIndexVercelAiGatewayApiKey: z.string().optional()
-});
+// src/cloud.ts
+import { z as z15 } from "zod";
 
 // src/events.ts
-import { z as z4 } from "zod";
+import { z as z3 } from "zod";
 
 // src/message.ts
-import { z as z2 } from "zod";
+import { z } from "zod";
 var clineAsks = [
   "followup",
   "command",
@@ -61,7 +20,7 @@ var clineAsks = [
   "use_mcp_server",
   "auto_approval_max_req_reached"
 ];
-var clineAskSchema = z2.enum(clineAsks);
+var clineAskSchema = z.enum(clineAsks);
 var idleAsks = [
   "completion_result",
   "api_req_failed",
@@ -112,53 +71,53 @@ var clineSays = [
   "codebase_search_result",
   "user_edit_todos"
 ];
-var clineSaySchema = z2.enum(clineSays);
-var toolProgressStatusSchema = z2.object({
-  icon: z2.string().optional(),
-  text: z2.string().optional()
+var clineSaySchema = z.enum(clineSays);
+var toolProgressStatusSchema = z.object({
+  icon: z.string().optional(),
+  text: z.string().optional()
 });
-var contextCondenseSchema = z2.object({
-  cost: z2.number(),
-  prevContextTokens: z2.number(),
-  newContextTokens: z2.number(),
-  summary: z2.string()
+var contextCondenseSchema = z.object({
+  cost: z.number(),
+  prevContextTokens: z.number(),
+  newContextTokens: z.number(),
+  summary: z.string()
 });
-var clineMessageSchema = z2.object({
-  ts: z2.number(),
-  type: z2.union([z2.literal("ask"), z2.literal("say")]),
+var clineMessageSchema = z.object({
+  ts: z.number(),
+  type: z.union([z.literal("ask"), z.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(),
+  text: z.string().optional(),
+  images: z.array(z.string()).optional(),
+  partial: z.boolean().optional(),
+  reasoning: z.string().optional(),
+  conversationHistoryIndex: z.number().optional(),
+  checkpoint: z.record(z.string(), z.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()
+  isProtected: z.boolean().optional(),
+  apiProtocol: z.union([z.literal("openai"), z.literal("anthropic")]).optional(),
+  metadata: z.object({
+    gpt5: z.object({
+      previous_response_id: z.string().optional(),
+      instructions: z.string().optional(),
+      reasoning_summary: z.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()
+var tokenUsageSchema = z.object({
+  totalTokensIn: z.number(),
+  totalTokensOut: z.number(),
+  totalCacheWrites: z.number().optional(),
+  totalCacheReads: z.number().optional(),
+  totalCost: z.number(),
+  contextTokens: z.number()
 });
 
 // src/tool.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
-var toolGroupsSchema = z3.enum(toolGroups);
+var toolGroupsSchema = z2.enum(toolGroups);
 var toolNames = [
   "execute_command",
   "read_file",
@@ -181,12 +140,12 @@ var toolNames = [
   "update_todo_list",
   "generate_image"
 ];
-var toolNamesSchema = z3.enum(toolNames);
-var toolUsageSchema = z3.record(
+var toolNamesSchema = z2.enum(toolNames);
+var toolUsageSchema = z2.record(
   toolNamesSchema,
-  z3.object({
-    attempts: z3.number(),
-    failures: z3.number()
+  z2.object({
+    attempts: z2.number(),
+    failures: z2.number()
   })
 );
 
@@ -214,226 +173,258 @@ var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
   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(),
+var rooCodeEventsSchema = z3.object({
+  ["taskCreated" /* TaskCreated */]: z3.tuple([z3.string()]),
+  ["taskStarted" /* TaskStarted */]: z3.tuple([z3.string()]),
+  ["taskCompleted" /* TaskCompleted */]: z3.tuple([
+    z3.string(),
     tokenUsageSchema,
     toolUsageSchema,
-    z4.object({
-      isSubtask: z4.boolean()
+    z3.object({
+      isSubtask: z3.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()]),
-  ["taskInteractive" /* TaskInteractive */]: z4.tuple([z4.string()]),
-  ["taskResumable" /* TaskResumable */]: 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")]),
+  ["taskAborted" /* TaskAborted */]: z3.tuple([z3.string()]),
+  ["taskFocused" /* TaskFocused */]: z3.tuple([z3.string()]),
+  ["taskUnfocused" /* TaskUnfocused */]: z3.tuple([z3.string()]),
+  ["taskActive" /* TaskActive */]: z3.tuple([z3.string()]),
+  ["taskInteractive" /* TaskInteractive */]: z3.tuple([z3.string()]),
+  ["taskResumable" /* TaskResumable */]: z3.tuple([z3.string()]),
+  ["taskIdle" /* TaskIdle */]: z3.tuple([z3.string()]),
+  ["taskPaused" /* TaskPaused */]: z3.tuple([z3.string()]),
+  ["taskUnpaused" /* TaskUnpaused */]: z3.tuple([z3.string()]),
+  ["taskSpawned" /* TaskSpawned */]: z3.tuple([z3.string(), z3.string()]),
+  ["message" /* Message */]: z3.tuple([
+    z3.object({
+      taskId: z3.string(),
+      action: z3.union([z3.literal("created"), z3.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])
+  ["taskModeSwitched" /* TaskModeSwitched */]: z3.tuple([z3.string(), z3.string()]),
+  ["taskAskResponded" /* TaskAskResponded */]: z3.tuple([z3.string()]),
+  ["taskToolFailed" /* TaskToolFailed */]: z3.tuple([z3.string(), toolNamesSchema, z3.string()]),
+  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z3.tuple([z3.string(), tokenUsageSchema])
 });
-var taskEventSchema = z4.discriminatedUnion("eventName", [
+var taskEventSchema = z3.discriminatedUnion("eventName", [
   // Task Provider Lifecycle
-  z4.object({
-    eventName: z4.literal("taskCreated" /* TaskCreated */),
+  z3.object({
+    eventName: z3.literal("taskCreated" /* TaskCreated */),
     payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
   // Task Lifecycle
-  z4.object({
-    eventName: z4.literal("taskStarted" /* TaskStarted */),
+  z3.object({
+    eventName: z3.literal("taskStarted" /* TaskStarted */),
     payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskCompleted" /* TaskCompleted */),
+  z3.object({
+    eventName: z3.literal("taskCompleted" /* TaskCompleted */),
     payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskAborted" /* TaskAborted */),
+  z3.object({
+    eventName: z3.literal("taskAborted" /* TaskAborted */),
     payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskFocused" /* TaskFocused */),
+  z3.object({
+    eventName: z3.literal("taskFocused" /* TaskFocused */),
     payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskUnfocused" /* TaskUnfocused */),
+  z3.object({
+    eventName: z3.literal("taskUnfocused" /* TaskUnfocused */),
     payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskActive" /* TaskActive */),
+  z3.object({
+    eventName: z3.literal("taskActive" /* TaskActive */),
     payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskInteractive" /* TaskInteractive */),
+  z3.object({
+    eventName: z3.literal("taskInteractive" /* TaskInteractive */),
     payload: rooCodeEventsSchema.shape["taskInteractive" /* TaskInteractive */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskResumable" /* TaskResumable */),
+  z3.object({
+    eventName: z3.literal("taskResumable" /* TaskResumable */),
     payload: rooCodeEventsSchema.shape["taskResumable" /* TaskResumable */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskIdle" /* TaskIdle */),
+  z3.object({
+    eventName: z3.literal("taskIdle" /* TaskIdle */),
     payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
   // Subtask Lifecycle
-  z4.object({
-    eventName: z4.literal("taskPaused" /* TaskPaused */),
+  z3.object({
+    eventName: z3.literal("taskPaused" /* TaskPaused */),
     payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskUnpaused" /* TaskUnpaused */),
+  z3.object({
+    eventName: z3.literal("taskUnpaused" /* TaskUnpaused */),
     payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskSpawned" /* TaskSpawned */),
+  z3.object({
+    eventName: z3.literal("taskSpawned" /* TaskSpawned */),
     payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
   // Task Execution
-  z4.object({
-    eventName: z4.literal("message" /* Message */),
+  z3.object({
+    eventName: z3.literal("message" /* Message */),
     payload: rooCodeEventsSchema.shape["message" /* Message */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskModeSwitched" /* TaskModeSwitched */),
+  z3.object({
+    eventName: z3.literal("taskModeSwitched" /* TaskModeSwitched */),
     payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskAskResponded" /* TaskAskResponded */),
+  z3.object({
+    eventName: z3.literal("taskAskResponded" /* TaskAskResponded */),
     payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
   // Task Analytics
-  z4.object({
-    eventName: z4.literal("taskToolFailed" /* TaskToolFailed */),
+  z3.object({
+    eventName: z3.literal("taskToolFailed" /* TaskToolFailed */),
     payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
-  z4.object({
-    eventName: z4.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
+  z3.object({
+    eventName: z3.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
     payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
-    taskId: z4.number().optional()
+    taskId: z3.number().optional()
   }),
   // Evals
-  z4.object({
-    eventName: z4.literal("evalPass" /* EvalPass */),
-    payload: z4.undefined(),
-    taskId: z4.number()
+  z3.object({
+    eventName: z3.literal("evalPass" /* EvalPass */),
+    payload: z3.undefined(),
+    taskId: z3.number()
   }),
-  z4.object({
-    eventName: z4.literal("evalFail" /* EvalFail */),
-    payload: z4.undefined(),
-    taskId: z4.number()
+  z3.object({
+    eventName: z3.literal("evalFail" /* EvalFail */),
+    payload: z3.undefined(),
+    taskId: z3.number()
   })
 ]);
 
-// src/experiment.ts
-import { z as z5 } from "zod";
-var experimentIds = [
-  "powerSteering",
-  "multiFileApplyDiff",
-  "preventFocusDisruption",
-  "imageGeneration"
-];
-var experimentIdsSchema = z5.enum(experimentIds);
-var experimentsSchema = z5.object({
-  powerSteering: z5.boolean().optional(),
-  multiFileApplyDiff: z5.boolean().optional(),
-  preventFocusDisruption: z5.boolean().optional(),
-  imageGeneration: z5.boolean().optional()
-});
-
-// src/followup.ts
-import { z as z6 } from "zod";
-var suggestionItemSchema = z6.object({
-  answer: z6.string(),
-  mode: z6.string().optional()
-});
-var followUpDataSchema = z6.object({
-  question: z6.string().optional(),
-  suggest: z6.array(suggestionItemSchema).optional()
+// src/task.ts
+import { z as z4 } from "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 = z4.object({
+  task: z4.string().optional(),
+  images: z4.array(z4.string()).optional()
 });
 
 // src/global-settings.ts
 import { z as z13 } from "zod";
 
 // src/provider-settings.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 
 // src/model.ts
-import { z as z7 } from "zod";
+import { z as z5 } from "zod";
 var reasoningEfforts = ["low", "medium", "high"];
-var reasoningEffortsSchema = z7.enum(reasoningEfforts);
-var reasoningEffortWithMinimalSchema = z7.union([reasoningEffortsSchema, z7.literal("minimal")]);
+var reasoningEffortsSchema = z5.enum(reasoningEfforts);
+var reasoningEffortWithMinimalSchema = z5.union([reasoningEffortsSchema, z5.literal("minimal")]);
 var verbosityLevels = ["low", "medium", "high"];
-var verbosityLevelsSchema = z7.enum(verbosityLevels);
+var verbosityLevelsSchema = z5.enum(verbosityLevels);
 var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
-var modelParametersSchema = z7.enum(modelParameters);
+var modelParametersSchema = z5.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(),
+var modelInfoSchema = z5.object({
+  maxTokens: z5.number().nullish(),
+  maxThinkingTokens: z5.number().nullish(),
+  contextWindow: z5.number(),
+  supportsImages: z5.boolean().optional(),
+  supportsComputerUse: z5.boolean().optional(),
+  supportsPromptCache: z5.boolean(),
   // Capability flag to indicate whether the model supports an output verbosity parameter
-  supportsVerbosity: z7.boolean().optional(),
-  supportsReasoningBudget: z7.boolean().optional(),
+  supportsVerbosity: z5.boolean().optional(),
+  supportsReasoningBudget: z5.boolean().optional(),
   // Capability flag to indicate whether the model supports temperature parameter
-  supportsTemperature: 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(),
+  supportsTemperature: z5.boolean().optional(),
+  requiredReasoningBudget: z5.boolean().optional(),
+  supportsReasoningEffort: z5.boolean().optional(),
+  supportedParameters: z5.array(modelParametersSchema).optional(),
+  inputPrice: z5.number().optional(),
+  outputPrice: z5.number().optional(),
+  cacheWritesPrice: z5.number().optional(),
+  cacheReadsPrice: z5.number().optional(),
+  description: z5.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()
+  minTokensPerCachePoint: z5.number().optional(),
+  maxCachePoints: z5.number().optional(),
+  cachableFields: z5.array(z5.string()).optional(),
+  tiers: z5.array(
+    z5.object({
+      contextWindow: z5.number(),
+      inputPrice: z5.number().optional(),
+      outputPrice: z5.number().optional(),
+      cacheWritesPrice: z5.number().optional(),
+      cacheReadsPrice: z5.number().optional()
     })
   ).optional()
 });
 
+// src/codebase-index.ts
+import { z as z6 } from "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 = z6.object({
+  codebaseIndexEnabled: z6.boolean().optional(),
+  codebaseIndexQdrantUrl: z6.string().optional(),
+  codebaseIndexEmbedderProvider: z6.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral", "vercel-ai-gateway"]).optional(),
+  codebaseIndexEmbedderBaseUrl: z6.string().optional(),
+  codebaseIndexEmbedderModelId: z6.string().optional(),
+  codebaseIndexEmbedderModelDimension: z6.number().optional(),
+  codebaseIndexSearchMinScore: z6.number().min(0).max(1).optional(),
+  codebaseIndexSearchMaxResults: z6.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
+  // OpenAI Compatible specific fields
+  codebaseIndexOpenAiCompatibleBaseUrl: z6.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: z6.number().optional()
+});
+var codebaseIndexModelsSchema = z6.object({
+  openai: z6.record(z6.string(), z6.object({ dimension: z6.number() })).optional(),
+  ollama: z6.record(z6.string(), z6.object({ dimension: z6.number() })).optional(),
+  "openai-compatible": z6.record(z6.string(), z6.object({ dimension: z6.number() })).optional(),
+  gemini: z6.record(z6.string(), z6.object({ dimension: z6.number() })).optional(),
+  mistral: z6.record(z6.string(), z6.object({ dimension: z6.number() })).optional(),
+  "vercel-ai-gateway": z6.record(z6.string(), z6.object({ dimension: z6.number() })).optional()
+});
+var codebaseIndexProviderSchema = z6.object({
+  codeIndexOpenAiKey: z6.string().optional(),
+  codeIndexQdrantApiKey: z6.string().optional(),
+  codebaseIndexOpenAiCompatibleBaseUrl: z6.string().optional(),
+  codebaseIndexOpenAiCompatibleApiKey: z6.string().optional(),
+  codebaseIndexOpenAiCompatibleModelDimension: z6.number().optional(),
+  codebaseIndexGeminiApiKey: z6.string().optional(),
+  codebaseIndexMistralApiKey: z6.string().optional(),
+  codebaseIndexVercelAiGatewayApiKey: z6.string().optional()
+});
+
 // src/providers/anthropic.ts
 var anthropicDefaultModelId = "claude-sonnet-4-20250514";
 var anthropicModels = {
@@ -3613,253 +3604,253 @@ var providerNames = [
   "roo",
   "vercel-ai-gateway"
 ];
-var providerNamesSchema = z8.enum(providerNames);
-var providerSettingsEntrySchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
+var providerNamesSchema = z7.enum(providerNames);
+var providerSettingsEntrySchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
   apiProvider: providerNamesSchema.optional(),
-  modelId: z8.string().optional()
+  modelId: z7.string().optional()
 });
 var DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3;
-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(),
+var baseProviderSettingsSchema = z7.object({
+  includeMaxTokens: z7.boolean().optional(),
+  diffEnabled: z7.boolean().optional(),
+  todoListEnabled: z7.boolean().optional(),
+  fuzzyMatchThreshold: z7.number().optional(),
+  modelTemperature: z7.number().nullish(),
+  rateLimitSeconds: z7.number().optional(),
+  consecutiveMistakeLimit: z7.number().min(0).optional(),
   // Model reasoning.
-  enableReasoningEffort: z8.boolean().optional(),
+  enableReasoningEffort: z7.boolean().optional(),
   reasoningEffort: reasoningEffortWithMinimalSchema.optional(),
-  modelMaxTokens: z8.number().optional(),
-  modelMaxThinkingTokens: z8.number().optional(),
+  modelMaxTokens: z7.number().optional(),
+  modelMaxThinkingTokens: z7.number().optional(),
   // Model verbosity.
   verbosity: verbosityLevelsSchema.optional()
 });
 var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
-  apiModelId: z8.string().optional()
+  apiModelId: z7.string().optional()
 });
 var anthropicSchema = apiModelIdProviderModelSchema.extend({
-  apiKey: z8.string().optional(),
-  anthropicBaseUrl: z8.string().optional(),
-  anthropicUseAuthToken: z8.boolean().optional(),
-  anthropicBeta1MContext: z8.boolean().optional()
+  apiKey: z7.string().optional(),
+  anthropicBaseUrl: z7.string().optional(),
+  anthropicUseAuthToken: z7.boolean().optional(),
+  anthropicBeta1MContext: z7.boolean().optional()
   // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var claudeCodeSchema = apiModelIdProviderModelSchema.extend({
-  claudeCodePath: z8.string().optional(),
-  claudeCodeMaxOutputTokens: z8.number().int().min(1).max(2e5).optional()
+  claudeCodePath: z7.string().optional(),
+  claudeCodeMaxOutputTokens: z7.number().int().min(1).max(2e5).optional()
 });
 var glamaSchema = baseProviderSettingsSchema.extend({
-  glamaModelId: z8.string().optional(),
-  glamaApiKey: z8.string().optional()
+  glamaModelId: z7.string().optional(),
+  glamaApiKey: z7.string().optional()
 });
 var openRouterSchema = baseProviderSettingsSchema.extend({
-  openRouterApiKey: z8.string().optional(),
-  openRouterModelId: z8.string().optional(),
-  openRouterBaseUrl: z8.string().optional(),
-  openRouterSpecificProvider: z8.string().optional(),
-  openRouterUseMiddleOutTransform: z8.boolean().optional(),
+  openRouterApiKey: z7.string().optional(),
+  openRouterModelId: z7.string().optional(),
+  openRouterBaseUrl: z7.string().optional(),
+  openRouterSpecificProvider: z7.string().optional(),
+  openRouterUseMiddleOutTransform: z7.boolean().optional(),
   // Image generation settings (experimental)
-  openRouterImageGenerationSettings: z8.object({
-    openRouterApiKey: z8.string().optional(),
-    selectedModel: z8.string().optional()
+  openRouterImageGenerationSettings: z7.object({
+    openRouterApiKey: z7.string().optional(),
+    selectedModel: z7.string().optional()
   }).optional()
 });
 var bedrockSchema = apiModelIdProviderModelSchema.extend({
-  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()
+  awsAccessKey: z7.string().optional(),
+  awsSecretKey: z7.string().optional(),
+  awsSessionToken: z7.string().optional(),
+  awsRegion: z7.string().optional(),
+  awsUseCrossRegionInference: z7.boolean().optional(),
+  awsUsePromptCache: z7.boolean().optional(),
+  awsProfile: z7.string().optional(),
+  awsUseProfile: z7.boolean().optional(),
+  awsApiKey: z7.string().optional(),
+  awsUseApiKey: z7.boolean().optional(),
+  awsCustomArn: z7.string().optional(),
+  awsModelContextWindow: z7.number().optional(),
+  awsBedrockEndpointEnabled: z7.boolean().optional(),
+  awsBedrockEndpoint: z7.string().optional(),
+  awsBedrock1MContext: z7.boolean().optional()
   // Enable 'context-1m-2025-08-07' beta for 1M context window
 });
 var vertexSchema = apiModelIdProviderModelSchema.extend({
-  vertexKeyFile: z8.string().optional(),
-  vertexJsonCredentials: z8.string().optional(),
-  vertexProjectId: z8.string().optional(),
-  vertexRegion: z8.string().optional(),
-  enableUrlContext: z8.boolean().optional(),
-  enableGrounding: z8.boolean().optional()
+  vertexKeyFile: z7.string().optional(),
+  vertexJsonCredentials: z7.string().optional(),
+  vertexProjectId: z7.string().optional(),
+  vertexRegion: z7.string().optional(),
+  enableUrlContext: z7.boolean().optional(),
+  enableGrounding: z7.boolean().optional()
 });
 var openAiSchema = baseProviderSettingsSchema.extend({
-  openAiBaseUrl: z8.string().optional(),
-  openAiApiKey: z8.string().optional(),
-  openAiLegacyFormat: z8.boolean().optional(),
-  openAiR1FormatEnabled: z8.boolean().optional(),
-  openAiModelId: z8.string().optional(),
+  openAiBaseUrl: z7.string().optional(),
+  openAiApiKey: z7.string().optional(),
+  openAiLegacyFormat: z7.boolean().optional(),
+  openAiR1FormatEnabled: z7.boolean().optional(),
+  openAiModelId: z7.string().optional(),
   openAiCustomModelInfo: modelInfoSchema.nullish(),
-  openAiUseAzure: z8.boolean().optional(),
-  azureApiVersion: z8.string().optional(),
-  openAiStreamingEnabled: z8.boolean().optional(),
-  openAiHostHeader: z8.string().optional(),
+  openAiUseAzure: z7.boolean().optional(),
+  azureApiVersion: z7.string().optional(),
+  openAiStreamingEnabled: z7.boolean().optional(),
+  openAiHostHeader: z7.string().optional(),
   // Keep temporarily for backward compatibility during migration.
-  openAiHeaders: z8.record(z8.string(), z8.string()).optional()
+  openAiHeaders: z7.record(z7.string(), z7.string()).optional()
 });
 var ollamaSchema = baseProviderSettingsSchema.extend({
-  ollamaModelId: z8.string().optional(),
-  ollamaBaseUrl: z8.string().optional()
+  ollamaModelId: z7.string().optional(),
+  ollamaBaseUrl: z7.string().optional()
 });
 var vsCodeLmSchema = baseProviderSettingsSchema.extend({
-  vsCodeLmModelSelector: z8.object({
-    vendor: z8.string().optional(),
-    family: z8.string().optional(),
-    version: z8.string().optional(),
-    id: z8.string().optional()
+  vsCodeLmModelSelector: z7.object({
+    vendor: z7.string().optional(),
+    family: z7.string().optional(),
+    version: z7.string().optional(),
+    id: z7.string().optional()
   }).optional()
 });
 var lmStudioSchema = baseProviderSettingsSchema.extend({
-  lmStudioModelId: z8.string().optional(),
-  lmStudioBaseUrl: z8.string().optional(),
-  lmStudioDraftModelId: z8.string().optional(),
-  lmStudioSpeculativeDecodingEnabled: z8.boolean().optional()
+  lmStudioModelId: z7.string().optional(),
+  lmStudioBaseUrl: z7.string().optional(),
+  lmStudioDraftModelId: z7.string().optional(),
+  lmStudioSpeculativeDecodingEnabled: z7.boolean().optional()
 });
 var geminiSchema = apiModelIdProviderModelSchema.extend({
-  geminiApiKey: z8.string().optional(),
-  googleGeminiBaseUrl: z8.string().optional(),
-  enableUrlContext: z8.boolean().optional(),
-  enableGrounding: z8.boolean().optional()
+  geminiApiKey: z7.string().optional(),
+  googleGeminiBaseUrl: z7.string().optional(),
+  enableUrlContext: z7.boolean().optional(),
+  enableGrounding: z7.boolean().optional()
 });
 var geminiCliSchema = apiModelIdProviderModelSchema.extend({
-  geminiCliOAuthPath: z8.string().optional(),
-  geminiCliProjectId: z8.string().optional()
+  geminiCliOAuthPath: z7.string().optional(),
+  geminiCliProjectId: z7.string().optional()
 });
 var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
-  openAiNativeApiKey: z8.string().optional(),
-  openAiNativeBaseUrl: z8.string().optional()
+  openAiNativeApiKey: z7.string().optional(),
+  openAiNativeBaseUrl: z7.string().optional()
 });
 var mistralSchema = apiModelIdProviderModelSchema.extend({
-  mistralApiKey: z8.string().optional(),
-  mistralCodestralUrl: z8.string().optional()
+  mistralApiKey: z7.string().optional(),
+  mistralCodestralUrl: z7.string().optional()
 });
 var deepSeekSchema = apiModelIdProviderModelSchema.extend({
-  deepSeekBaseUrl: z8.string().optional(),
-  deepSeekApiKey: z8.string().optional()
+  deepSeekBaseUrl: z7.string().optional(),
+  deepSeekApiKey: z7.string().optional()
 });
 var doubaoSchema = apiModelIdProviderModelSchema.extend({
-  doubaoBaseUrl: z8.string().optional(),
-  doubaoApiKey: z8.string().optional()
+  doubaoBaseUrl: z7.string().optional(),
+  doubaoApiKey: z7.string().optional()
 });
 var moonshotSchema = apiModelIdProviderModelSchema.extend({
-  moonshotBaseUrl: z8.union([z8.literal("https://api.moonshot.ai/v1"), z8.literal("https://api.moonshot.cn/v1")]).optional(),
-  moonshotApiKey: z8.string().optional()
+  moonshotBaseUrl: z7.union([z7.literal("https://api.moonshot.ai/v1"), z7.literal("https://api.moonshot.cn/v1")]).optional(),
+  moonshotApiKey: z7.string().optional()
 });
 var unboundSchema = baseProviderSettingsSchema.extend({
-  unboundApiKey: z8.string().optional(),
-  unboundModelId: z8.string().optional()
+  unboundApiKey: z7.string().optional(),
+  unboundModelId: z7.string().optional()
 });
 var requestySchema = baseProviderSettingsSchema.extend({
-  requestyBaseUrl: z8.string().optional(),
-  requestyApiKey: z8.string().optional(),
-  requestyModelId: z8.string().optional()
+  requestyBaseUrl: z7.string().optional(),
+  requestyApiKey: z7.string().optional(),
+  requestyModelId: z7.string().optional()
 });
 var humanRelaySchema = baseProviderSettingsSchema;
 var fakeAiSchema = baseProviderSettingsSchema.extend({
-  fakeAi: z8.unknown().optional()
+  fakeAi: z7.unknown().optional()
 });
 var xaiSchema = apiModelIdProviderModelSchema.extend({
-  xaiApiKey: z8.string().optional()
+  xaiApiKey: z7.string().optional()
 });
 var groqSchema = apiModelIdProviderModelSchema.extend({
-  groqApiKey: z8.string().optional()
+  groqApiKey: z7.string().optional()
 });
 var huggingFaceSchema = baseProviderSettingsSchema.extend({
-  huggingFaceApiKey: z8.string().optional(),
-  huggingFaceModelId: z8.string().optional(),
-  huggingFaceInferenceProvider: z8.string().optional()
+  huggingFaceApiKey: z7.string().optional(),
+  huggingFaceModelId: z7.string().optional(),
+  huggingFaceInferenceProvider: z7.string().optional()
 });
 var chutesSchema = apiModelIdProviderModelSchema.extend({
-  chutesApiKey: z8.string().optional()
+  chutesApiKey: z7.string().optional()
 });
 var litellmSchema = baseProviderSettingsSchema.extend({
-  litellmBaseUrl: z8.string().optional(),
-  litellmApiKey: z8.string().optional(),
-  litellmModelId: z8.string().optional(),
-  litellmUsePromptCache: z8.boolean().optional()
+  litellmBaseUrl: z7.string().optional(),
+  litellmApiKey: z7.string().optional(),
+  litellmModelId: z7.string().optional(),
+  litellmUsePromptCache: z7.boolean().optional()
 });
 var cerebrasSchema = apiModelIdProviderModelSchema.extend({
-  cerebrasApiKey: z8.string().optional()
+  cerebrasApiKey: z7.string().optional()
 });
 var sambaNovaSchema = apiModelIdProviderModelSchema.extend({
-  sambaNovaApiKey: z8.string().optional()
+  sambaNovaApiKey: z7.string().optional()
 });
 var zaiSchema = apiModelIdProviderModelSchema.extend({
-  zaiApiKey: z8.string().optional(),
-  zaiApiLine: z8.union([z8.literal("china"), z8.literal("international")]).optional()
+  zaiApiKey: z7.string().optional(),
+  zaiApiLine: z7.union([z7.literal("china"), z7.literal("international")]).optional()
 });
 var fireworksSchema = apiModelIdProviderModelSchema.extend({
-  fireworksApiKey: z8.string().optional()
+  fireworksApiKey: z7.string().optional()
 });
 var featherlessSchema = apiModelIdProviderModelSchema.extend({
-  featherlessApiKey: z8.string().optional()
+  featherlessApiKey: z7.string().optional()
 });
 var ioIntelligenceSchema = apiModelIdProviderModelSchema.extend({
-  ioIntelligenceModelId: z8.string().optional(),
-  ioIntelligenceApiKey: z8.string().optional()
+  ioIntelligenceModelId: z7.string().optional(),
+  ioIntelligenceApiKey: z7.string().optional()
 });
 var qwenCodeSchema = apiModelIdProviderModelSchema.extend({
-  qwenCodeOauthPath: z8.string().optional()
+  qwenCodeOauthPath: z7.string().optional()
 });
 var rooSchema = apiModelIdProviderModelSchema.extend({
   // No additional fields needed - uses cloud authentication
 });
 var vercelAiGatewaySchema = baseProviderSettingsSchema.extend({
-  vercelAiGatewayApiKey: z8.string().optional(),
-  vercelAiGatewayModelId: z8.string().optional()
+  vercelAiGatewayApiKey: z7.string().optional(),
+  vercelAiGatewayModelId: z7.string().optional()
 });
-var defaultSchema = z8.object({
-  apiProvider: z8.undefined()
+var defaultSchema = z7.object({
+  apiProvider: z7.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") })),
-  featherlessSchema.merge(z8.object({ apiProvider: z8.literal("featherless") })),
-  ioIntelligenceSchema.merge(z8.object({ apiProvider: z8.literal("io-intelligence") })),
-  qwenCodeSchema.merge(z8.object({ apiProvider: z8.literal("qwen-code") })),
-  rooSchema.merge(z8.object({ apiProvider: z8.literal("roo") })),
-  vercelAiGatewaySchema.merge(z8.object({ apiProvider: z8.literal("vercel-ai-gateway") })),
+var providerSettingsSchemaDiscriminated = z7.discriminatedUnion("apiProvider", [
+  anthropicSchema.merge(z7.object({ apiProvider: z7.literal("anthropic") })),
+  claudeCodeSchema.merge(z7.object({ apiProvider: z7.literal("claude-code") })),
+  glamaSchema.merge(z7.object({ apiProvider: z7.literal("glama") })),
+  openRouterSchema.merge(z7.object({ apiProvider: z7.literal("openrouter") })),
+  bedrockSchema.merge(z7.object({ apiProvider: z7.literal("bedrock") })),
+  vertexSchema.merge(z7.object({ apiProvider: z7.literal("vertex") })),
+  openAiSchema.merge(z7.object({ apiProvider: z7.literal("openai") })),
+  ollamaSchema.merge(z7.object({ apiProvider: z7.literal("ollama") })),
+  vsCodeLmSchema.merge(z7.object({ apiProvider: z7.literal("vscode-lm") })),
+  lmStudioSchema.merge(z7.object({ apiProvider: z7.literal("lmstudio") })),
+  geminiSchema.merge(z7.object({ apiProvider: z7.literal("gemini") })),
+  geminiCliSchema.merge(z7.object({ apiProvider: z7.literal("gemini-cli") })),
+  openAiNativeSchema.merge(z7.object({ apiProvider: z7.literal("openai-native") })),
+  mistralSchema.merge(z7.object({ apiProvider: z7.literal("mistral") })),
+  deepSeekSchema.merge(z7.object({ apiProvider: z7.literal("deepseek") })),
+  doubaoSchema.merge(z7.object({ apiProvider: z7.literal("doubao") })),
+  moonshotSchema.merge(z7.object({ apiProvider: z7.literal("moonshot") })),
+  unboundSchema.merge(z7.object({ apiProvider: z7.literal("unbound") })),
+  requestySchema.merge(z7.object({ apiProvider: z7.literal("requesty") })),
+  humanRelaySchema.merge(z7.object({ apiProvider: z7.literal("human-relay") })),
+  fakeAiSchema.merge(z7.object({ apiProvider: z7.literal("fake-ai") })),
+  xaiSchema.merge(z7.object({ apiProvider: z7.literal("xai") })),
+  groqSchema.merge(z7.object({ apiProvider: z7.literal("groq") })),
+  huggingFaceSchema.merge(z7.object({ apiProvider: z7.literal("huggingface") })),
+  chutesSchema.merge(z7.object({ apiProvider: z7.literal("chutes") })),
+  litellmSchema.merge(z7.object({ apiProvider: z7.literal("litellm") })),
+  cerebrasSchema.merge(z7.object({ apiProvider: z7.literal("cerebras") })),
+  sambaNovaSchema.merge(z7.object({ apiProvider: z7.literal("sambanova") })),
+  zaiSchema.merge(z7.object({ apiProvider: z7.literal("zai") })),
+  fireworksSchema.merge(z7.object({ apiProvider: z7.literal("fireworks") })),
+  featherlessSchema.merge(z7.object({ apiProvider: z7.literal("featherless") })),
+  ioIntelligenceSchema.merge(z7.object({ apiProvider: z7.literal("io-intelligence") })),
+  qwenCodeSchema.merge(z7.object({ apiProvider: z7.literal("qwen-code") })),
+  rooSchema.merge(z7.object({ apiProvider: z7.literal("roo") })),
+  vercelAiGatewaySchema.merge(z7.object({ apiProvider: z7.literal("vercel-ai-gateway") })),
   defaultSchema
 ]);
-var providerSettingsSchema = z8.object({
+var providerSettingsSchema = z7.object({
   apiProvider: providerNamesSchema.optional(),
   ...anthropicSchema.shape,
   ...claudeCodeSchema.shape,
@@ -3898,9 +3889,9 @@ var providerSettingsSchema = z8.object({
   ...vercelAiGatewaySchema.shape,
   ...codebaseIndexProviderSchema.shape
 });
-var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: z8.string().optional() });
+var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: z7.string().optional() });
 var discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
-  z8.object({ id: z8.string().optional() })
+  z7.object({ id: z7.string().optional() })
 );
 var PROVIDER_SETTINGS_KEYS = providerSettingsSchema.keyof().options;
 var MODEL_ID_KEYS = [
@@ -4039,20 +4030,36 @@ var dynamicProviders = [
 var isDynamicProvider = (key) => dynamicProviders.includes(key);
 
 // src/history.ts
+import { z as z8 } from "zod";
+var historyItemSchema = z8.object({
+  id: z8.string(),
+  number: z8.number(),
+  ts: z8.number(),
+  task: z8.string(),
+  tokensIn: z8.number(),
+  tokensOut: z8.number(),
+  cacheWrites: z8.number().optional(),
+  cacheReads: z8.number().optional(),
+  totalCost: z8.number(),
+  size: z8.number().optional(),
+  workspace: z8.string().optional(),
+  mode: z8.string().optional()
+});
+
+// src/experiment.ts
 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()
+var experimentIds = [
+  "powerSteering",
+  "multiFileApplyDiff",
+  "preventFocusDisruption",
+  "imageGeneration"
+];
+var experimentIdsSchema = z9.enum(experimentIds);
+var experimentsSchema = z9.object({
+  powerSteering: z9.boolean().optional(),
+  multiFileApplyDiff: z9.boolean().optional(),
+  preventFocusDisruption: z9.boolean().optional(),
+  imageGeneration: z9.boolean().optional()
 });
 
 // src/telemetry.ts
@@ -4582,8 +4589,370 @@ var EVALS_SETTINGS = {
 };
 var EVALS_TIMEOUT = 5 * 60 * 1e3;
 
-// src/ipc.ts
+// src/marketplace.ts
 import { z as z14 } from "zod";
+var mcpParameterSchema = z14.object({
+  name: z14.string().min(1),
+  key: z14.string().min(1),
+  placeholder: z14.string().optional(),
+  optional: z14.boolean().optional().default(false)
+});
+var mcpInstallationMethodSchema = z14.object({
+  name: z14.string().min(1),
+  content: z14.string().min(1),
+  parameters: z14.array(mcpParameterSchema).optional(),
+  prerequisites: z14.array(z14.string()).optional()
+});
+var marketplaceItemTypeSchema = z14.enum(["mode", "mcp"]);
+var baseMarketplaceItemSchema = z14.object({
+  id: z14.string().min(1),
+  name: z14.string().min(1, "Name is required"),
+  description: z14.string(),
+  author: z14.string().optional(),
+  authorUrl: z14.string().url("Author URL must be a valid URL").optional(),
+  tags: z14.array(z14.string()).optional(),
+  prerequisites: z14.array(z14.string()).optional()
+});
+var modeMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  content: z14.string().min(1)
+  // YAML content for modes
+});
+var mcpMarketplaceItemSchema = baseMarketplaceItemSchema.extend({
+  url: z14.string().url(),
+  // Required url field
+  content: z14.union([z14.string().min(1), z14.array(mcpInstallationMethodSchema)]),
+  // Single config or array of methods
+  parameters: z14.array(mcpParameterSchema).optional()
+});
+var marketplaceItemSchema = z14.discriminatedUnion("type", [
+  // Mode marketplace item
+  modeMarketplaceItemSchema.extend({
+    type: z14.literal("mode")
+  }),
+  // MCP marketplace item
+  mcpMarketplaceItemSchema.extend({
+    type: z14.literal("mcp")
+  })
+]);
+var installMarketplaceItemOptionsSchema = z14.object({
+  target: z14.enum(["global", "project"]).optional().default("project"),
+  parameters: z14.record(z14.string(), z14.any()).optional()
+});
+
+// src/cloud.ts
+var organizationAllowListSchema = z15.object({
+  allowAll: z15.boolean(),
+  providers: z15.record(
+    z15.object({
+      allowAll: z15.boolean(),
+      models: z15.array(z15.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(
+  z15.object({
+    maxOpenTabsContext: z15.number().int().nonnegative().optional(),
+    maxReadFileLine: z15.number().int().gte(-1).optional(),
+    maxWorkspaceFiles: z15.number().int().nonnegative().optional(),
+    terminalCommandDelay: z15.number().int().nonnegative().optional(),
+    terminalOutputLineLimit: z15.number().int().nonnegative().optional(),
+    terminalShellIntegrationTimeout: z15.number().int().nonnegative().optional()
+  })
+);
+var organizationCloudSettingsSchema = z15.object({
+  recordTaskMessages: z15.boolean().optional(),
+  enableTaskSharing: z15.boolean().optional(),
+  taskShareExpirationDays: z15.number().int().positive().optional(),
+  allowMembersViewAllTasks: z15.boolean().optional()
+});
+var organizationSettingsSchema = z15.object({
+  version: z15.number(),
+  cloudSettings: organizationCloudSettingsSchema.optional(),
+  defaultSettings: organizationDefaultSettingsSchema,
+  allowList: organizationAllowListSchema,
+  hiddenMcps: z15.array(z15.string()).optional(),
+  hideMarketplaceMcps: z15.boolean().optional(),
+  mcps: z15.array(mcpMarketplaceItemSchema).optional(),
+  providerProfiles: z15.record(z15.string(), providerSettingsWithIdSchema).optional()
+});
+var userFeaturesSchema = z15.object({
+  roomoteControlEnabled: z15.boolean().optional()
+});
+var userSettingsConfigSchema = z15.object({
+  extensionBridgeEnabled: z15.boolean().optional()
+});
+var userSettingsDataSchema = z15.object({
+  features: userFeaturesSchema,
+  settings: userSettingsConfigSchema,
+  version: z15.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 = z15.object({
+  success: z15.boolean(),
+  shareUrl: z15.string().optional(),
+  error: z15.string().optional(),
+  isNewShare: z15.boolean().optional(),
+  manageUrl: z15.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 = z15.object({
+  taskId: z15.string(),
+  taskStatus: z15.nativeEnum(TaskStatus),
+  ...taskMetadataSchema.shape
+});
+var extensionInstanceSchema = z15.object({
+  instanceId: z15.string(),
+  userId: z15.string(),
+  workspacePath: z15.string(),
+  appProperties: staticAppPropertiesSchema,
+  gitProperties: gitPropertiesSchema.optional(),
+  lastHeartbeat: z15.coerce.number(),
+  task: extensionTaskSchema,
+  taskAsk: clineMessageSchema.optional(),
+  taskHistory: z15.array(z15.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 = z15.discriminatedUnion("type", [
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskCreated),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskStarted),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskCompleted),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskAborted),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskFocused),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskUnfocused),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskActive),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskInteractive),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskResumable),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal(ExtensionBridgeEventName.TaskIdle),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("instance_registered" /* InstanceRegistered */),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("instance_unregistered" /* InstanceUnregistered */),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("heartbeat_updated" /* HeartbeatUpdated */),
+    instance: extensionInstanceSchema,
+    timestamp: z15.number()
+  })
+]);
+var ExtensionBridgeCommandName = /* @__PURE__ */ ((ExtensionBridgeCommandName2) => {
+  ExtensionBridgeCommandName2["StartTask"] = "start_task";
+  ExtensionBridgeCommandName2["StopTask"] = "stop_task";
+  ExtensionBridgeCommandName2["ResumeTask"] = "resume_task";
+  return ExtensionBridgeCommandName2;
+})(ExtensionBridgeCommandName || {});
+var extensionBridgeCommandSchema = z15.discriminatedUnion("type", [
+  z15.object({
+    type: z15.literal("start_task" /* StartTask */),
+    instanceId: z15.string(),
+    payload: z15.object({
+      text: z15.string(),
+      images: z15.array(z15.string()).optional()
+    }),
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("stop_task" /* StopTask */),
+    instanceId: z15.string(),
+    payload: z15.object({ taskId: z15.string() }),
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("resume_task" /* ResumeTask */),
+    instanceId: z15.string(),
+    payload: z15.object({
+      taskId: z15.string()
+    }),
+    timestamp: z15.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 = z15.discriminatedUnion("type", [
+  z15.object({
+    type: z15.literal(TaskBridgeEventName.Message),
+    taskId: z15.string(),
+    action: z15.string(),
+    message: clineMessageSchema
+  }),
+  z15.object({
+    type: z15.literal(TaskBridgeEventName.TaskModeSwitched),
+    taskId: z15.string(),
+    mode: z15.string()
+  }),
+  z15.object({
+    type: z15.literal(TaskBridgeEventName.TaskInteractive),
+    taskId: z15.string()
+  })
+]);
+var TaskBridgeCommandName = /* @__PURE__ */ ((TaskBridgeCommandName2) => {
+  TaskBridgeCommandName2["Message"] = "message";
+  TaskBridgeCommandName2["ApproveAsk"] = "approve_ask";
+  TaskBridgeCommandName2["DenyAsk"] = "deny_ask";
+  return TaskBridgeCommandName2;
+})(TaskBridgeCommandName || {});
+var taskBridgeCommandSchema = z15.discriminatedUnion("type", [
+  z15.object({
+    type: z15.literal("message" /* Message */),
+    taskId: z15.string(),
+    payload: z15.object({
+      text: z15.string(),
+      images: z15.array(z15.string()).optional()
+    }),
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("approve_ask" /* ApproveAsk */),
+    taskId: z15.string(),
+    payload: z15.object({
+      text: z15.string().optional(),
+      images: z15.array(z15.string()).optional()
+    }),
+    timestamp: z15.number()
+  }),
+  z15.object({
+    type: z15.literal("deny_ask" /* DenyAsk */),
+    taskId: z15.string(),
+    payload: z15.object({
+      text: z15.string().optional(),
+      images: z15.array(z15.string()).optional()
+    }),
+    timestamp: z15.number()
+  })
+]);
+var ExtensionSocketEvents = /* @__PURE__ */ ((ExtensionSocketEvents2) => {
+  ExtensionSocketEvents2["CONNECTED"] = "extension:connected";
+  ExtensionSocketEvents2["REGISTER"] = "extension:register";
+  ExtensionSocketEvents2["UNREGISTER"] = "extension:unregister";
+  ExtensionSocketEvents2["HEARTBEAT"] = "extension:heartbeat";
+  ExtensionSocketEvents2["EVENT"] = "extension:event";
+  ExtensionSocketEvents2["RELAYED_EVENT"] = "extension:relayed_event";
+  ExtensionSocketEvents2["COMMAND"] = "extension:command";
+  ExtensionSocketEvents2["RELAYED_COMMAND"] = "extension:relayed_command";
+  return ExtensionSocketEvents2;
+})(ExtensionSocketEvents || {});
+var TaskSocketEvents = /* @__PURE__ */ ((TaskSocketEvents2) => {
+  TaskSocketEvents2["JOIN"] = "task:join";
+  TaskSocketEvents2["LEAVE"] = "task:leave";
+  TaskSocketEvents2["EVENT"] = "task:event";
+  TaskSocketEvents2["RELAYED_EVENT"] = "task:relayed_event";
+  TaskSocketEvents2["COMMAND"] = "task:command";
+  TaskSocketEvents2["RELAYED_COMMAND"] = "task:relayed_command";
+  return TaskSocketEvents2;
+})(TaskSocketEvents || {});
+
+// src/followup.ts
+import { z as z16 } from "zod";
+var suggestionItemSchema = z16.object({
+  answer: z16.string(),
+  mode: z16.string().optional()
+});
+var followUpDataSchema = z16.object({
+  question: z16.string().optional(),
+  suggest: z16.array(suggestionItemSchema).optional()
+});
+
+// src/ipc.ts
+import { z as z17 } from "zod";
 var IpcMessageType = /* @__PURE__ */ ((IpcMessageType2) => {
   IpcMessageType2["Connect"] = "Connect";
   IpcMessageType2["Disconnect"] = "Disconnect";
@@ -4597,10 +4966,10 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
   IpcOrigin2["Server"] = "server";
   return IpcOrigin2;
 })(IpcOrigin || {});
-var ackSchema = z14.object({
-  clientId: z14.string(),
-  pid: z14.number(),
-  ppid: z14.number()
+var ackSchema = z17.object({
+  clientId: z17.string(),
+  pid: z17.number(),
+  ppid: z17.number()
 });
 var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -4609,122 +4978,72 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["ResumeTask"] = "ResumeTask";
   return TaskCommandName2;
 })(TaskCommandName || {});
-var taskCommandSchema = z14.discriminatedUnion("commandName", [
-  z14.object({
-    commandName: z14.literal("StartNewTask" /* StartNewTask */),
-    data: z14.object({
+var taskCommandSchema = z17.discriminatedUnion("commandName", [
+  z17.object({
+    commandName: z17.literal("StartNewTask" /* StartNewTask */),
+    data: z17.object({
       configuration: rooCodeSettingsSchema,
-      text: z14.string(),
-      images: z14.array(z14.string()).optional(),
-      newTab: z14.boolean().optional()
+      text: z17.string(),
+      images: z17.array(z17.string()).optional(),
+      newTab: z17.boolean().optional()
     })
   }),
-  z14.object({
-    commandName: z14.literal("CancelTask" /* CancelTask */),
-    data: z14.string()
+  z17.object({
+    commandName: z17.literal("CancelTask" /* CancelTask */),
+    data: z17.string()
   }),
-  z14.object({
-    commandName: z14.literal("CloseTask" /* CloseTask */),
-    data: z14.string()
+  z17.object({
+    commandName: z17.literal("CloseTask" /* CloseTask */),
+    data: z17.string()
   }),
-  z14.object({
-    commandName: z14.literal("ResumeTask" /* ResumeTask */),
-    data: z14.string()
+  z17.object({
+    commandName: z17.literal("ResumeTask" /* ResumeTask */),
+    data: z17.string()
   })
 ]);
-var ipcMessageSchema = z14.discriminatedUnion("type", [
-  z14.object({
-    type: z14.literal("Ack" /* Ack */),
-    origin: z14.literal("server" /* Server */),
+var ipcMessageSchema = z17.discriminatedUnion("type", [
+  z17.object({
+    type: z17.literal("Ack" /* Ack */),
+    origin: z17.literal("server" /* Server */),
     data: ackSchema
   }),
-  z14.object({
-    type: z14.literal("TaskCommand" /* TaskCommand */),
-    origin: z14.literal("client" /* Client */),
-    clientId: z14.string(),
+  z17.object({
+    type: z17.literal("TaskCommand" /* TaskCommand */),
+    origin: z17.literal("client" /* Client */),
+    clientId: z17.string(),
     data: taskCommandSchema
   }),
-  z14.object({
-    type: z14.literal("TaskEvent" /* TaskEvent */),
-    origin: z14.literal("server" /* Server */),
-    relayClientId: z14.string().optional(),
+  z17.object({
+    type: z17.literal("TaskEvent" /* TaskEvent */),
+    origin: z17.literal("server" /* Server */),
+    relayClientId: z17.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 z16 } from "zod";
-var mcpExecutionStatusSchema = z16.discriminatedUnion("status", [
-  z16.object({
-    executionId: z16.string(),
-    status: z16.literal("started"),
-    serverName: z16.string(),
-    toolName: z16.string()
+import { z as z18 } from "zod";
+var mcpExecutionStatusSchema = z18.discriminatedUnion("status", [
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("started"),
+    serverName: z18.string(),
+    toolName: z18.string()
   }),
-  z16.object({
-    executionId: z16.string(),
-    status: z16.literal("output"),
-    response: z16.string()
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("output"),
+    response: z18.string()
   }),
-  z16.object({
-    executionId: z16.string(),
-    status: z16.literal("completed"),
-    response: z16.string().optional()
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("completed"),
+    response: z18.string().optional()
   }),
-  z16.object({
-    executionId: z16.string(),
-    status: z16.literal("error"),
-    error: z16.string().optional()
+  z18.object({
+    executionId: z18.string(),
+    status: z18.literal("error"),
+    error: z18.string().optional()
   })
 ]);
 
@@ -4733,56 +5052,41 @@ function shouldUseSingleFileRead(modelId) {
   return modelId.includes("grok-code-fast-1");
 }
 
-// src/task.ts
-import { z as z17 } from "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 = z17.object({
-  task: z17.string().optional(),
-  images: z17.array(z17.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 z19 } from "zod";
+var todoStatusSchema = z19.enum(["pending", "in_progress", "completed"]);
+var todoItemSchema = z19.object({
+  id: z19.string(),
+  content: z19.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 z20 } from "zod";
+var commandExecutionStatusSchema = z20.discriminatedUnion("status", [
+  z20.object({
+    executionId: z20.string(),
+    status: z20.literal("started"),
+    pid: z20.number().optional(),
+    command: z20.string()
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("output"),
-    output: z19.string()
+  z20.object({
+    executionId: z20.string(),
+    status: z20.literal("output"),
+    output: z20.string()
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("exited"),
-    exitCode: z19.number().optional()
+  z20.object({
+    executionId: z20.string(),
+    status: z20.literal("exited"),
+    exitCode: z20.number().optional()
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("fallback")
+  z20.object({
+    executionId: z20.string(),
+    status: z20.literal("fallback")
   }),
-  z19.object({
-    executionId: z19.string(),
-    status: z19.literal("timeout")
+  z20.object({
+    executionId: z20.string(),
+    status: z20.literal("timeout")
   })
 ]);
 export {
@@ -4796,6 +5100,7 @@ export {
   BEDROCK_REGIONS,
   CLAUDE_CODE_DEFAULT_MAX_OUTPUT_TOKENS,
   CODEBASE_INDEX_DEFAULTS,
+  ConnectionState,
   DEEP_SEEK_DEFAULT_TEMPERATURE,
   DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
   DEFAULT_MODES,
@@ -4805,10 +5110,14 @@ export {
   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,
@@ -4817,6 +5126,7 @@ export {
   HUGGINGFACE_SLIDER_MIN,
   HUGGINGFACE_SLIDER_STEP,
   HUGGINGFACE_TEMPERATURE_MAX_VALUE,
+  INSTANCE_TTL_SECONDS,
   IO_INTELLIGENCE_CACHE_DURATION,
   IpcMessageType,
   IpcOrigin,
@@ -4833,10 +5143,15 @@ 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,
+  TaskBridgeCommandName,
+  TaskBridgeEventName,
   TaskCommandName,
+  TaskSocketEvents,
   TaskStatus,
   TelemetryEventName,
   VERCEL_AI_GATEWAY_DEFAULT_TEMPERATURE,
@@ -4887,6 +5202,9 @@ export {
   experimentIds,
   experimentIdsSchema,
   experimentsSchema,
+  extensionBridgeCommandSchema,
+  extensionBridgeEventSchema,
+  extensionInstanceSchema,
   featherlessDefaultModelId,
   featherlessModels,
   fireworksDefaultModelId,
@@ -4953,6 +5271,10 @@ export {
   openAiNativeModels,
   openRouterDefaultModelId,
   openRouterDefaultModelInfo,
+  organizationAllowListSchema,
+  organizationCloudSettingsSchema,
+  organizationDefaultSettingsSchema,
+  organizationSettingsSchema,
   promptComponentSchema,
   providerNames,
   providerNamesSchema,
@@ -4975,9 +5297,12 @@ export {
   rooModels,
   sambaNovaDefaultModelId,
   sambaNovaModels,
+  shareResponseSchema,
   shouldUseSingleFileRead,
   staticAppPropertiesSchema,
   suggestionItemSchema,
+  taskBridgeCommandSchema,
+  taskBridgeEventSchema,
   taskCommandSchema,
   taskEventSchema,
   taskMetadataSchema,
@@ -4997,6 +5322,9 @@ export {
   toolUsageSchema,
   unboundDefaultModelId,
   unboundDefaultModelInfo,
+  userFeaturesSchema,
+  userSettingsConfigSchema,
+  userSettingsDataSchema,
   verbosityLevels,
   verbosityLevelsSchema,
   vercelAiGatewayDefaultModelId,