@roo-code/types 1.17.0 → 1.19.0

package/dist/index.js

@@ -1,127 +1,32 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  GLOBAL_SETTINGS_KEYS: () => GLOBAL_SETTINGS_KEYS,
-  GLOBAL_STATE_KEYS: () => GLOBAL_STATE_KEYS,
-  IpcMessageType: () => IpcMessageType,
-  IpcOrigin: () => IpcOrigin,
-  PROVIDER_SETTINGS_KEYS: () => PROVIDER_SETTINGS_KEYS,
-  RooCodeEventName: () => RooCodeEventName,
-  SECRET_STATE_KEYS: () => SECRET_STATE_KEYS,
-  TaskCommandName: () => TaskCommandName,
-  TelemetryEventName: () => TelemetryEventName,
-  ackSchema: () => ackSchema,
-  appPropertiesSchema: () => appPropertiesSchema,
-  clineAskSchema: () => clineAskSchema,
-  clineAsks: () => clineAsks,
-  clineMessageSchema: () => clineMessageSchema,
-  clineSaySchema: () => clineSaySchema,
-  clineSays: () => clineSays,
-  codeActionIds: () => codeActionIds,
-  codebaseIndexConfigSchema: () => codebaseIndexConfigSchema,
-  codebaseIndexModelsSchema: () => codebaseIndexModelsSchema,
-  codebaseIndexProviderSchema: () => codebaseIndexProviderSchema,
-  commandExecutionStatusSchema: () => commandExecutionStatusSchema,
-  commandIds: () => commandIds,
-  contextCondenseSchema: () => contextCondenseSchema,
-  customModePromptsSchema: () => customModePromptsSchema,
-  customModesSettingsSchema: () => customModesSettingsSchema,
-  customSupportPromptsSchema: () => customSupportPromptsSchema,
-  experimentIds: () => experimentIds,
-  experimentIdsSchema: () => experimentIdsSchema,
-  experimentsSchema: () => experimentsSchema,
-  globalSettingsSchema: () => globalSettingsSchema,
-  groupEntrySchema: () => groupEntrySchema,
-  groupOptionsSchema: () => groupOptionsSchema,
-  historyItemSchema: () => historyItemSchema,
-  ipcMessageSchema: () => ipcMessageSchema,
-  isGlobalStateKey: () => isGlobalStateKey,
-  isLanguage: () => isLanguage,
-  isModelParameter: () => isModelParameter,
-  isSecretStateKey: () => isSecretStateKey,
-  keysOf: () => keysOf,
-  languages: () => languages,
-  languagesSchema: () => languagesSchema,
-  modeConfigSchema: () => modeConfigSchema,
-  modelInfoSchema: () => modelInfoSchema,
-  modelParameters: () => modelParameters,
-  modelParametersSchema: () => modelParametersSchema,
-  promptComponentSchema: () => promptComponentSchema,
-  providerNames: () => providerNames,
-  providerNamesSchema: () => providerNamesSchema,
-  providerSettingsEntrySchema: () => providerSettingsEntrySchema,
-  providerSettingsSchema: () => providerSettingsSchema,
-  providerSettingsSchemaDiscriminated: () => providerSettingsSchemaDiscriminated,
-  reasoningEfforts: () => reasoningEfforts,
-  reasoningEffortsSchema: () => reasoningEffortsSchema,
-  rooCodeEventsSchema: () => rooCodeEventsSchema,
-  rooCodeSettingsSchema: () => rooCodeSettingsSchema,
-  rooCodeTelemetryEventSchema: () => rooCodeTelemetryEventSchema,
-  taskCommandSchema: () => taskCommandSchema,
-  taskEventSchema: () => taskEventSchema,
-  taskPropertiesSchema: () => taskPropertiesSchema,
-  telemetryPropertiesSchema: () => telemetryPropertiesSchema,
-  telemetrySettings: () => telemetrySettings,
-  telemetrySettingsSchema: () => telemetrySettingsSchema,
-  terminalActionIds: () => terminalActionIds,
-  tokenUsageSchema: () => tokenUsageSchema,
-  toolGroups: () => toolGroups,
-  toolGroupsSchema: () => toolGroupsSchema,
-  toolNames: () => toolNames,
-  toolNamesSchema: () => toolNamesSchema,
-  toolProgressStatusSchema: () => toolProgressStatusSchema,
-  toolUsageSchema: () => toolUsageSchema
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/codebase-index.ts
-var import_zod = require("zod");
-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"]).optional(),
-  codebaseIndexEmbedderBaseUrl: import_zod.z.string().optional(),
-  codebaseIndexEmbedderModelId: import_zod.z.string().optional()
+import { z } from "zod";
+var codebaseIndexConfigSchema = z.object({
+  codebaseIndexEnabled: z.boolean().optional(),
+  codebaseIndexQdrantUrl: z.string().optional(),
+  codebaseIndexEmbedderProvider: z.enum(["openai", "ollama"]).optional(),
+  codebaseIndexEmbedderBaseUrl: z.string().optional(),
+  codebaseIndexEmbedderModelId: z.string().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()
+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()
 });
