@roo-code/types 1.12.0 → 1.14.0

package/dist/index.js

@@ -0,0 +1,1213 @@
+"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.js.map