@roo-code/types 1.13.0 → 1.14.0

package/dist/index.cjs

@@ -1,1213 +0,0 @@
-"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()
-});
-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 codebaseIndexProviderSchema = import_zod.z.object({
-  codeIndexOpenAiKey: import_zod.z.string().optional(),
-  codeIndexQdrantApiKey: import_zod.z.string().optional()
-});
-
-// src/experiment.ts
-var import_zod2 = require("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()
-});
-
-// src/global-settings.ts
-var import_zod10 = require("zod");
-
-// src/type-fu.ts
-function keysOf() {
-  return (keys) => keys;
-}
-
-// src/provider-settings.ts
-var import_zod4 = require("zod");
-
-// src/model.ts
-var import_zod3 = require("zod");
-var reasoningEfforts = ["low", "medium", "high"];
-var reasoningEffortsSchema = import_zod3.z.enum(reasoningEfforts);
-var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
-var modelParametersSchema = import_zod3.z.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(),
-  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()
-    })
-  ).optional()
-});
-
-// src/provider-settings.ts
-var providerNames = [
-  "anthropic",
-  "glama",
-  "openrouter",
-  "bedrock",
-  "vertex",
-  "openai",
-  "ollama",
-  "vscode-lm",
-  "lmstudio",
-  "gemini",
-  "openai-native",
-  "mistral",
-  "deepseek",
-  "unbound",
-  "requesty",
-  "human-relay",
-  "fake-ai",
-  "xai",
-  "groq",
-  "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(),
-  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(),
-  // Model reasoning.
-  enableReasoningEffort: import_zod4.z.boolean().optional(),
-  reasoningEffort: reasoningEffortsSchema.optional(),
-  modelMaxTokens: import_zod4.z.number().optional(),
-  modelMaxThinkingTokens: import_zod4.z.number().optional()
-});
-var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
-  apiModelId: import_zod4.z.string().optional()
-});
-var anthropicSchema = apiModelIdProviderModelSchema.extend({
-  apiKey: import_zod4.z.string().optional(),
-  anthropicBaseUrl: import_zod4.z.string().optional(),
-  anthropicUseAuthToken: import_zod4.z.boolean().optional()
-});
-var glamaSchema = baseProviderSettingsSchema.extend({
-  glamaModelId: import_zod4.z.string().optional(),
-  glamaApiKey: import_zod4.z.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()
-});
-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()
-});
-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()
-});
-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(),
-  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(),
-  // Keep temporarily for backward compatibility during migration.
-  openAiHeaders: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional()
-});
-var ollamaSchema = baseProviderSettingsSchema.extend({
-  ollamaModelId: import_zod4.z.string().optional(),
-  ollamaBaseUrl: import_zod4.z.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()
-  }).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()
-});
-var geminiSchema = apiModelIdProviderModelSchema.extend({
-  geminiApiKey: import_zod4.z.string().optional(),
-  googleGeminiBaseUrl: import_zod4.z.string().optional()
-});
-var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
-  openAiNativeApiKey: import_zod4.z.string().optional(),
-  openAiNativeBaseUrl: import_zod4.z.string().optional()
-});
-var mistralSchema = apiModelIdProviderModelSchema.extend({
-  mistralApiKey: import_zod4.z.string().optional(),
-  mistralCodestralUrl: import_zod4.z.string().optional()
-});
-var deepSeekSchema = apiModelIdProviderModelSchema.extend({
-  deepSeekBaseUrl: import_zod4.z.string().optional(),
-  deepSeekApiKey: import_zod4.z.string().optional()
-});
-var unboundSchema = baseProviderSettingsSchema.extend({
-  unboundApiKey: import_zod4.z.string().optional(),
-  unboundModelId: import_zod4.z.string().optional()
-});
-var requestySchema = baseProviderSettingsSchema.extend({
-  requestyApiKey: import_zod4.z.string().optional(),
-  requestyModelId: import_zod4.z.string().optional()
-});
-var humanRelaySchema = baseProviderSettingsSchema;
-var fakeAiSchema = baseProviderSettingsSchema.extend({
-  fakeAi: import_zod4.z.unknown().optional()
-});
-var xaiSchema = apiModelIdProviderModelSchema.extend({
-  xaiApiKey: import_zod4.z.string().optional()
-});
-var groqSchema = apiModelIdProviderModelSchema.extend({
-  groqApiKey: import_zod4.z.string().optional()
-});
-var chutesSchema = apiModelIdProviderModelSchema.extend({
-  chutesApiKey: import_zod4.z.string().optional()
-});
-var litellmSchema = baseProviderSettingsSchema.extend({
-  litellmBaseUrl: import_zod4.z.string().optional(),
-  litellmApiKey: import_zod4.z.string().optional(),
-  litellmModelId: import_zod4.z.string().optional()
-});
-var defaultSchema = import_zod4.z.object({
-  apiProvider: import_zod4.z.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") })),
-  defaultSchema
-]);
-var providerSettingsSchema = import_zod4.z.object({
-  apiProvider: providerNamesSchema.optional(),
-  ...anthropicSchema.shape,
-  ...glamaSchema.shape,
-  ...openRouterSchema.shape,
-  ...bedrockSchema.shape,
-  ...vertexSchema.shape,
-  ...openAiSchema.shape,
-  ...ollamaSchema.shape,
-  ...vsCodeLmSchema.shape,
-  ...lmStudioSchema.shape,
-  ...geminiSchema.shape,
-  ...openAiNativeSchema.shape,
-  ...mistralSchema.shape,
-  ...deepSeekSchema.shape,
-  ...unboundSchema.shape,
-  ...requestySchema.shape,
-  ...humanRelaySchema.shape,
-  ...fakeAiSchema.shape,
-  ...xaiSchema.shape,
-  ...groqSchema.shape,
-  ...chutesSchema.shape,
-  ...litellmSchema.shape,
-  ...codebaseIndexProviderSchema.shape
-});
-var PROVIDER_SETTINGS_KEYS = keysOf()([
-  "apiProvider",
-  // Anthropic
-  "apiModelId",
-  "apiKey",
-  "anthropicBaseUrl",
-  "anthropicUseAuthToken",
-  // Glama
-  "glamaModelId",
-  "glamaApiKey",
-  // OpenRouter
-  "openRouterApiKey",
-  "openRouterModelId",
-  "openRouterBaseUrl",
-  "openRouterSpecificProvider",
-  "openRouterUseMiddleOutTransform",
-  // Amazon Bedrock
-  "awsAccessKey",
-  "awsSecretKey",
-  "awsSessionToken",
-  "awsRegion",
-  "awsUseCrossRegionInference",
-  "awsUsePromptCache",
-  "awsProfile",
-  "awsUseProfile",
-  "awsCustomArn",
-  // Google Vertex
-  "vertexKeyFile",
-  "vertexJsonCredentials",
-  "vertexProjectId",
-  "vertexRegion",
-  // OpenAI
-  "openAiBaseUrl",
-  "openAiApiKey",
-  "openAiLegacyFormat",
-  "openAiR1FormatEnabled",
-  "openAiModelId",
-  "openAiCustomModelInfo",
-  "openAiUseAzure",
-  "azureApiVersion",
-  "openAiStreamingEnabled",
-  "openAiHostHeader",
-  // Keep temporarily for backward compatibility during migration.
-  "openAiHeaders",
-  // Ollama
-  "ollamaModelId",
-  "ollamaBaseUrl",
-  // VS Code LM
-  "vsCodeLmModelSelector",
-  "lmStudioModelId",
-  "lmStudioBaseUrl",
-  "lmStudioDraftModelId",
-  "lmStudioSpeculativeDecodingEnabled",
-  // Gemini
-  "geminiApiKey",
-  "googleGeminiBaseUrl",
-  // OpenAI Native
-  "openAiNativeApiKey",
-  "openAiNativeBaseUrl",
-  // Mistral
-  "mistralApiKey",
-  "mistralCodestralUrl",
-  // DeepSeek
-  "deepSeekBaseUrl",
-  "deepSeekApiKey",
-  // Unbound
-  "unboundApiKey",
-  "unboundModelId",
-  // Requesty
-  "requestyApiKey",
-  "requestyModelId",
-  // Code Index
-  "codeIndexOpenAiKey",
-  "codeIndexQdrantApiKey",
-  // Reasoning
-  "enableReasoningEffort",
-  "reasoningEffort",
-  "modelMaxTokens",
-  "modelMaxThinkingTokens",
-  // Generic
-  "includeMaxTokens",
-  "diffEnabled",
-  "fuzzyMatchThreshold",
-  "modelTemperature",
-  "rateLimitSeconds",
-  // Fake AI
-  "fakeAi",
-  // X.AI (Grok)
-  "xaiApiKey",
-  // Groq
-  "groqApiKey",
-  // Chutes AI
-  "chutesApiKey",
-  // LiteLLM
-  "litellmBaseUrl",
-  "litellmApiKey",
-  "litellmModelId"
-]);
-
-// 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()
-});
-
-// src/telemetry.ts
-var import_zod6 = require("zod");
-var telemetrySettings = ["unset", "enabled", "disabled"];
-var telemetrySettingsSchema = import_zod6.z.enum(telemetrySettings);
-var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
-  TelemetryEventName2["TASK_CREATED"] = "Task Created";
-  TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
-  TelemetryEventName2["TASK_COMPLETED"] = "Task Completed";
-  TelemetryEventName2["TASK_CONVERSATION_MESSAGE"] = "Conversation Message";
-  TelemetryEventName2["LLM_COMPLETION"] = "LLM Completion";
-  TelemetryEventName2["MODE_SWITCH"] = "Mode Switched";
-  TelemetryEventName2["TOOL_USED"] = "Tool Used";
-  TelemetryEventName2["CHECKPOINT_CREATED"] = "Checkpoint Created";
-  TelemetryEventName2["CHECKPOINT_RESTORED"] = "Checkpoint Restored";
-  TelemetryEventName2["CHECKPOINT_DIFFED"] = "Checkpoint Diffed";
-  TelemetryEventName2["CONTEXT_CONDENSED"] = "Context Condensed";
-  TelemetryEventName2["SLIDING_WINDOW_TRUNCATION"] = "Sliding Window Truncation";
-  TelemetryEventName2["CODE_ACTION_USED"] = "Code Action Used";
-  TelemetryEventName2["PROMPT_ENHANCED"] = "Prompt Enhanced";
-  TelemetryEventName2["TITLE_BUTTON_CLICKED"] = "Title Button Clicked";
-  TelemetryEventName2["AUTHENTICATION_INITIATED"] = "Authentication Initiated";
-  TelemetryEventName2["SCHEMA_VALIDATION_ERROR"] = "Schema Validation Error";
-  TelemetryEventName2["DIFF_APPLICATION_ERROR"] = "Diff Application Error";
-  TelemetryEventName2["SHELL_INTEGRATION_ERROR"] = "Shell Integration Error";
-  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 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 telemetryPropertiesSchema = import_zod6.z.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 rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
-  import_zod6.z.object({
-    type: import_zod6.z.enum([
-      "Task Created" /* TASK_CREATED */,
-      "Task Reopened" /* TASK_RESTARTED */,
-      "Task Completed" /* TASK_COMPLETED */,
-      "Conversation Message" /* TASK_CONVERSATION_MESSAGE */,
-      "Mode Switched" /* MODE_SWITCH */,
-      "Tool Used" /* TOOL_USED */,
-      "Checkpoint Created" /* CHECKPOINT_CREATED */,
-      "Checkpoint Restored" /* CHECKPOINT_RESTORED */,
-      "Checkpoint Diffed" /* CHECKPOINT_DIFFED */,
-      "Code Action Used" /* CODE_ACTION_USED */,
-      "Prompt Enhanced" /* PROMPT_ENHANCED */,
-      "Title Button Clicked" /* TITLE_BUTTON_CLICKED */,
-      "Authentication Initiated" /* AUTHENTICATION_INITIATED */,
-      "Schema Validation Error" /* SCHEMA_VALIDATION_ERROR */,
-      "Diff Application Error" /* DIFF_APPLICATION_ERROR */,
-      "Shell Integration Error" /* SHELL_INTEGRATION_ERROR */,
-      "Consecutive Mistake Error" /* CONSECUTIVE_MISTAKE_ERROR */
-    ]),
-    properties: import_zod6.z.object({
-      ...appPropertiesSchema.shape,
-      ...taskPropertiesSchema.shape
-    })
-  }),
-  import_zod6.z.object({
-    type: import_zod6.z.literal("LLM Completion" /* LLM_COMPLETION */),
-    properties: import_zod6.z.object({
-      ...appPropertiesSchema.shape,
-      ...taskPropertiesSchema.shape,
-      ...completionPropertiesSchema.shape
-    })
-  })
-]);
-
-// src/mode.ts
-var import_zod8 = require("zod");
-
-// src/tool.ts
-var import_zod7 = require("zod");
-var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
-var toolGroupsSchema = import_zod7.z.enum(toolGroups);
-var toolNames = [
-  "execute_command",
-  "read_file",
-  "write_to_file",
-  "apply_diff",
-  "insert_content",
-  "search_and_replace",
-  "search_files",
-  "list_files",
-  "list_code_definition_names",
-  "browser_action",
-  "use_mcp_tool",
-  "access_mcp_resource",
-  "ask_followup_question",
-  "attempt_completion",
-  "switch_mode",
-  "new_task",
-  "fetch_instructions",
-  "codebase_search"
-];
-var toolNamesSchema = import_zod7.z.enum(toolNames);
-var toolUsageSchema = import_zod7.z.record(
-  toolNamesSchema,
-  import_zod7.z.object({
-    attempts: import_zod7.z.number(),
-    failures: import_zod7.z.number()
-  })
-);
-
-// src/mode.ts
-var groupOptionsSchema = import_zod8.z.object({
-  fileRegex: import_zod8.z.string().optional().refine(
-    (pattern) => {
-      if (!pattern) {
-        return true;
-      }
-      try {
-        new RegExp(pattern);
-        return true;
-      } catch {
-        return false;
-      }
-    },
-    { message: "Invalid regular expression pattern" }
-  ),
-  description: import_zod8.z.string().optional()
-});
-var groupEntrySchema = import_zod8.z.union([toolGroupsSchema, import_zod8.z.tuple([toolGroupsSchema, groupOptionsSchema])]);
-var groupEntryArraySchema = import_zod8.z.array(groupEntrySchema).refine(
-  (groups) => {
-    const seen = /* @__PURE__ */ new Set();
-    return groups.every((group) => {
-      const groupName = Array.isArray(group) ? group[0] : group;
-      if (seen.has(groupName)) {
-        return false;
-      }
-      seen.add(groupName);
-      return true;
-    });
-  },
-  { 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(),
-  groups: groupEntryArraySchema,
-  source: import_zod8.z.enum(["global", "project"]).optional()
-});
-var customModesSettingsSchema = import_zod8.z.object({
-  customModes: import_zod8.z.array(modeConfigSchema).refine(
-    (modes) => {
-      const slugs = /* @__PURE__ */ new Set();
-      return modes.every((mode) => {
-        if (slugs.has(mode.slug)) {
-          return false;
-        }
-        slugs.add(mode.slug);
-        return true;
-      });
-    },
-    {
-      message: "Duplicate mode slugs are not allowed"
-    }
-  )
-});
-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 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());
-
-// src/vscode.ts
-var import_zod9 = require("zod");
-var codeActionIds = ["explainCode", "fixCode", "improveCode", "addToContext", "newTask"];
-var terminalActionIds = ["terminalAddToContext", "terminalFixCommand", "terminalExplainCommand"];
-var commandIds = [
-  "activationCompleted",
-  "plusButtonClicked",
-  "promptsButtonClicked",
-  "mcpButtonClicked",
-  "historyButtonClicked",
-  "popoutButtonClicked",
-  "settingsButtonClicked",
-  "openInNewTab",
-  "showHumanRelayDialog",
-  "registerHumanRelayCallback",
-  "unregisterHumanRelayCallback",
-  "handleHumanRelayResponse",
-  "newTask",
-  "setCustomStoragePath",
-  "focusInput",
-  "acceptInput"
-];
-var languages = [
-  "ca",
-  "de",
-  "en",
-  "es",
-  "fr",
-  "hi",
-  "it",
-  "ja",
-  "ko",
-  "nl",
-  "pl",
-  "pt-BR",
-  "ru",
-  "tr",
-  "vi",
-  "zh-CN",
-  "zh-TW"
-];
-var languagesSchema = import_zod9.z.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(),
-  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(),
-  customModePrompts: customModePromptsSchema.optional(),
-  customSupportPrompts: customSupportPromptsSchema.optional(),
-  enhancementApiConfigId: import_zod10.z.string().optional(),
-  historyPreviewCollapsed: import_zod10.z.boolean().optional()
-});
-var GLOBAL_SETTINGS_KEYS = keysOf()([
-  "currentApiConfigName",
-  "listApiConfigMeta",
-  "pinnedApiConfigs",
-  "lastShownAnnouncementId",
-  "customInstructions",
-  "taskHistory",
-  "condensingApiConfigId",
-  "customCondensingPrompt",
-  "autoApprovalEnabled",
-  "alwaysAllowReadOnly",
-  "alwaysAllowReadOnlyOutsideWorkspace",
-  "alwaysAllowWrite",
-  "alwaysAllowWriteOutsideWorkspace",
-  "writeDelayMs",
-  "alwaysAllowBrowser",
-  "alwaysApproveResubmit",
-  "requestDelaySeconds",
-  "alwaysAllowMcp",
-  "alwaysAllowModeSwitch",
-  "alwaysAllowSubtasks",
-  "alwaysAllowExecute",
-  "allowedCommands",
-  "allowedMaxRequests",
-  "autoCondenseContextPercent",
-  "browserToolEnabled",
-  "browserViewportSize",
-  "screenshotQuality",
-  "remoteBrowserEnabled",
-  "remoteBrowserHost",
-  "enableCheckpoints",
-  "ttsEnabled",
-  "ttsSpeed",
-  "soundEnabled",
-  "soundVolume",
-  "maxOpenTabsContext",
-  "maxWorkspaceFiles",
-  "showRooIgnoredFiles",
-  "maxReadFileLine",
-  "terminalOutputLineLimit",
-  "terminalShellIntegrationTimeout",
-  "terminalShellIntegrationDisabled",
-  "terminalCommandDelay",
-  "terminalPowershellCounter",
-  "terminalZshClearEolMark",
-  "terminalZshOhMy",
-  "terminalZshP10k",
-  "terminalZdotdir",
-  "terminalCompressProgressBar",
-  "rateLimitSeconds",
-  "diffEnabled",
-  "fuzzyMatchThreshold",
-  "experiments",
-  "codebaseIndexModels",
-  "codebaseIndexConfig",
-  "language",
-  "telemetrySetting",
-  "mcpEnabled",
-  "enableMcpServerCreation",
-  "mode",
-  "modeApiConfigs",
-  "customModes",
-  "customModePrompts",
-  "customSupportPrompts",
-  "enhancementApiConfigId",
-  "cachedChromeHostUrl",
-  "historyPreviewCollapsed"
-]);
-var rooCodeSettingsSchema = providerSettingsSchema.merge(globalSettingsSchema);
-var SECRET_STATE_KEYS = keysOf()([
-  "apiKey",
-  "glamaApiKey",
-  "openRouterApiKey",
-  "awsAccessKey",
-  "awsSecretKey",
-  "awsSessionToken",
-  "openAiApiKey",
-  "geminiApiKey",
-  "openAiNativeApiKey",
-  "deepSeekApiKey",
-  "mistralApiKey",
-  "unboundApiKey",
-  "requestyApiKey",
-  "xaiApiKey",
-  "groqApiKey",
-  "chutesApiKey",
-  "litellmApiKey",
-  "codeIndexOpenAiKey",
-  "codeIndexQdrantApiKey"
-]);
-var isSecretStateKey = (key) => SECRET_STATE_KEYS.includes(key);
-var GLOBAL_STATE_KEYS = [...GLOBAL_SETTINGS_KEYS, ...PROVIDER_SETTINGS_KEYS].filter(
-  (key) => !SECRET_STATE_KEYS.includes(key)
-);
-var isGlobalStateKey = (key) => GLOBAL_STATE_KEYS.includes(key);
-
-// src/ipc.ts
-var import_zod12 = require("zod");
-
-// src/message.ts
-var import_zod11 = require("zod");
-var clineAsks = [
-  "followup",
-  "command",
-  "command_output",
-  "completion_result",
-  "tool",
-  "api_req_failed",
-  "resume_task",
-  "resume_completed_task",
-  "mistake_limit_reached",
-  "browser_action_launch",
-  "use_mcp_server",
-  "auto_approval_max_req_reached"
-];
-var clineAskSchema = import_zod11.z.enum(clineAsks);
-var clineSays = [
-  "error",
-  "api_req_started",
-  "api_req_finished",
-  "api_req_retried",
-  "api_req_retry_delayed",
-  "api_req_deleted",
-  "text",
-  "reasoning",
-  "completion_result",
-  "user_feedback",
-  "user_feedback_diff",
-  "command_output",
-  "shell_integration_warning",
-  "browser_action",
-  "browser_action_result",
-  "mcp_server_request_started",
-  "mcp_server_response",
-  "subtask_result",
-  "checkpoint_saved",
-  "rooignore_error",
-  "diff_error",
-  "condense_context",
-  "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 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 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")]),
-  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(),
-  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()
-});
-
-// src/ipc.ts
-var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
-  RooCodeEventName2["Message"] = "message";
-  RooCodeEventName2["TaskCreated"] = "taskCreated";
-  RooCodeEventName2["TaskStarted"] = "taskStarted";
-  RooCodeEventName2["TaskModeSwitched"] = "taskModeSwitched";
-  RooCodeEventName2["TaskPaused"] = "taskPaused";
-  RooCodeEventName2["TaskUnpaused"] = "taskUnpaused";
-  RooCodeEventName2["TaskAskResponded"] = "taskAskResponded";
-  RooCodeEventName2["TaskAborted"] = "taskAborted";
-  RooCodeEventName2["TaskSpawned"] = "taskSpawned";
-  RooCodeEventName2["TaskCompleted"] = "taskCompleted";
-  RooCodeEventName2["TaskTokenUsageUpdated"] = "taskTokenUsageUpdated";
-  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")]),
-      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()])
-});
-var ackSchema = import_zod12.z.object({
-  clientId: import_zod12.z.string(),
-  pid: import_zod12.z.number(),
-  ppid: import_zod12.z.number()
-});
-var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
-  TaskCommandName2["StartNewTask"] = "StartNewTask";
-  TaskCommandName2["CancelTask"] = "CancelTask";
-  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({
-      configuration: rooCodeSettingsSchema,
-      text: import_zod12.z.string(),
-      images: import_zod12.z.array(import_zod12.z.string()).optional(),
-      newTab: import_zod12.z.boolean().optional()
-    })
-  }),
-  import_zod12.z.object({
-    commandName: import_zod12.z.literal("CancelTask" /* CancelTask */),
-    data: import_zod12.z.string()
-  }),
-  import_zod12.z.object({
-    commandName: import_zod12.z.literal("CloseTask" /* CloseTask */),
-    data: import_zod12.z.string()
-  })
-]);
-var taskEventSchema = import_zod12.z.discriminatedUnion("eventName", [
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("message" /* Message */),
-    payload: rooCodeEventsSchema.shape["message" /* Message */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskCreated" /* TaskCreated */),
-    payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskStarted" /* TaskStarted */),
-    payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskModeSwitched" /* TaskModeSwitched */),
-    payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskPaused" /* TaskPaused */),
-    payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskUnpaused" /* TaskUnpaused */),
-    payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskAskResponded" /* TaskAskResponded */),
-    payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskAborted" /* TaskAborted */),
-    payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskSpawned" /* TaskSpawned */),
-    payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskCompleted" /* TaskCompleted */),
-    payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */]
-  }),
-  import_zod12.z.object({
-    eventName: import_zod12.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
-    payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]
-  })
-]);
-var IpcMessageType = /* @__PURE__ */ ((IpcMessageType2) => {
-  IpcMessageType2["Connect"] = "Connect";
-  IpcMessageType2["Disconnect"] = "Disconnect";
-  IpcMessageType2["Ack"] = "Ack";
-  IpcMessageType2["TaskCommand"] = "TaskCommand";
-  IpcMessageType2["TaskEvent"] = "TaskEvent";
-  return IpcMessageType2;
-})(IpcMessageType || {});
-var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
-  IpcOrigin2["Client"] = "client";
-  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 */),
-    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(),
-    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(),
-    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_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("output"),
-    output: import_zod13.z.string()
-  }),
-  import_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("exited"),
-    exitCode: import_zod13.z.number().optional()
-  }),
-  import_zod13.z.object({
-    executionId: import_zod13.z.string(),
-    status: import_zod13.z.literal("fallback")
-  })
-]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GLOBAL_SETTINGS_KEYS,
-  GLOBAL_STATE_KEYS,
-  IpcMessageType,
-  IpcOrigin,
-  PROVIDER_SETTINGS_KEYS,
-  RooCodeEventName,
-  SECRET_STATE_KEYS,
-  TaskCommandName,
-  TelemetryEventName,
-  ackSchema,
-  appPropertiesSchema,
-  clineAskSchema,
-  clineAsks,
-  clineMessageSchema,
-  clineSaySchema,
-  clineSays,
-  codeActionIds,
-  codebaseIndexConfigSchema,
-  codebaseIndexModelsSchema,
-  codebaseIndexProviderSchema,
-  commandExecutionStatusSchema,
-  commandIds,
-  contextCondenseSchema,
-  customModePromptsSchema,
-  customModesSettingsSchema,
-  customSupportPromptsSchema,
-  experimentIds,
-  experimentIdsSchema,
-  experimentsSchema,
-  globalSettingsSchema,
-  groupEntrySchema,
-  groupOptionsSchema,
-  historyItemSchema,
-  ipcMessageSchema,
-  isGlobalStateKey,
-  isLanguage,
-  isModelParameter,
-  isSecretStateKey,
-  keysOf,
-  languages,
-  languagesSchema,
-  modeConfigSchema,
-  modelInfoSchema,
-  modelParameters,
-  modelParametersSchema,
-  promptComponentSchema,
-  providerNames,
-  providerNamesSchema,
-  providerSettingsEntrySchema,
-  providerSettingsSchema,
-  providerSettingsSchemaDiscriminated,
-  reasoningEfforts,
-  reasoningEffortsSchema,
-  rooCodeEventsSchema,
-  rooCodeSettingsSchema,
-  rooCodeTelemetryEventSchema,
-  taskCommandSchema,
-  taskEventSchema,
-  taskPropertiesSchema,
-  telemetryPropertiesSchema,
-  telemetrySettings,
-  telemetrySettingsSchema,
-  terminalActionIds,
-  tokenUsageSchema,
-  toolGroups,
-  toolGroupsSchema,
-  toolNames,
-  toolNamesSchema,
-  toolProgressStatusSchema,
-  toolUsageSchema
-});
-//# sourceMappingURL=index.cjs.map