-var codebaseIndexProviderSchema = import_zod.z.object({
-  codeIndexOpenAiKey: import_zod.z.string().optional(),
-  codeIndexQdrantApiKey: import_zod.z.string().optional()
+var codebaseIndexProviderSchema = z.object({
+  codeIndexOpenAiKey: z.string().optional(),
+  codeIndexQdrantApiKey: z.string().optional()
 });
 
 // src/experiment.ts
-var import_zod2 = require("zod");
+import { z as z2 } from "zod";
 var experimentIds = ["autoCondenseContext", "powerSteering"];
-var experimentIdsSchema = import_zod2.z.enum(experimentIds);
-var experimentsSchema = import_zod2.z.object({
-  autoCondenseContext: import_zod2.z.boolean(),
-  powerSteering: import_zod2.z.boolean()
+var experimentIdsSchema = z2.enum(experimentIds);
+var experimentsSchema = z2.object({
+  autoCondenseContext: z2.boolean(),
+  powerSteering: z2.boolean()
 });
 
 // src/global-settings.ts
-var import_zod10 = require("zod");
+import { z as z10 } from "zod";
 
 // src/type-fu.ts
 function keysOf() {
@@ -129,42 +34,42 @@ function keysOf() {
 }
 
 // src/provider-settings.ts
-var import_zod4 = require("zod");
+import { z as z4 } from "zod";
 
 // src/model.ts
-var import_zod3 = require("zod");
+import { z as z3 } from "zod";
 var reasoningEfforts = ["low", "medium", "high"];
-var reasoningEffortsSchema = import_zod3.z.enum(reasoningEfforts);
+var reasoningEffortsSchema = z3.enum(reasoningEfforts);
 var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
-var modelParametersSchema = import_zod3.z.enum(modelParameters);
+var modelParametersSchema = z3.enum(modelParameters);
 var isModelParameter = (value) => modelParameters.includes(value);
-var modelInfoSchema = import_zod3.z.object({
-  maxTokens: import_zod3.z.number().nullish(),
-  maxThinkingTokens: import_zod3.z.number().nullish(),
-  contextWindow: import_zod3.z.number(),
-  supportsImages: import_zod3.z.boolean().optional(),
-  supportsComputerUse: import_zod3.z.boolean().optional(),
-  supportsPromptCache: import_zod3.z.boolean(),
-  supportsReasoningBudget: import_zod3.z.boolean().optional(),
-  requiredReasoningBudget: import_zod3.z.boolean().optional(),
-  supportsReasoningEffort: import_zod3.z.boolean().optional(),
-  supportedParameters: import_zod3.z.array(modelParametersSchema).optional(),
-  inputPrice: import_zod3.z.number().optional(),
-  outputPrice: import_zod3.z.number().optional(),
-  cacheWritesPrice: import_zod3.z.number().optional(),
-  cacheReadsPrice: import_zod3.z.number().optional(),
-  description: import_zod3.z.string().optional(),
+var modelInfoSchema = z3.object({
+  maxTokens: z3.number().nullish(),
+  maxThinkingTokens: z3.number().nullish(),
+  contextWindow: z3.number(),
+  supportsImages: z3.boolean().optional(),
+  supportsComputerUse: z3.boolean().optional(),
+  supportsPromptCache: z3.boolean(),
+  supportsReasoningBudget: z3.boolean().optional(),
+  requiredReasoningBudget: z3.boolean().optional(),
+  supportsReasoningEffort: z3.boolean().optional(),
+  supportedParameters: z3.array(modelParametersSchema).optional(),
+  inputPrice: z3.number().optional(),
+  outputPrice: z3.number().optional(),
+  cacheWritesPrice: z3.number().optional(),
+  cacheReadsPrice: z3.number().optional(),
+  description: z3.string().optional(),
   reasoningEffort: reasoningEffortsSchema.optional(),
-  minTokensPerCachePoint: import_zod3.z.number().optional(),
-  maxCachePoints: import_zod3.z.number().optional(),
-  cachableFields: import_zod3.z.array(import_zod3.z.string()).optional(),
-  tiers: import_zod3.z.array(
-    import_zod3.z.object({
-      contextWindow: import_zod3.z.number(),
-      inputPrice: import_zod3.z.number().optional(),
-      outputPrice: import_zod3.z.number().optional(),
-      cacheWritesPrice: import_zod3.z.number().optional(),
-      cacheReadsPrice: import_zod3.z.number().optional()
+  minTokensPerCachePoint: z3.number().optional(),
+  maxCachePoints: z3.number().optional(),
+  cachableFields: z3.array(z3.string()).optional(),
+  tiers: z3.array(
+    z3.object({
+      contextWindow: z3.number(),
+      inputPrice: z3.number().optional(),
+      outputPrice: z3.number().optional(),
+      cacheWritesPrice: z3.number().optional(),
+      cacheReadsPrice: z3.number().optional()
     })
   ).optional()
 });
@@ -193,162 +98,162 @@ var providerNames = [
   "chutes",
   "litellm"
 ];
-var providerNamesSchema = import_zod4.z.enum(providerNames);
-var providerSettingsEntrySchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  name: import_zod4.z.string(),
+var providerNamesSchema = z4.enum(providerNames);
+var providerSettingsEntrySchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
   apiProvider: providerNamesSchema.optional()
 });
-var baseProviderSettingsSchema = import_zod4.z.object({
-  includeMaxTokens: import_zod4.z.boolean().optional(),
-  diffEnabled: import_zod4.z.boolean().optional(),
-  fuzzyMatchThreshold: import_zod4.z.number().optional(),
-  modelTemperature: import_zod4.z.number().nullish(),
-  rateLimitSeconds: import_zod4.z.number().optional(),
+var baseProviderSettingsSchema = z4.object({
+  includeMaxTokens: z4.boolean().optional(),
+  diffEnabled: z4.boolean().optional(),
+  fuzzyMatchThreshold: z4.number().optional(),
+  modelTemperature: z4.number().nullish(),
+  rateLimitSeconds: z4.number().optional(),
   // Model reasoning.
-  enableReasoningEffort: import_zod4.z.boolean().optional(),
+  enableReasoningEffort: z4.boolean().optional(),
   reasoningEffort: reasoningEffortsSchema.optional(),
-  modelMaxTokens: import_zod4.z.number().optional(),
-  modelMaxThinkingTokens: import_zod4.z.number().optional()
+  modelMaxTokens: z4.number().optional(),
+  modelMaxThinkingTokens: z4.number().optional()
 });
 var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
-  apiModelId: import_zod4.z.string().optional()
+  apiModelId: z4.string().optional()
 });
 var anthropicSchema = apiModelIdProviderModelSchema.extend({
-  apiKey: import_zod4.z.string().optional(),
-  anthropicBaseUrl: import_zod4.z.string().optional(),
-  anthropicUseAuthToken: import_zod4.z.boolean().optional()
+  apiKey: z4.string().optional(),
+  anthropicBaseUrl: z4.string().optional(),
+  anthropicUseAuthToken: z4.boolean().optional()
 });
 var glamaSchema = baseProviderSettingsSchema.extend({
-  glamaModelId: import_zod4.z.string().optional(),
-  glamaApiKey: import_zod4.z.string().optional()
+  glamaModelId: z4.string().optional(),
+  glamaApiKey: z4.string().optional()
 });
 var openRouterSchema = baseProviderSettingsSchema.extend({
-  openRouterApiKey: import_zod4.z.string().optional(),
-  openRouterModelId: import_zod4.z.string().optional(),
-  openRouterBaseUrl: import_zod4.z.string().optional(),
-  openRouterSpecificProvider: import_zod4.z.string().optional(),
-  openRouterUseMiddleOutTransform: import_zod4.z.boolean().optional()
+  openRouterApiKey: z4.string().optional(),
+  openRouterModelId: z4.string().optional(),
+  openRouterBaseUrl: z4.string().optional(),
+  openRouterSpecificProvider: z4.string().optional(),
+  openRouterUseMiddleOutTransform: z4.boolean().optional()
 });
 var bedrockSchema = apiModelIdProviderModelSchema.extend({
-  awsAccessKey: import_zod4.z.string().optional(),
-  awsSecretKey: import_zod4.z.string().optional(),
-  awsSessionToken: import_zod4.z.string().optional(),
-  awsRegion: import_zod4.z.string().optional(),
-  awsUseCrossRegionInference: import_zod4.z.boolean().optional(),
-  awsUsePromptCache: import_zod4.z.boolean().optional(),
-  awsProfile: import_zod4.z.string().optional(),
-  awsUseProfile: import_zod4.z.boolean().optional(),
-  awsCustomArn: import_zod4.z.string().optional()
+  awsAccessKey: z4.string().optional(),
+  awsSecretKey: z4.string().optional(),
+  awsSessionToken: z4.string().optional(),
+  awsRegion: z4.string().optional(),
+  awsUseCrossRegionInference: z4.boolean().optional(),
+  awsUsePromptCache: z4.boolean().optional(),
+  awsProfile: z4.string().optional(),
+  awsUseProfile: z4.boolean().optional(),
+  awsCustomArn: z4.string().optional()
 });
 var vertexSchema = apiModelIdProviderModelSchema.extend({
-  vertexKeyFile: import_zod4.z.string().optional(),
-  vertexJsonCredentials: import_zod4.z.string().optional(),
-  vertexProjectId: import_zod4.z.string().optional(),
-  vertexRegion: import_zod4.z.string().optional()
+  vertexKeyFile: z4.string().optional(),
+  vertexJsonCredentials: z4.string().optional(),
+  vertexProjectId: z4.string().optional(),
+  vertexRegion: z4.string().optional()
 });
 var openAiSchema = baseProviderSettingsSchema.extend({
-  openAiBaseUrl: import_zod4.z.string().optional(),
-  openAiApiKey: import_zod4.z.string().optional(),
-  openAiLegacyFormat: import_zod4.z.boolean().optional(),
-  openAiR1FormatEnabled: import_zod4.z.boolean().optional(),
-  openAiModelId: import_zod4.z.string().optional(),
+  openAiBaseUrl: z4.string().optional(),
+  openAiApiKey: z4.string().optional(),
+  openAiLegacyFormat: z4.boolean().optional(),
+  openAiR1FormatEnabled: z4.boolean().optional(),
+  openAiModelId: z4.string().optional(),
   openAiCustomModelInfo: modelInfoSchema.nullish(),
-  openAiUseAzure: import_zod4.z.boolean().optional(),
-  azureApiVersion: import_zod4.z.string().optional(),
-  openAiStreamingEnabled: import_zod4.z.boolean().optional(),
-  openAiHostHeader: import_zod4.z.string().optional(),
+  openAiUseAzure: z4.boolean().optional(),
+  azureApiVersion: z4.string().optional(),
+  openAiStreamingEnabled: z4.boolean().optional(),
+  openAiHostHeader: z4.string().optional(),
   // Keep temporarily for backward compatibility during migration.
-  openAiHeaders: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional()
+  openAiHeaders: z4.record(z4.string(), z4.string()).optional()
 });
 var ollamaSchema = baseProviderSettingsSchema.extend({
-  ollamaModelId: import_zod4.z.string().optional(),
-  ollamaBaseUrl: import_zod4.z.string().optional()
+  ollamaModelId: z4.string().optional(),
+  ollamaBaseUrl: z4.string().optional()
 });
 var vsCodeLmSchema = baseProviderSettingsSchema.extend({
-  vsCodeLmModelSelector: import_zod4.z.object({
-    vendor: import_zod4.z.string().optional(),
-    family: import_zod4.z.string().optional(),
-    version: import_zod4.z.string().optional(),
-    id: import_zod4.z.string().optional()
+  vsCodeLmModelSelector: z4.object({
+    vendor: z4.string().optional(),
+    family: z4.string().optional(),
+    version: z4.string().optional(),
+    id: z4.string().optional()
   }).optional()
 });
 var lmStudioSchema = baseProviderSettingsSchema.extend({
-  lmStudioModelId: import_zod4.z.string().optional(),
-  lmStudioBaseUrl: import_zod4.z.string().optional(),
-  lmStudioDraftModelId: import_zod4.z.string().optional(),
-  lmStudioSpeculativeDecodingEnabled: import_zod4.z.boolean().optional()
+  lmStudioModelId: z4.string().optional(),
+  lmStudioBaseUrl: z4.string().optional(),
+  lmStudioDraftModelId: z4.string().optional(),
+  lmStudioSpeculativeDecodingEnabled: z4.boolean().optional()
 });
 var geminiSchema = apiModelIdProviderModelSchema.extend({
-  geminiApiKey: import_zod4.z.string().optional(),
-  googleGeminiBaseUrl: import_zod4.z.string().optional()
+  geminiApiKey: z4.string().optional(),
+  googleGeminiBaseUrl: z4.string().optional()
 });
 var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
-  openAiNativeApiKey: import_zod4.z.string().optional(),
-  openAiNativeBaseUrl: import_zod4.z.string().optional()
+  openAiNativeApiKey: z4.string().optional(),
+  openAiNativeBaseUrl: z4.string().optional()
 });
 var mistralSchema = apiModelIdProviderModelSchema.extend({
-  mistralApiKey: import_zod4.z.string().optional(),
-  mistralCodestralUrl: import_zod4.z.string().optional()
+  mistralApiKey: z4.string().optional(),
+  mistralCodestralUrl: z4.string().optional()
 });
 var deepSeekSchema = apiModelIdProviderModelSchema.extend({
-  deepSeekBaseUrl: import_zod4.z.string().optional(),
-  deepSeekApiKey: import_zod4.z.string().optional()
+  deepSeekBaseUrl: z4.string().optional(),
+  deepSeekApiKey: z4.string().optional()
 });
 var unboundSchema = baseProviderSettingsSchema.extend({
-  unboundApiKey: import_zod4.z.string().optional(),
-  unboundModelId: import_zod4.z.string().optional()
+  unboundApiKey: z4.string().optional(),
+  unboundModelId: z4.string().optional()
 });
 var requestySchema = baseProviderSettingsSchema.extend({
-  requestyApiKey: import_zod4.z.string().optional(),
-  requestyModelId: import_zod4.z.string().optional()
+  requestyApiKey: z4.string().optional(),
+  requestyModelId: z4.string().optional()
 });
 var humanRelaySchema = baseProviderSettingsSchema;
 var fakeAiSchema = baseProviderSettingsSchema.extend({
-  fakeAi: import_zod4.z.unknown().optional()
+  fakeAi: z4.unknown().optional()
 });
 var xaiSchema = apiModelIdProviderModelSchema.extend({
-  xaiApiKey: import_zod4.z.string().optional()
+  xaiApiKey: z4.string().optional()
 });
 var groqSchema = apiModelIdProviderModelSchema.extend({
-  groqApiKey: import_zod4.z.string().optional()
+  groqApiKey: z4.string().optional()
 });
 var chutesSchema = apiModelIdProviderModelSchema.extend({
-  chutesApiKey: import_zod4.z.string().optional()
+  chutesApiKey: z4.string().optional()
 });
 var litellmSchema = baseProviderSettingsSchema.extend({
-  litellmBaseUrl: import_zod4.z.string().optional(),
-  litellmApiKey: import_zod4.z.string().optional(),
-  litellmModelId: import_zod4.z.string().optional()
+  litellmBaseUrl: z4.string().optional(),
+  litellmApiKey: z4.string().optional(),
+  litellmModelId: z4.string().optional()
 });
-var defaultSchema = import_zod4.z.object({
-  apiProvider: import_zod4.z.undefined()
+var defaultSchema = z4.object({
+  apiProvider: z4.undefined()
 });
-var providerSettingsSchemaDiscriminated = import_zod4.z.discriminatedUnion("apiProvider", [
-  anthropicSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("anthropic") })),
-  glamaSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("glama") })),
-  openRouterSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("openrouter") })),
-  bedrockSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("bedrock") })),
-  vertexSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("vertex") })),
-  openAiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("openai") })),
-  ollamaSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("ollama") })),
-  vsCodeLmSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("vscode-lm") })),
-  lmStudioSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("lmstudio") })),
-  geminiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("gemini") })),
-  openAiNativeSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("openai-native") })),
-  mistralSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("mistral") })),
-  deepSeekSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("deepseek") })),
-  unboundSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("unbound") })),
-  requestySchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("requesty") })),
-  humanRelaySchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("human-relay") })),
-  fakeAiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("fake-ai") })),
-  xaiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("xai") })),
-  groqSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("groq") })),
-  chutesSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("chutes") })),
-  litellmSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("litellm") })),
+var providerSettingsSchemaDiscriminated = z4.discriminatedUnion("apiProvider", [
+  anthropicSchema.merge(z4.object({ apiProvider: z4.literal("anthropic") })),
+  glamaSchema.merge(z4.object({ apiProvider: z4.literal("glama") })),
+  openRouterSchema.merge(z4.object({ apiProvider: z4.literal("openrouter") })),
+  bedrockSchema.merge(z4.object({ apiProvider: z4.literal("bedrock") })),
+  vertexSchema.merge(z4.object({ apiProvider: z4.literal("vertex") })),
+  openAiSchema.merge(z4.object({ apiProvider: z4.literal("openai") })),
+  ollamaSchema.merge(z4.object({ apiProvider: z4.literal("ollama") })),
+  vsCodeLmSchema.merge(z4.object({ apiProvider: z4.literal("vscode-lm") })),
+  lmStudioSchema.merge(z4.object({ apiProvider: z4.literal("lmstudio") })),
+  geminiSchema.merge(z4.object({ apiProvider: z4.literal("gemini") })),
+  openAiNativeSchema.merge(z4.object({ apiProvider: z4.literal("openai-native") })),
+  mistralSchema.merge(z4.object({ apiProvider: z4.literal("mistral") })),
+  deepSeekSchema.merge(z4.object({ apiProvider: z4.literal("deepseek") })),
+  unboundSchema.merge(z4.object({ apiProvider: z4.literal("unbound") })),
+  requestySchema.merge(z4.object({ apiProvider: z4.literal("requesty") })),
+  humanRelaySchema.merge(z4.object({ apiProvider: z4.literal("human-relay") })),
+  fakeAiSchema.merge(z4.object({ apiProvider: z4.literal("fake-ai") })),
+  xaiSchema.merge(z4.object({ apiProvider: z4.literal("xai") })),
+  groqSchema.merge(z4.object({ apiProvider: z4.literal("groq") })),
+  chutesSchema.merge(z4.object({ apiProvider: z4.literal("chutes") })),
+  litellmSchema.merge(z4.object({ apiProvider: z4.literal("litellm") })),
   defaultSchema
 ]);
-var providerSettingsSchema = import_zod4.z.object({
+var providerSettingsSchema = z4.object({
   apiProvider: providerNamesSchema.optional(),
   ...anthropicSchema.shape,
   ...glamaSchema.shape,
@@ -473,25 +378,25 @@ var PROVIDER_SETTINGS_KEYS = keysOf()([
 ]);
 
 // src/history.ts
-var import_zod5 = require("zod");
-var historyItemSchema = import_zod5.z.object({
-  id: import_zod5.z.string(),
-  number: import_zod5.z.number(),
-  ts: import_zod5.z.number(),
-  task: import_zod5.z.string(),
-  tokensIn: import_zod5.z.number(),
-  tokensOut: import_zod5.z.number(),
-  cacheWrites: import_zod5.z.number().optional(),
-  cacheReads: import_zod5.z.number().optional(),
-  totalCost: import_zod5.z.number(),
-  size: import_zod5.z.number().optional(),
-  workspace: import_zod5.z.string().optional()
+import { z as z5 } from "zod";
+var historyItemSchema = z5.object({
+  id: z5.string(),
+  number: z5.number(),
+  ts: z5.number(),
+  task: z5.string(),
+  tokensIn: z5.number(),
+  tokensOut: z5.number(),
+  cacheWrites: z5.number().optional(),
+  cacheReads: z5.number().optional(),
+  totalCost: z5.number(),
+  size: z5.number().optional(),
+  workspace: z5.string().optional()
 });
 
 // src/telemetry.ts
-var import_zod6 = require("zod");
+import { z as z6 } from "zod";
 var telemetrySettings = ["unset", "enabled", "disabled"];
-var telemetrySettingsSchema = import_zod6.z.enum(telemetrySettings);
+var telemetrySettingsSchema = z6.enum(telemetrySettings);
 var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
   TelemetryEventName2["TASK_CREATED"] = "Task Created";
   TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
@@ -515,35 +420,35 @@ var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
   TelemetryEventName2["CONSECUTIVE_MISTAKE_ERROR"] = "Consecutive Mistake Error";
   return TelemetryEventName2;
 })(TelemetryEventName || {});
-var appPropertiesSchema = import_zod6.z.object({
-  appVersion: import_zod6.z.string(),
-  vscodeVersion: import_zod6.z.string(),
-  platform: import_zod6.z.string(),
-  editorName: import_zod6.z.string(),
-  language: import_zod6.z.string(),
-  mode: import_zod6.z.string()
+var appPropertiesSchema = z6.object({
+  appVersion: z6.string(),
+  vscodeVersion: z6.string(),
+  platform: z6.string(),
+  editorName: z6.string(),
+  language: z6.string(),
+  mode: z6.string()
 });
-var taskPropertiesSchema = import_zod6.z.object({
-  taskId: import_zod6.z.string().optional(),
-  apiProvider: import_zod6.z.enum(providerNames).optional(),
-  modelId: import_zod6.z.string().optional(),
-  diffStrategy: import_zod6.z.string().optional(),
-  isSubtask: import_zod6.z.boolean().optional()
+var taskPropertiesSchema = z6.object({
+  taskId: z6.string().optional(),
+  apiProvider: z6.enum(providerNames).optional(),
+  modelId: z6.string().optional(),
+  diffStrategy: z6.string().optional(),
+  isSubtask: z6.boolean().optional()
 });
-var telemetryPropertiesSchema = import_zod6.z.object({
+var telemetryPropertiesSchema = z6.object({
   ...appPropertiesSchema.shape,
   ...taskPropertiesSchema.shape
 });
-var completionPropertiesSchema = import_zod6.z.object({
-  inputTokens: import_zod6.z.number(),
-  outputTokens: import_zod6.z.number(),
-  cacheReadTokens: import_zod6.z.number().optional(),
-  cacheWriteTokens: import_zod6.z.number().optional(),
-  cost: import_zod6.z.number().optional()
+var completionPropertiesSchema = z6.object({
+  inputTokens: z6.number(),
+  outputTokens: z6.number(),
+  cacheReadTokens: z6.number().optional(),
+  cacheWriteTokens: z6.number().optional(),
+  cost: z6.number().optional()
 });
-var rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
-  import_zod6.z.object({
-    type: import_zod6.z.enum([
+var rooCodeTelemetryEventSchema = z6.discriminatedUnion("type", [
+  z6.object({
+    type: z6.enum([
       "Task Created" /* TASK_CREATED */,
       "Task Reopened" /* TASK_RESTARTED */,
       "Task Completed" /* TASK_COMPLETED */,
@@ -562,14 +467,14 @@ var rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
       "Shell Integration Error" /* SHELL_INTEGRATION_ERROR */,
       "Consecutive Mistake Error" /* CONSECUTIVE_MISTAKE_ERROR */
     ]),
-    properties: import_zod6.z.object({
+    properties: z6.object({
       ...appPropertiesSchema.shape,
       ...taskPropertiesSchema.shape
     })
   }),
-  import_zod6.z.object({
-    type: import_zod6.z.literal("LLM Completion" /* LLM_COMPLETION */),
-    properties: import_zod6.z.object({
+  z6.object({
+    type: z6.literal("LLM Completion" /* LLM_COMPLETION */),
+    properties: z6.object({
       ...appPropertiesSchema.shape,
       ...taskPropertiesSchema.shape,
       ...completionPropertiesSchema.shape
@@ -578,12 +483,12 @@ var rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
 ]);
 
 // src/mode.ts
-var import_zod8 = require("zod");
+import { z as z8 } from "zod";
 
 // src/tool.ts
-var import_zod7 = require("zod");
+import { z as z7 } from "zod";
 var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
-var toolGroupsSchema = import_zod7.z.enum(toolGroups);
+var toolGroupsSchema = z7.enum(toolGroups);
 var toolNames = [
   "execute_command",
   "read_file",
@@ -604,18 +509,18 @@ var toolNames = [
   "fetch_instructions",
   "codebase_search"
 ];
-var toolNamesSchema = import_zod7.z.enum(toolNames);
-var toolUsageSchema = import_zod7.z.record(
+var toolNamesSchema = z7.enum(toolNames);
+var toolUsageSchema = z7.record(
   toolNamesSchema,
-  import_zod7.z.object({
-    attempts: import_zod7.z.number(),
-    failures: import_zod7.z.number()
+  z7.object({
+    attempts: z7.number(),
+    failures: z7.number()
   })
 );
 
 // src/mode.ts
-var groupOptionsSchema = import_zod8.z.object({
-  fileRegex: import_zod8.z.string().optional().refine(
+var groupOptionsSchema = z8.object({
+  fileRegex: z8.string().optional().refine(
     (pattern) => {
       if (!pattern) {
         return true;
@@ -629,10 +534,10 @@ var groupOptionsSchema = import_zod8.z.object({
     },
     { message: "Invalid regular expression pattern" }
   ),
-  description: import_zod8.z.string().optional()
+  description: z8.string().optional()
 });
-var groupEntrySchema = import_zod8.z.union([toolGroupsSchema, import_zod8.z.tuple([toolGroupsSchema, groupOptionsSchema])]);
-var groupEntryArraySchema = import_zod8.z.array(groupEntrySchema).refine(
+var groupEntrySchema = z8.union([toolGroupsSchema, z8.tuple([toolGroupsSchema, groupOptionsSchema])]);
+var groupEntryArraySchema = z8.array(groupEntrySchema).refine(
   (groups) => {
     const seen = /* @__PURE__ */ new Set();
     return groups.every((group) => {
@@ -646,17 +551,17 @@ var groupEntryArraySchema = import_zod8.z.array(groupEntrySchema).refine(
   },
   { message: "Duplicate groups are not allowed" }
 );
-var modeConfigSchema = import_zod8.z.object({
-  slug: import_zod8.z.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
-  name: import_zod8.z.string().min(1, "Name is required"),
-  roleDefinition: import_zod8.z.string().min(1, "Role definition is required"),
-  whenToUse: import_zod8.z.string().optional(),
-  customInstructions: import_zod8.z.string().optional(),
+var modeConfigSchema = z8.object({
+  slug: z8.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
+  name: z8.string().min(1, "Name is required"),
+  roleDefinition: z8.string().min(1, "Role definition is required"),
+  whenToUse: z8.string().optional(),
+  customInstructions: z8.string().optional(),
   groups: groupEntryArraySchema,
-  source: import_zod8.z.enum(["global", "project"]).optional()
+  source: z8.enum(["global", "project"]).optional()
 });
-var customModesSettingsSchema = import_zod8.z.object({
-  customModes: import_zod8.z.array(modeConfigSchema).refine(
+var customModesSettingsSchema = z8.object({
+  customModes: z8.array(modeConfigSchema).refine(
     (modes) => {
       const slugs = /* @__PURE__ */ new Set();
       return modes.every((mode) => {
@@ -672,16 +577,16 @@ var customModesSettingsSchema = import_zod8.z.object({
     }
   )
 });
-var promptComponentSchema = import_zod8.z.object({
-  roleDefinition: import_zod8.z.string().optional(),
-  whenToUse: import_zod8.z.string().optional(),
-  customInstructions: import_zod8.z.string().optional()
+var promptComponentSchema = z8.object({
+  roleDefinition: z8.string().optional(),
+  whenToUse: z8.string().optional(),
+  customInstructions: z8.string().optional()
 });
-var customModePromptsSchema = import_zod8.z.record(import_zod8.z.string(), promptComponentSchema.optional());
-var customSupportPromptsSchema = import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string().optional());
+var customModePromptsSchema = z8.record(z8.string(), promptComponentSchema.optional());
+var customSupportPromptsSchema = z8.record(z8.string(), z8.string().optional());
 
 // src/vscode.ts
-var import_zod9 = require("zod");
+import { z as z9 } from "zod";
 var codeActionIds = ["explainCode", "fixCode", "improveCode", "addToContext", "newTask"];
 var terminalActionIds = ["terminalAddToContext", "terminalFixCommand", "terminalExplainCommand"];
 var commandIds = [
@@ -721,77 +626,77 @@ var languages = [
   "zh-CN",
   "zh-TW"
 ];
-var languagesSchema = import_zod9.z.enum(languages);
+var languagesSchema = z9.enum(languages);
 var isLanguage = (value) => languages.includes(value);
 
 // src/global-settings.ts
-var globalSettingsSchema = import_zod10.z.object({
-  currentApiConfigName: import_zod10.z.string().optional(),
-  listApiConfigMeta: import_zod10.z.array(providerSettingsEntrySchema).optional(),
-  pinnedApiConfigs: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.boolean()).optional(),
-  lastShownAnnouncementId: import_zod10.z.string().optional(),
-  customInstructions: import_zod10.z.string().optional(),
-  taskHistory: import_zod10.z.array(historyItemSchema).optional(),
-  condensingApiConfigId: import_zod10.z.string().optional(),
-  customCondensingPrompt: import_zod10.z.string().optional(),
-  autoApprovalEnabled: import_zod10.z.boolean().optional(),
-  alwaysAllowReadOnly: import_zod10.z.boolean().optional(),
-  alwaysAllowReadOnlyOutsideWorkspace: import_zod10.z.boolean().optional(),
-  alwaysAllowWrite: import_zod10.z.boolean().optional(),
-  alwaysAllowWriteOutsideWorkspace: import_zod10.z.boolean().optional(),
-  writeDelayMs: import_zod10.z.number().optional(),
-  alwaysAllowBrowser: import_zod10.z.boolean().optional(),
-  alwaysApproveResubmit: import_zod10.z.boolean().optional(),
-  requestDelaySeconds: import_zod10.z.number().optional(),
-  alwaysAllowMcp: import_zod10.z.boolean().optional(),
-  alwaysAllowModeSwitch: import_zod10.z.boolean().optional(),
-  alwaysAllowSubtasks: import_zod10.z.boolean().optional(),
-  alwaysAllowExecute: import_zod10.z.boolean().optional(),
-  allowedCommands: import_zod10.z.array(import_zod10.z.string()).optional(),
-  allowedMaxRequests: import_zod10.z.number().nullish(),
-  autoCondenseContextPercent: import_zod10.z.number().optional(),
-  browserToolEnabled: import_zod10.z.boolean().optional(),
-  browserViewportSize: import_zod10.z.string().optional(),
-  screenshotQuality: import_zod10.z.number().optional(),
-  remoteBrowserEnabled: import_zod10.z.boolean().optional(),
-  remoteBrowserHost: import_zod10.z.string().optional(),
-  cachedChromeHostUrl: import_zod10.z.string().optional(),
-  enableCheckpoints: import_zod10.z.boolean().optional(),
-  ttsEnabled: import_zod10.z.boolean().optional(),
-  ttsSpeed: import_zod10.z.number().optional(),
-  soundEnabled: import_zod10.z.boolean().optional(),
-  soundVolume: import_zod10.z.number().optional(),
-  maxOpenTabsContext: import_zod10.z.number().optional(),
-  maxWorkspaceFiles: import_zod10.z.number().optional(),
-  showRooIgnoredFiles: import_zod10.z.boolean().optional(),
-  maxReadFileLine: import_zod10.z.number().optional(),
-  terminalOutputLineLimit: import_zod10.z.number().optional(),
-  terminalShellIntegrationTimeout: import_zod10.z.number().optional(),
-  terminalShellIntegrationDisabled: import_zod10.z.boolean().optional(),
-  terminalCommandDelay: import_zod10.z.number().optional(),
-  terminalPowershellCounter: import_zod10.z.boolean().optional(),
-  terminalZshClearEolMark: import_zod10.z.boolean().optional(),
-  terminalZshOhMy: import_zod10.z.boolean().optional(),
-  terminalZshP10k: import_zod10.z.boolean().optional(),
-  terminalZdotdir: import_zod10.z.boolean().optional(),
-  terminalCompressProgressBar: import_zod10.z.boolean().optional(),
-  rateLimitSeconds: import_zod10.z.number().optional(),
-  diffEnabled: import_zod10.z.boolean().optional(),
-  fuzzyMatchThreshold: import_zod10.z.number().optional(),
+var globalSettingsSchema = z10.object({
+  currentApiConfigName: z10.string().optional(),
+  listApiConfigMeta: z10.array(providerSettingsEntrySchema).optional(),
+  pinnedApiConfigs: z10.record(z10.string(), z10.boolean()).optional(),
+  lastShownAnnouncementId: z10.string().optional(),
+  customInstructions: z10.string().optional(),
+  taskHistory: z10.array(historyItemSchema).optional(),
+  condensingApiConfigId: z10.string().optional(),
+  customCondensingPrompt: z10.string().optional(),
+  autoApprovalEnabled: z10.boolean().optional(),
+  alwaysAllowReadOnly: z10.boolean().optional(),
+  alwaysAllowReadOnlyOutsideWorkspace: z10.boolean().optional(),
+  alwaysAllowWrite: z10.boolean().optional(),
+  alwaysAllowWriteOutsideWorkspace: z10.boolean().optional(),
+  writeDelayMs: z10.number().optional(),
+  alwaysAllowBrowser: z10.boolean().optional(),
+  alwaysApproveResubmit: z10.boolean().optional(),
+  requestDelaySeconds: z10.number().optional(),
+  alwaysAllowMcp: z10.boolean().optional(),
+  alwaysAllowModeSwitch: z10.boolean().optional(),
+  alwaysAllowSubtasks: z10.boolean().optional(),
+  alwaysAllowExecute: z10.boolean().optional(),
+  allowedCommands: z10.array(z10.string()).optional(),
+  allowedMaxRequests: z10.number().nullish(),
+  autoCondenseContextPercent: z10.number().optional(),
+  browserToolEnabled: z10.boolean().optional(),
+  browserViewportSize: z10.string().optional(),
+  screenshotQuality: z10.number().optional(),
+  remoteBrowserEnabled: z10.boolean().optional(),
+  remoteBrowserHost: z10.string().optional(),
+  cachedChromeHostUrl: z10.string().optional(),
+  enableCheckpoints: z10.boolean().optional(),
+  ttsEnabled: z10.boolean().optional(),
+  ttsSpeed: z10.number().optional(),
+  soundEnabled: z10.boolean().optional(),
+  soundVolume: z10.number().optional(),
+  maxOpenTabsContext: z10.number().optional(),
+  maxWorkspaceFiles: z10.number().optional(),
+  showRooIgnoredFiles: z10.boolean().optional(),
+  maxReadFileLine: z10.number().optional(),
+  terminalOutputLineLimit: z10.number().optional(),
+  terminalShellIntegrationTimeout: z10.number().optional(),
+  terminalShellIntegrationDisabled: z10.boolean().optional(),
+  terminalCommandDelay: z10.number().optional(),
+  terminalPowershellCounter: z10.boolean().optional(),
+  terminalZshClearEolMark: z10.boolean().optional(),
+  terminalZshOhMy: z10.boolean().optional(),
+  terminalZshP10k: z10.boolean().optional(),
+  terminalZdotdir: z10.boolean().optional(),
+  terminalCompressProgressBar: z10.boolean().optional(),
+  rateLimitSeconds: z10.number().optional(),
+  diffEnabled: z10.boolean().optional(),
+  fuzzyMatchThreshold: z10.number().optional(),
   experiments: experimentsSchema.optional(),
   codebaseIndexModels: codebaseIndexModelsSchema.optional(),
   codebaseIndexConfig: codebaseIndexConfigSchema.optional(),
   language: languagesSchema.optional(),
   telemetrySetting: telemetrySettingsSchema.optional(),
-  mcpEnabled: import_zod10.z.boolean().optional(),
-  enableMcpServerCreation: import_zod10.z.boolean().optional(),
-  mode: import_zod10.z.string().optional(),
-  modeApiConfigs: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.string()).optional(),
-  customModes: import_zod10.z.array(modeConfigSchema).optional(),
+  mcpEnabled: z10.boolean().optional(),
+  enableMcpServerCreation: z10.boolean().optional(),
+  mode: z10.string().optional(),
+  modeApiConfigs: z10.record(z10.string(), z10.string()).optional(),
+  customModes: z10.array(modeConfigSchema).optional(),
   customModePrompts: customModePromptsSchema.optional(),
   customSupportPrompts: customSupportPromptsSchema.optional(),
-  enhancementApiConfigId: import_zod10.z.string().optional(),
-  historyPreviewCollapsed: import_zod10.z.boolean().optional()
+  enhancementApiConfigId: z10.string().optional(),
+  historyPreviewCollapsed: z10.boolean().optional()
 });
 var GLOBAL_SETTINGS_KEYS = keysOf()([
   "currentApiConfigName",
@@ -890,10 +795,10 @@ var GLOBAL_STATE_KEYS = [...GLOBAL_SETTINGS_KEYS, ...PROVIDER_SETTINGS_KEYS].fil
 var isGlobalStateKey = (key) => GLOBAL_STATE_KEYS.includes(key);
 
 // src/ipc.ts
-var import_zod12 = require("zod");
+import { z as z12 } from "zod";
 
 // src/message.ts
-var import_zod11 = require("zod");
+import { z as z11 } from "zod";
 var clineAsks = [
   "followup",
   "command",
@@ -908,7 +813,7 @@ var clineAsks = [
   "use_mcp_server",
   "auto_approval_max_req_reached"
 ];
-var clineAskSchema = import_zod11.z.enum(clineAsks);
+var clineAskSchema = z11.enum(clineAsks);
 var clineSays = [
   "error",
   "api_req_started",
@@ -934,38 +839,38 @@ var clineSays = [
   "condense_context",
   "codebase_search_result"
 ];
-var clineSaySchema = import_zod11.z.enum(clineSays);
-var toolProgressStatusSchema = import_zod11.z.object({
-  icon: import_zod11.z.string().optional(),
-  text: import_zod11.z.string().optional()
+var clineSaySchema = z11.enum(clineSays);
+var toolProgressStatusSchema = z11.object({
+  icon: z11.string().optional(),
+  text: z11.string().optional()
 });
-var contextCondenseSchema = import_zod11.z.object({
-  cost: import_zod11.z.number(),
-  prevContextTokens: import_zod11.z.number(),
-  newContextTokens: import_zod11.z.number(),
-  summary: import_zod11.z.string()
+var contextCondenseSchema = z11.object({
+  cost: z11.number(),
+  prevContextTokens: z11.number(),
+  newContextTokens: z11.number(),
+  summary: z11.string()
 });
-var clineMessageSchema = import_zod11.z.object({
-  ts: import_zod11.z.number(),
-  type: import_zod11.z.union([import_zod11.z.literal("ask"), import_zod11.z.literal("say")]),
+var clineMessageSchema = z11.object({
+  ts: z11.number(),
+  type: z11.union([z11.literal("ask"), z11.literal("say")]),
   ask: clineAskSchema.optional(),
   say: clineSaySchema.optional(),
-  text: import_zod11.z.string().optional(),
-  images: import_zod11.z.array(import_zod11.z.string()).optional(),
-  partial: import_zod11.z.boolean().optional(),
-  reasoning: import_zod11.z.string().optional(),
-  conversationHistoryIndex: import_zod11.z.number().optional(),
-  checkpoint: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown()).optional(),
+  text: z11.string().optional(),
+  images: z11.array(z11.string()).optional(),
+  partial: z11.boolean().optional(),
+  reasoning: z11.string().optional(),
+  conversationHistoryIndex: z11.number().optional(),
+  checkpoint: z11.record(z11.string(), z11.unknown()).optional(),
   progressStatus: toolProgressStatusSchema.optional(),
   contextCondense: contextCondenseSchema.optional()
 });
-var tokenUsageSchema = import_zod11.z.object({
-  totalTokensIn: import_zod11.z.number(),
-  totalTokensOut: import_zod11.z.number(),
-  totalCacheWrites: import_zod11.z.number().optional(),
-  totalCacheReads: import_zod11.z.number().optional(),
-  totalCost: import_zod11.z.number(),
-  contextTokens: import_zod11.z.number()
+var tokenUsageSchema = z11.object({
+  totalTokensIn: z11.number(),
+  totalTokensOut: z11.number(),
+  totalCacheWrites: z11.number().optional(),
+  totalCacheReads: z11.number().optional(),
+  totalCost: z11.number(),
+  contextTokens: z11.number()
 });
 
 // src/ipc.ts
@@ -984,30 +889,30 @@ var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
   RooCodeEventName2["TaskToolFailed"] = "taskToolFailed";
   return RooCodeEventName2;
 })(RooCodeEventName || {});
-var rooCodeEventsSchema = import_zod12.z.object({
-  ["message" /* Message */]: import_zod12.z.tuple([
-    import_zod12.z.object({
-      taskId: import_zod12.z.string(),
-      action: import_zod12.z.union([import_zod12.z.literal("created"), import_zod12.z.literal("updated")]),
+var rooCodeEventsSchema = z12.object({
+  ["message" /* Message */]: z12.tuple([
+    z12.object({
+      taskId: z12.string(),
+      action: z12.union([z12.literal("created"), z12.literal("updated")]),
       message: clineMessageSchema
     })
   ]),
-  ["taskCreated" /* TaskCreated */]: import_zod12.z.tuple([import_zod12.z.string()]),
-  ["taskStarted" /* TaskStarted */]: import_zod12.z.tuple([import_zod12.z.string()]),
-  ["taskModeSwitched" /* TaskModeSwitched */]: import_zod12.z.tuple([import_zod12.z.string(), import_zod12.z.string()]),
-  ["taskPaused" /* TaskPaused */]: import_zod12.z.tuple([import_zod12.z.string()]),
-  ["taskUnpaused" /* TaskUnpaused */]: import_zod12.z.tuple([import_zod12.z.string()]),
-  ["taskAskResponded" /* TaskAskResponded */]: import_zod12.z.tuple([import_zod12.z.string()]),
-  ["taskAborted" /* TaskAborted */]: import_zod12.z.tuple([import_zod12.z.string()]),
-  ["taskSpawned" /* TaskSpawned */]: import_zod12.z.tuple([import_zod12.z.string(), import_zod12.z.string()]),
-  ["taskCompleted" /* TaskCompleted */]: import_zod12.z.tuple([import_zod12.z.string(), tokenUsageSchema, toolUsageSchema]),
-  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: import_zod12.z.tuple([import_zod12.z.string(), tokenUsageSchema]),
-  ["taskToolFailed" /* TaskToolFailed */]: import_zod12.z.tuple([import_zod12.z.string(), toolNamesSchema, import_zod12.z.string()])
+  ["taskCreated" /* TaskCreated */]: z12.tuple([z12.string()]),
+  ["taskStarted" /* TaskStarted */]: z12.tuple([z12.string()]),
+  ["taskModeSwitched" /* TaskModeSwitched */]: z12.tuple([z12.string(), z12.string()]),
+  ["taskPaused" /* TaskPaused */]: z12.tuple([z12.string()]),
+  ["taskUnpaused" /* TaskUnpaused */]: z12.tuple([z12.string()]),
+  ["taskAskResponded" /* TaskAskResponded */]: z12.tuple([z12.string()]),
+  ["taskAborted" /* TaskAborted */]: z12.tuple([z12.string()]),
+  ["taskSpawned" /* TaskSpawned */]: z12.tuple([z12.string(), z12.string()]),
+  ["taskCompleted" /* TaskCompleted */]: z12.tuple([z12.string(), tokenUsageSchema, toolUsageSchema]),
+  ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z12.tuple([z12.string(), tokenUsageSchema]),
+  ["taskToolFailed" /* TaskToolFailed */]: z12.tuple([z12.string(), toolNamesSchema, z12.string()])
 });
-var ackSchema = import_zod12.z.object({
-  clientId: import_zod12.z.string(),
-  pid: import_zod12.z.number(),
-  ppid: import_zod12.z.number()
+var ackSchema = z12.object({
+  clientId: z12.string(),
+  pid: z12.number(),
+  ppid: z12.number()
 });
 var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -1015,68 +920,68 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
   TaskCommandName2["CloseTask"] = "CloseTask";
   return TaskCommandName2;
 })(TaskCommandName || {});
-var taskCommandSchema = import_zod12.z.discriminatedUnion("commandName", [
-  import_zod12.z.object({
-    commandName: import_zod12.z.literal("StartNewTask" /* StartNewTask */),
-    data: import_zod12.z.object({
+var taskCommandSchema = z12.discriminatedUnion("commandName", [
+  z12.object({
+    commandName: z12.literal("StartNewTask" /* StartNewTask */),
+    data: z12.object({
       configuration: rooCodeSettingsSchema,
-      text: import_zod12.z.string(),
-      images: import_zod12.z.array(import_zod12.z.string()).optional(),
-      newTab: import_zod12.z.boolean().optional()
+      text: z12.string(),
+      images: z12.array(z12.string()).optional(),
+      newTab: z12.boolean().optional()
     })
   }),
-  import_zod12.z.object({
-    commandName: import_zod12.z.literal("CancelTask" /* CancelTask */),
-    data: import_zod12.z.string()
+  z12.object({
+    commandName: z12.literal("CancelTask" /* CancelTask */),
+    data: z12.string()
   }),
-  import_zod12.z.object({
-    commandName: import_zod12.z.literal("CloseTask" /* CloseTask */),
-    data: import_zod12.z.string()
+  z12.object({
+    commandName: z12.literal("CloseTask" /* CloseTask */),
+    data: z12.string()
   })
 ]);
-var taskEventSchema = import_zod12.z.discriminatedUnion("eventName", [
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("message" /* Message */),
+var taskEventSchema = z12.discriminatedUnion("eventName", [
+  z12.object({
+    eventName: z12.literal("message" /* Message */),
     payload: rooCodeEventsSchema.shape["message" /* Message */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskCreated" /* TaskCreated */),
+  z12.object({
+    eventName: z12.literal("taskCreated" /* TaskCreated */),
     payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskStarted" /* TaskStarted */),
+  z12.object({
+    eventName: z12.literal("taskStarted" /* TaskStarted */),
     payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskModeSwitched" /* TaskModeSwitched */),
+  z12.object({
+    eventName: z12.literal("taskModeSwitched" /* TaskModeSwitched */),
     payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskPaused" /* TaskPaused */),
+  z12.object({
+    eventName: z12.literal("taskPaused" /* TaskPaused */),
     payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskUnpaused" /* TaskUnpaused */),
+  z12.object({
+    eventName: z12.literal("taskUnpaused" /* TaskUnpaused */),
     payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskAskResponded" /* TaskAskResponded */),
+  z12.object({
+    eventName: z12.literal("taskAskResponded" /* TaskAskResponded */),
     payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskAborted" /* TaskAborted */),
+  z12.object({
+    eventName: z12.literal("taskAborted" /* TaskAborted */),
     payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskSpawned" /* TaskSpawned */),
+  z12.object({
+    eventName: z12.literal("taskSpawned" /* TaskSpawned */),
     payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskCompleted" /* TaskCompleted */),
+  z12.object({
+    eventName: z12.literal("taskCompleted" /* TaskCompleted */),
     payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */]
   }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
+  z12.object({
+    eventName: z12.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
     payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]
   })
 ]);
@@ -1093,52 +998,51 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
   IpcOrigin2["Server"] = "server";
   return IpcOrigin2;
 })(IpcOrigin || {});
-var ipcMessageSchema = import_zod12.z.discriminatedUnion("type", [
-  import_zod12.z.object({
-    type: import_zod12.z.literal("Ack" /* Ack */),
-    origin: import_zod12.z.literal("server" /* Server */),
+var ipcMessageSchema = z12.discriminatedUnion("type", [
+  z12.object({
+    type: z12.literal("Ack" /* Ack */),
+    origin: z12.literal("server" /* Server */),
     data: ackSchema
   }),
-  import_zod12.z.object({
-    type: import_zod12.z.literal("TaskCommand" /* TaskCommand */),
-    origin: import_zod12.z.literal("client" /* Client */),
-    clientId: import_zod12.z.string(),
+  z12.object({
+    type: z12.literal("TaskCommand" /* TaskCommand */),
+    origin: z12.literal("client" /* Client */),
+    clientId: z12.string(),
     data: taskCommandSchema
   }),
-  import_zod12.z.object({
-    type: import_zod12.z.literal("TaskEvent" /* TaskEvent */),
-    origin: import_zod12.z.literal("server" /* Server */),
-    relayClientId: import_zod12.z.string().optional(),
+  z12.object({
+    type: z12.literal("TaskEvent" /* TaskEvent */),
+    origin: z12.literal("server" /* Server */),
+    relayClientId: z12.string().optional(),
     data: taskEventSchema
   })
 ]);
 
 // src/terminal.ts
-var import_zod13 = require("zod");
-var commandExecutionStatusSchema = import_zod13.z.discriminatedUnion("status", [
-  import_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("started"),
-    pid: import_zod13.z.number().optional(),
-    command: import_zod13.z.string()
+import { z as z13 } from "zod";
+var commandExecutionStatusSchema = z13.discriminatedUnion("status", [
+  z13.object({
+    executionId: z13.string(),
+    status: z13.literal("started"),
+    pid: z13.number().optional(),
+    command: z13.string()
   }),
-  import_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("output"),
-    output: import_zod13.z.string()
+  z13.object({
+    executionId: z13.string(),
+    status: z13.literal("output"),
+    output: z13.string()
   }),
-  import_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("exited"),
-    exitCode: import_zod13.z.number().optional()
+  z13.object({
+    executionId: z13.string(),
+    status: z13.literal("exited"),
+    exitCode: z13.number().optional()
   }),
-  import_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("fallback")
+  z13.object({
+    executionId: z13.string(),
+    status: z13.literal("fallback")
   })
 ]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   GLOBAL_SETTINGS_KEYS,
   GLOBAL_STATE_KEYS,
   IpcMessageType,
@@ -1209,5 +1113,5 @@ var commandExecutionStatusSchema = import_zod13.z.discriminatedUnion("status", [
   toolNamesSchema,
   toolProgressStatusSchema,
   toolUsageSchema
-});
+};
 //# sourceMappingURL=index.js.map