@roo-code/types 1.13.0 → 1.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/index.js +495 -399
  2. package/dist/index.js.map +1 -1
  3. package/dist/index.mjs +1117 -0
  4. package/dist/index.mjs.map +1 -0
  5. package/package.json +5 -4
  6. package/dist/index.cjs +0 -1213
  7. package/dist/index.cjs.map +0 -1
  8. /package/dist/{index.d.cts → index.d.mts} +0 -0
package/dist/index.js CHANGED
@@ -1,32 +1,127 @@
1
+ "use strict";
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
6
+ var __export = (target, all) => {
7
+ for (var name in all)
8
+ __defProp(target, name, { get: all[name], enumerable: true });
9
+ };
10
+ var __copyProps = (to, from, except, desc) => {
11
+ if (from && typeof from === "object" || typeof from === "function") {
12
+ for (let key of __getOwnPropNames(from))
13
+ if (!__hasOwnProp.call(to, key) && key !== except)
14
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
+ }
16
+ return to;
17
+ };
18
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
+
20
+ // src/index.ts
21
+ var index_exports = {};
22
+ __export(index_exports, {
23
+ GLOBAL_SETTINGS_KEYS: () => GLOBAL_SETTINGS_KEYS,
24
+ GLOBAL_STATE_KEYS: () => GLOBAL_STATE_KEYS,
25
+ IpcMessageType: () => IpcMessageType,
26
+ IpcOrigin: () => IpcOrigin,
27
+ PROVIDER_SETTINGS_KEYS: () => PROVIDER_SETTINGS_KEYS,
28
+ RooCodeEventName: () => RooCodeEventName,
29
+ SECRET_STATE_KEYS: () => SECRET_STATE_KEYS,
30
+ TaskCommandName: () => TaskCommandName,
31
+ TelemetryEventName: () => TelemetryEventName,
32
+ ackSchema: () => ackSchema,
33
+ appPropertiesSchema: () => appPropertiesSchema,
34
+ clineAskSchema: () => clineAskSchema,
35
+ clineAsks: () => clineAsks,
36
+ clineMessageSchema: () => clineMessageSchema,
37
+ clineSaySchema: () => clineSaySchema,
38
+ clineSays: () => clineSays,
39
+ codeActionIds: () => codeActionIds,
40
+ codebaseIndexConfigSchema: () => codebaseIndexConfigSchema,
41
+ codebaseIndexModelsSchema: () => codebaseIndexModelsSchema,
42
+ codebaseIndexProviderSchema: () => codebaseIndexProviderSchema,
43
+ commandExecutionStatusSchema: () => commandExecutionStatusSchema,
44
+ commandIds: () => commandIds,
45
+ contextCondenseSchema: () => contextCondenseSchema,
46
+ customModePromptsSchema: () => customModePromptsSchema,
47
+ customModesSettingsSchema: () => customModesSettingsSchema,
48
+ customSupportPromptsSchema: () => customSupportPromptsSchema,
49
+ experimentIds: () => experimentIds,
50
+ experimentIdsSchema: () => experimentIdsSchema,
51
+ experimentsSchema: () => experimentsSchema,
52
+ globalSettingsSchema: () => globalSettingsSchema,
53
+ groupEntrySchema: () => groupEntrySchema,
54
+ groupOptionsSchema: () => groupOptionsSchema,
55
+ historyItemSchema: () => historyItemSchema,
56
+ ipcMessageSchema: () => ipcMessageSchema,
57
+ isGlobalStateKey: () => isGlobalStateKey,
58
+ isLanguage: () => isLanguage,
59
+ isModelParameter: () => isModelParameter,
60
+ isSecretStateKey: () => isSecretStateKey,
61
+ keysOf: () => keysOf,
62
+ languages: () => languages,
63
+ languagesSchema: () => languagesSchema,
64
+ modeConfigSchema: () => modeConfigSchema,
65
+ modelInfoSchema: () => modelInfoSchema,
66
+ modelParameters: () => modelParameters,
67
+ modelParametersSchema: () => modelParametersSchema,
68
+ promptComponentSchema: () => promptComponentSchema,
69
+ providerNames: () => providerNames,
70
+ providerNamesSchema: () => providerNamesSchema,
71
+ providerSettingsEntrySchema: () => providerSettingsEntrySchema,
72
+ providerSettingsSchema: () => providerSettingsSchema,
73
+ providerSettingsSchemaDiscriminated: () => providerSettingsSchemaDiscriminated,
74
+ reasoningEfforts: () => reasoningEfforts,
75
+ reasoningEffortsSchema: () => reasoningEffortsSchema,
76
+ rooCodeEventsSchema: () => rooCodeEventsSchema,
77
+ rooCodeSettingsSchema: () => rooCodeSettingsSchema,
78
+ rooCodeTelemetryEventSchema: () => rooCodeTelemetryEventSchema,
79
+ taskCommandSchema: () => taskCommandSchema,
80
+ taskEventSchema: () => taskEventSchema,
81
+ taskPropertiesSchema: () => taskPropertiesSchema,
82
+ telemetryPropertiesSchema: () => telemetryPropertiesSchema,
83
+ telemetrySettings: () => telemetrySettings,
84
+ telemetrySettingsSchema: () => telemetrySettingsSchema,
85
+ terminalActionIds: () => terminalActionIds,
86
+ tokenUsageSchema: () => tokenUsageSchema,
87
+ toolGroups: () => toolGroups,
88
+ toolGroupsSchema: () => toolGroupsSchema,
89
+ toolNames: () => toolNames,
90
+ toolNamesSchema: () => toolNamesSchema,
91
+ toolProgressStatusSchema: () => toolProgressStatusSchema,
92
+ toolUsageSchema: () => toolUsageSchema
93
+ });
94
+ module.exports = __toCommonJS(index_exports);
95
+
1
96
  // src/codebase-index.ts
2
- import { z } from "zod";
3
- var codebaseIndexConfigSchema = z.object({
4
- codebaseIndexEnabled: z.boolean().optional(),
5
- codebaseIndexQdrantUrl: z.string().optional(),
6
- codebaseIndexEmbedderProvider: z.enum(["openai", "ollama"]).optional(),
7
- codebaseIndexEmbedderBaseUrl: z.string().optional(),
8
- codebaseIndexEmbedderModelId: z.string().optional()
97
+ var import_zod = require("zod");
98
+ var codebaseIndexConfigSchema = import_zod.z.object({
99
+ codebaseIndexEnabled: import_zod.z.boolean().optional(),
100
+ codebaseIndexQdrantUrl: import_zod.z.string().optional(),
101
+ codebaseIndexEmbedderProvider: import_zod.z.enum(["openai", "ollama"]).optional(),
102
+ codebaseIndexEmbedderBaseUrl: import_zod.z.string().optional(),
103
+ codebaseIndexEmbedderModelId: import_zod.z.string().optional()
9
104
  });
10
- var codebaseIndexModelsSchema = z.object({
11
- openai: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
12
- ollama: z.record(z.string(), z.object({ dimension: z.number() })).optional()
105
+ var codebaseIndexModelsSchema = import_zod.z.object({
106
+ openai: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
107
+ ollama: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional()
13
108
  });
14
- var codebaseIndexProviderSchema = z.object({
15
- codeIndexOpenAiKey: z.string().optional(),
16
- codeIndexQdrantApiKey: z.string().optional()
109
+ var codebaseIndexProviderSchema = import_zod.z.object({
110
+ codeIndexOpenAiKey: import_zod.z.string().optional(),
111
+ codeIndexQdrantApiKey: import_zod.z.string().optional()
17
112
  });
18
113
 
19
114
  // src/experiment.ts
20
- import { z as z2 } from "zod";
115
+ var import_zod2 = require("zod");
21
116
  var experimentIds = ["autoCondenseContext", "powerSteering"];
22
- var experimentIdsSchema = z2.enum(experimentIds);
23
- var experimentsSchema = z2.object({
24
- autoCondenseContext: z2.boolean(),
25
- powerSteering: z2.boolean()
117
+ var experimentIdsSchema = import_zod2.z.enum(experimentIds);
118
+ var experimentsSchema = import_zod2.z.object({
119
+ autoCondenseContext: import_zod2.z.boolean(),
120
+ powerSteering: import_zod2.z.boolean()
26
121
  });
27
122
 
28
123
  // src/global-settings.ts
29
- import { z as z10 } from "zod";
124
+ var import_zod10 = require("zod");
30
125
 
31
126
  // src/type-fu.ts
32
127
  function keysOf() {
@@ -34,42 +129,42 @@ function keysOf() {
34
129
  }
35
130
 
36
131
  // src/provider-settings.ts
37
- import { z as z4 } from "zod";
132
+ var import_zod4 = require("zod");
38
133
 
39
134
  // src/model.ts
40
- import { z as z3 } from "zod";
135
+ var import_zod3 = require("zod");
41
136
  var reasoningEfforts = ["low", "medium", "high"];
42
- var reasoningEffortsSchema = z3.enum(reasoningEfforts);
137
+ var reasoningEffortsSchema = import_zod3.z.enum(reasoningEfforts);
43
138
  var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
44
- var modelParametersSchema = z3.enum(modelParameters);
139
+ var modelParametersSchema = import_zod3.z.enum(modelParameters);
45
140
  var isModelParameter = (value) => modelParameters.includes(value);
46
- var modelInfoSchema = z3.object({
47
- maxTokens: z3.number().nullish(),
48
- maxThinkingTokens: z3.number().nullish(),
49
- contextWindow: z3.number(),
50
- supportsImages: z3.boolean().optional(),
51
- supportsComputerUse: z3.boolean().optional(),
52
- supportsPromptCache: z3.boolean(),
53
- supportsReasoningBudget: z3.boolean().optional(),
54
- requiredReasoningBudget: z3.boolean().optional(),
55
- supportsReasoningEffort: z3.boolean().optional(),
56
- supportedParameters: z3.array(modelParametersSchema).optional(),
57
- inputPrice: z3.number().optional(),
58
- outputPrice: z3.number().optional(),
59
- cacheWritesPrice: z3.number().optional(),
60
- cacheReadsPrice: z3.number().optional(),
61
- description: z3.string().optional(),
141
+ var modelInfoSchema = import_zod3.z.object({
142
+ maxTokens: import_zod3.z.number().nullish(),
143
+ maxThinkingTokens: import_zod3.z.number().nullish(),
144
+ contextWindow: import_zod3.z.number(),
145
+ supportsImages: import_zod3.z.boolean().optional(),
146
+ supportsComputerUse: import_zod3.z.boolean().optional(),
147
+ supportsPromptCache: import_zod3.z.boolean(),
148
+ supportsReasoningBudget: import_zod3.z.boolean().optional(),
149
+ requiredReasoningBudget: import_zod3.z.boolean().optional(),
150
+ supportsReasoningEffort: import_zod3.z.boolean().optional(),
151
+ supportedParameters: import_zod3.z.array(modelParametersSchema).optional(),
152
+ inputPrice: import_zod3.z.number().optional(),
153
+ outputPrice: import_zod3.z.number().optional(),
154
+ cacheWritesPrice: import_zod3.z.number().optional(),
155
+ cacheReadsPrice: import_zod3.z.number().optional(),
156
+ description: import_zod3.z.string().optional(),
62
157
  reasoningEffort: reasoningEffortsSchema.optional(),
63
- minTokensPerCachePoint: z3.number().optional(),
64
- maxCachePoints: z3.number().optional(),
65
- cachableFields: z3.array(z3.string()).optional(),
66
- tiers: z3.array(
67
- z3.object({
68
- contextWindow: z3.number(),
69
- inputPrice: z3.number().optional(),
70
- outputPrice: z3.number().optional(),
71
- cacheWritesPrice: z3.number().optional(),
72
- cacheReadsPrice: z3.number().optional()
158
+ minTokensPerCachePoint: import_zod3.z.number().optional(),
159
+ maxCachePoints: import_zod3.z.number().optional(),
160
+ cachableFields: import_zod3.z.array(import_zod3.z.string()).optional(),
161
+ tiers: import_zod3.z.array(
162
+ import_zod3.z.object({
163
+ contextWindow: import_zod3.z.number(),
164
+ inputPrice: import_zod3.z.number().optional(),
165
+ outputPrice: import_zod3.z.number().optional(),
166
+ cacheWritesPrice: import_zod3.z.number().optional(),
167
+ cacheReadsPrice: import_zod3.z.number().optional()
73
168
  })
74
169
  ).optional()
75
170
  });
@@ -98,162 +193,162 @@ var providerNames = [
98
193
  "chutes",
99
194
  "litellm"
100
195
  ];
101
- var providerNamesSchema = z4.enum(providerNames);
102
- var providerSettingsEntrySchema = z4.object({
103
- id: z4.string(),
104
- name: z4.string(),
196
+ var providerNamesSchema = import_zod4.z.enum(providerNames);
197
+ var providerSettingsEntrySchema = import_zod4.z.object({
198
+ id: import_zod4.z.string(),
199
+ name: import_zod4.z.string(),
105
200
  apiProvider: providerNamesSchema.optional()
106
201
  });
107
- var baseProviderSettingsSchema = z4.object({
108
- includeMaxTokens: z4.boolean().optional(),
109
- diffEnabled: z4.boolean().optional(),
110
- fuzzyMatchThreshold: z4.number().optional(),
111
- modelTemperature: z4.number().nullish(),
112
- rateLimitSeconds: z4.number().optional(),
202
+ var baseProviderSettingsSchema = import_zod4.z.object({
203
+ includeMaxTokens: import_zod4.z.boolean().optional(),
204
+ diffEnabled: import_zod4.z.boolean().optional(),
205
+ fuzzyMatchThreshold: import_zod4.z.number().optional(),
206
+ modelTemperature: import_zod4.z.number().nullish(),
207
+ rateLimitSeconds: import_zod4.z.number().optional(),
113
208
  // Model reasoning.
114
- enableReasoningEffort: z4.boolean().optional(),
209
+ enableReasoningEffort: import_zod4.z.boolean().optional(),
115
210
  reasoningEffort: reasoningEffortsSchema.optional(),
116
- modelMaxTokens: z4.number().optional(),
117
- modelMaxThinkingTokens: z4.number().optional()
211
+ modelMaxTokens: import_zod4.z.number().optional(),
212
+ modelMaxThinkingTokens: import_zod4.z.number().optional()
118
213
  });
119
214
  var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
120
- apiModelId: z4.string().optional()
215
+ apiModelId: import_zod4.z.string().optional()
121
216
  });
122
217
  var anthropicSchema = apiModelIdProviderModelSchema.extend({
123
- apiKey: z4.string().optional(),
124
- anthropicBaseUrl: z4.string().optional(),
125
- anthropicUseAuthToken: z4.boolean().optional()
218
+ apiKey: import_zod4.z.string().optional(),
219
+ anthropicBaseUrl: import_zod4.z.string().optional(),
220
+ anthropicUseAuthToken: import_zod4.z.boolean().optional()
126
221
  });
127
222
  var glamaSchema = baseProviderSettingsSchema.extend({
128
- glamaModelId: z4.string().optional(),
129
- glamaApiKey: z4.string().optional()
223
+ glamaModelId: import_zod4.z.string().optional(),
224
+ glamaApiKey: import_zod4.z.string().optional()
130
225
  });
131
226
  var openRouterSchema = baseProviderSettingsSchema.extend({
132
- openRouterApiKey: z4.string().optional(),
133
- openRouterModelId: z4.string().optional(),
134
- openRouterBaseUrl: z4.string().optional(),
135
- openRouterSpecificProvider: z4.string().optional(),
136
- openRouterUseMiddleOutTransform: z4.boolean().optional()
227
+ openRouterApiKey: import_zod4.z.string().optional(),
228
+ openRouterModelId: import_zod4.z.string().optional(),
229
+ openRouterBaseUrl: import_zod4.z.string().optional(),
230
+ openRouterSpecificProvider: import_zod4.z.string().optional(),
231
+ openRouterUseMiddleOutTransform: import_zod4.z.boolean().optional()
137
232
  });
138
233
  var bedrockSchema = apiModelIdProviderModelSchema.extend({
139
- awsAccessKey: z4.string().optional(),
140
- awsSecretKey: z4.string().optional(),
141
- awsSessionToken: z4.string().optional(),
142
- awsRegion: z4.string().optional(),
143
- awsUseCrossRegionInference: z4.boolean().optional(),
144
- awsUsePromptCache: z4.boolean().optional(),
145
- awsProfile: z4.string().optional(),
146
- awsUseProfile: z4.boolean().optional(),
147
- awsCustomArn: z4.string().optional()
234
+ awsAccessKey: import_zod4.z.string().optional(),
235
+ awsSecretKey: import_zod4.z.string().optional(),
236
+ awsSessionToken: import_zod4.z.string().optional(),
237
+ awsRegion: import_zod4.z.string().optional(),
238
+ awsUseCrossRegionInference: import_zod4.z.boolean().optional(),
239
+ awsUsePromptCache: import_zod4.z.boolean().optional(),
240
+ awsProfile: import_zod4.z.string().optional(),
241
+ awsUseProfile: import_zod4.z.boolean().optional(),
242
+ awsCustomArn: import_zod4.z.string().optional()
148
243
  });
149
244
  var vertexSchema = apiModelIdProviderModelSchema.extend({
150
- vertexKeyFile: z4.string().optional(),
151
- vertexJsonCredentials: z4.string().optional(),
152
- vertexProjectId: z4.string().optional(),
153
- vertexRegion: z4.string().optional()
245
+ vertexKeyFile: import_zod4.z.string().optional(),
246
+ vertexJsonCredentials: import_zod4.z.string().optional(),
247
+ vertexProjectId: import_zod4.z.string().optional(),
248
+ vertexRegion: import_zod4.z.string().optional()
154
249
  });
155
250
  var openAiSchema = baseProviderSettingsSchema.extend({
156
- openAiBaseUrl: z4.string().optional(),
157
- openAiApiKey: z4.string().optional(),
158
- openAiLegacyFormat: z4.boolean().optional(),
159
- openAiR1FormatEnabled: z4.boolean().optional(),
160
- openAiModelId: z4.string().optional(),
251
+ openAiBaseUrl: import_zod4.z.string().optional(),
252
+ openAiApiKey: import_zod4.z.string().optional(),
253
+ openAiLegacyFormat: import_zod4.z.boolean().optional(),
254
+ openAiR1FormatEnabled: import_zod4.z.boolean().optional(),
255
+ openAiModelId: import_zod4.z.string().optional(),
161
256
  openAiCustomModelInfo: modelInfoSchema.nullish(),
162
- openAiUseAzure: z4.boolean().optional(),
163
- azureApiVersion: z4.string().optional(),
164
- openAiStreamingEnabled: z4.boolean().optional(),
165
- openAiHostHeader: z4.string().optional(),
257
+ openAiUseAzure: import_zod4.z.boolean().optional(),
258
+ azureApiVersion: import_zod4.z.string().optional(),
259
+ openAiStreamingEnabled: import_zod4.z.boolean().optional(),
260
+ openAiHostHeader: import_zod4.z.string().optional(),
166
261
  // Keep temporarily for backward compatibility during migration.
167
- openAiHeaders: z4.record(z4.string(), z4.string()).optional()
262
+ openAiHeaders: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional()
168
263
  });
169
264
  var ollamaSchema = baseProviderSettingsSchema.extend({
170
- ollamaModelId: z4.string().optional(),
171
- ollamaBaseUrl: z4.string().optional()
265
+ ollamaModelId: import_zod4.z.string().optional(),
266
+ ollamaBaseUrl: import_zod4.z.string().optional()
172
267
  });
173
268
  var vsCodeLmSchema = baseProviderSettingsSchema.extend({
174
- vsCodeLmModelSelector: z4.object({
175
- vendor: z4.string().optional(),
176
- family: z4.string().optional(),
177
- version: z4.string().optional(),
178
- id: z4.string().optional()
269
+ vsCodeLmModelSelector: import_zod4.z.object({
270
+ vendor: import_zod4.z.string().optional(),
271
+ family: import_zod4.z.string().optional(),
272
+ version: import_zod4.z.string().optional(),
273
+ id: import_zod4.z.string().optional()
179
274
  }).optional()
180
275
  });
181
276
  var lmStudioSchema = baseProviderSettingsSchema.extend({
182
- lmStudioModelId: z4.string().optional(),
183
- lmStudioBaseUrl: z4.string().optional(),
184
- lmStudioDraftModelId: z4.string().optional(),
185
- lmStudioSpeculativeDecodingEnabled: z4.boolean().optional()
277
+ lmStudioModelId: import_zod4.z.string().optional(),
278
+ lmStudioBaseUrl: import_zod4.z.string().optional(),
279
+ lmStudioDraftModelId: import_zod4.z.string().optional(),
280
+ lmStudioSpeculativeDecodingEnabled: import_zod4.z.boolean().optional()
186
281
  });
187
282
  var geminiSchema = apiModelIdProviderModelSchema.extend({
188
- geminiApiKey: z4.string().optional(),
189
- googleGeminiBaseUrl: z4.string().optional()
283
+ geminiApiKey: import_zod4.z.string().optional(),
284
+ googleGeminiBaseUrl: import_zod4.z.string().optional()
190
285
  });
191
286
  var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
192
- openAiNativeApiKey: z4.string().optional(),
193
- openAiNativeBaseUrl: z4.string().optional()
287
+ openAiNativeApiKey: import_zod4.z.string().optional(),
288
+ openAiNativeBaseUrl: import_zod4.z.string().optional()
194
289
  });
195
290
  var mistralSchema = apiModelIdProviderModelSchema.extend({
196
- mistralApiKey: z4.string().optional(),
197
- mistralCodestralUrl: z4.string().optional()
291
+ mistralApiKey: import_zod4.z.string().optional(),
292
+ mistralCodestralUrl: import_zod4.z.string().optional()
198
293
  });
199
294
  var deepSeekSchema = apiModelIdProviderModelSchema.extend({
200
- deepSeekBaseUrl: z4.string().optional(),
201
- deepSeekApiKey: z4.string().optional()
295
+ deepSeekBaseUrl: import_zod4.z.string().optional(),
296
+ deepSeekApiKey: import_zod4.z.string().optional()
202
297
  });
203
298
  var unboundSchema = baseProviderSettingsSchema.extend({
204
- unboundApiKey: z4.string().optional(),
205
- unboundModelId: z4.string().optional()
299
+ unboundApiKey: import_zod4.z.string().optional(),
300
+ unboundModelId: import_zod4.z.string().optional()
206
301
  });
207
302
  var requestySchema = baseProviderSettingsSchema.extend({
208
- requestyApiKey: z4.string().optional(),
209
- requestyModelId: z4.string().optional()
303
+ requestyApiKey: import_zod4.z.string().optional(),
304
+ requestyModelId: import_zod4.z.string().optional()
210
305
  });
211
306
  var humanRelaySchema = baseProviderSettingsSchema;
212
307
  var fakeAiSchema = baseProviderSettingsSchema.extend({
213
- fakeAi: z4.unknown().optional()
308
+ fakeAi: import_zod4.z.unknown().optional()
214
309
  });
215
310
  var xaiSchema = apiModelIdProviderModelSchema.extend({
216
- xaiApiKey: z4.string().optional()
311
+ xaiApiKey: import_zod4.z.string().optional()
217
312
  });
218
313
  var groqSchema = apiModelIdProviderModelSchema.extend({
219
- groqApiKey: z4.string().optional()
314
+ groqApiKey: import_zod4.z.string().optional()
220
315
  });
221
316
  var chutesSchema = apiModelIdProviderModelSchema.extend({
222
- chutesApiKey: z4.string().optional()
317
+ chutesApiKey: import_zod4.z.string().optional()
223
318
  });
224
319
  var litellmSchema = baseProviderSettingsSchema.extend({
225
- litellmBaseUrl: z4.string().optional(),
226
- litellmApiKey: z4.string().optional(),
227
- litellmModelId: z4.string().optional()
320
+ litellmBaseUrl: import_zod4.z.string().optional(),
321
+ litellmApiKey: import_zod4.z.string().optional(),
322
+ litellmModelId: import_zod4.z.string().optional()
228
323
  });
229
- var defaultSchema = z4.object({
230
- apiProvider: z4.undefined()
324
+ var defaultSchema = import_zod4.z.object({
325
+ apiProvider: import_zod4.z.undefined()
231
326
  });
232
- var providerSettingsSchemaDiscriminated = z4.discriminatedUnion("apiProvider", [
233
- anthropicSchema.merge(z4.object({ apiProvider: z4.literal("anthropic") })),
234
- glamaSchema.merge(z4.object({ apiProvider: z4.literal("glama") })),
235
- openRouterSchema.merge(z4.object({ apiProvider: z4.literal("openrouter") })),
236
- bedrockSchema.merge(z4.object({ apiProvider: z4.literal("bedrock") })),
237
- vertexSchema.merge(z4.object({ apiProvider: z4.literal("vertex") })),
238
- openAiSchema.merge(z4.object({ apiProvider: z4.literal("openai") })),
239
- ollamaSchema.merge(z4.object({ apiProvider: z4.literal("ollama") })),
240
- vsCodeLmSchema.merge(z4.object({ apiProvider: z4.literal("vscode-lm") })),
241
- lmStudioSchema.merge(z4.object({ apiProvider: z4.literal("lmstudio") })),
242
- geminiSchema.merge(z4.object({ apiProvider: z4.literal("gemini") })),
243
- openAiNativeSchema.merge(z4.object({ apiProvider: z4.literal("openai-native") })),
244
- mistralSchema.merge(z4.object({ apiProvider: z4.literal("mistral") })),
245
- deepSeekSchema.merge(z4.object({ apiProvider: z4.literal("deepseek") })),
246
- unboundSchema.merge(z4.object({ apiProvider: z4.literal("unbound") })),
247
- requestySchema.merge(z4.object({ apiProvider: z4.literal("requesty") })),
248
- humanRelaySchema.merge(z4.object({ apiProvider: z4.literal("human-relay") })),
249
- fakeAiSchema.merge(z4.object({ apiProvider: z4.literal("fake-ai") })),
250
- xaiSchema.merge(z4.object({ apiProvider: z4.literal("xai") })),
251
- groqSchema.merge(z4.object({ apiProvider: z4.literal("groq") })),
252
- chutesSchema.merge(z4.object({ apiProvider: z4.literal("chutes") })),
253
- litellmSchema.merge(z4.object({ apiProvider: z4.literal("litellm") })),
327
+ var providerSettingsSchemaDiscriminated = import_zod4.z.discriminatedUnion("apiProvider", [
328
+ anthropicSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("anthropic") })),
329
+ glamaSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("glama") })),
330
+ openRouterSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("openrouter") })),
331
+ bedrockSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("bedrock") })),
332
+ vertexSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("vertex") })),
333
+ openAiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("openai") })),
334
+ ollamaSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("ollama") })),
335
+ vsCodeLmSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("vscode-lm") })),
336
+ lmStudioSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("lmstudio") })),
337
+ geminiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("gemini") })),
338
+ openAiNativeSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("openai-native") })),
339
+ mistralSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("mistral") })),
340
+ deepSeekSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("deepseek") })),
341
+ unboundSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("unbound") })),
342
+ requestySchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("requesty") })),
343
+ humanRelaySchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("human-relay") })),
344
+ fakeAiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("fake-ai") })),
345
+ xaiSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("xai") })),
346
+ groqSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("groq") })),
347
+ chutesSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("chutes") })),
348
+ litellmSchema.merge(import_zod4.z.object({ apiProvider: import_zod4.z.literal("litellm") })),
254
349
  defaultSchema
255
350
  ]);
256
- var providerSettingsSchema = z4.object({
351
+ var providerSettingsSchema = import_zod4.z.object({
257
352
  apiProvider: providerNamesSchema.optional(),
258
353
  ...anthropicSchema.shape,
259
354
  ...glamaSchema.shape,
@@ -378,25 +473,25 @@ var PROVIDER_SETTINGS_KEYS = keysOf()([
378
473
  ]);
379
474
 
380
475
  // src/history.ts
381
- import { z as z5 } from "zod";
382
- var historyItemSchema = z5.object({
383
- id: z5.string(),
384
- number: z5.number(),
385
- ts: z5.number(),
386
- task: z5.string(),
387
- tokensIn: z5.number(),
388
- tokensOut: z5.number(),
389
- cacheWrites: z5.number().optional(),
390
- cacheReads: z5.number().optional(),
391
- totalCost: z5.number(),
392
- size: z5.number().optional(),
393
- workspace: z5.string().optional()
476
+ var import_zod5 = require("zod");
477
+ var historyItemSchema = import_zod5.z.object({
478
+ id: import_zod5.z.string(),
479
+ number: import_zod5.z.number(),
480
+ ts: import_zod5.z.number(),
481
+ task: import_zod5.z.string(),
482
+ tokensIn: import_zod5.z.number(),
483
+ tokensOut: import_zod5.z.number(),
484
+ cacheWrites: import_zod5.z.number().optional(),
485
+ cacheReads: import_zod5.z.number().optional(),
486
+ totalCost: import_zod5.z.number(),
487
+ size: import_zod5.z.number().optional(),
488
+ workspace: import_zod5.z.string().optional()
394
489
  });
395
490
 
396
491
  // src/telemetry.ts
397
- import { z as z6 } from "zod";
492
+ var import_zod6 = require("zod");
398
493
  var telemetrySettings = ["unset", "enabled", "disabled"];
399
- var telemetrySettingsSchema = z6.enum(telemetrySettings);
494
+ var telemetrySettingsSchema = import_zod6.z.enum(telemetrySettings);
400
495
  var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
401
496
  TelemetryEventName2["TASK_CREATED"] = "Task Created";
402
497
  TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
@@ -420,35 +515,35 @@ var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
420
515
  TelemetryEventName2["CONSECUTIVE_MISTAKE_ERROR"] = "Consecutive Mistake Error";
421
516
  return TelemetryEventName2;
422
517
  })(TelemetryEventName || {});
423
- var appPropertiesSchema = z6.object({
424
- appVersion: z6.string(),
425
- vscodeVersion: z6.string(),
426
- platform: z6.string(),
427
- editorName: z6.string(),
428
- language: z6.string(),
429
- mode: z6.string()
518
+ var appPropertiesSchema = import_zod6.z.object({
519
+ appVersion: import_zod6.z.string(),
520
+ vscodeVersion: import_zod6.z.string(),
521
+ platform: import_zod6.z.string(),
522
+ editorName: import_zod6.z.string(),
523
+ language: import_zod6.z.string(),
524
+ mode: import_zod6.z.string()
430
525
  });
431
- var taskPropertiesSchema = z6.object({
432
- taskId: z6.string().optional(),
433
- apiProvider: z6.enum(providerNames).optional(),
434
- modelId: z6.string().optional(),
435
- diffStrategy: z6.string().optional(),
436
- isSubtask: z6.boolean().optional()
526
+ var taskPropertiesSchema = import_zod6.z.object({
527
+ taskId: import_zod6.z.string().optional(),
528
+ apiProvider: import_zod6.z.enum(providerNames).optional(),
529
+ modelId: import_zod6.z.string().optional(),
530
+ diffStrategy: import_zod6.z.string().optional(),
531
+ isSubtask: import_zod6.z.boolean().optional()
437
532
  });
438
- var telemetryPropertiesSchema = z6.object({
533
+ var telemetryPropertiesSchema = import_zod6.z.object({
439
534
  ...appPropertiesSchema.shape,
440
535
  ...taskPropertiesSchema.shape
441
536
  });
442
- var completionPropertiesSchema = z6.object({
443
- inputTokens: z6.number(),
444
- outputTokens: z6.number(),
445
- cacheReadTokens: z6.number().optional(),
446
- cacheWriteTokens: z6.number().optional(),
447
- cost: z6.number().optional()
537
+ var completionPropertiesSchema = import_zod6.z.object({
538
+ inputTokens: import_zod6.z.number(),
539
+ outputTokens: import_zod6.z.number(),
540
+ cacheReadTokens: import_zod6.z.number().optional(),
541
+ cacheWriteTokens: import_zod6.z.number().optional(),
542
+ cost: import_zod6.z.number().optional()
448
543
  });
449
- var rooCodeTelemetryEventSchema = z6.discriminatedUnion("type", [
450
- z6.object({
451
- type: z6.enum([
544
+ var rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
545
+ import_zod6.z.object({
546
+ type: import_zod6.z.enum([
452
547
  "Task Created" /* TASK_CREATED */,
453
548
  "Task Reopened" /* TASK_RESTARTED */,
454
549
  "Task Completed" /* TASK_COMPLETED */,
@@ -467,14 +562,14 @@ var rooCodeTelemetryEventSchema = z6.discriminatedUnion("type", [
467
562
  "Shell Integration Error" /* SHELL_INTEGRATION_ERROR */,
468
563
  "Consecutive Mistake Error" /* CONSECUTIVE_MISTAKE_ERROR */
469
564
  ]),
470
- properties: z6.object({
565
+ properties: import_zod6.z.object({
471
566
  ...appPropertiesSchema.shape,
472
567
  ...taskPropertiesSchema.shape
473
568
  })
474
569
  }),
475
- z6.object({
476
- type: z6.literal("LLM Completion" /* LLM_COMPLETION */),
477
- properties: z6.object({
570
+ import_zod6.z.object({
571
+ type: import_zod6.z.literal("LLM Completion" /* LLM_COMPLETION */),
572
+ properties: import_zod6.z.object({
478
573
  ...appPropertiesSchema.shape,
479
574
  ...taskPropertiesSchema.shape,
480
575
  ...completionPropertiesSchema.shape
@@ -483,12 +578,12 @@ var rooCodeTelemetryEventSchema = z6.discriminatedUnion("type", [
483
578
  ]);
484
579
 
485
580
  // src/mode.ts
486
- import { z as z8 } from "zod";
581
+ var import_zod8 = require("zod");
487
582
 
488
583
  // src/tool.ts
489
- import { z as z7 } from "zod";
584
+ var import_zod7 = require("zod");
490
585
  var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
491
- var toolGroupsSchema = z7.enum(toolGroups);
586
+ var toolGroupsSchema = import_zod7.z.enum(toolGroups);
492
587
  var toolNames = [
493
588
  "execute_command",
494
589
  "read_file",
@@ -509,18 +604,18 @@ var toolNames = [
509
604
  "fetch_instructions",
510
605
  "codebase_search"
511
606
  ];
512
- var toolNamesSchema = z7.enum(toolNames);
513
- var toolUsageSchema = z7.record(
607
+ var toolNamesSchema = import_zod7.z.enum(toolNames);
608
+ var toolUsageSchema = import_zod7.z.record(
514
609
  toolNamesSchema,
515
- z7.object({
516
- attempts: z7.number(),
517
- failures: z7.number()
610
+ import_zod7.z.object({
611
+ attempts: import_zod7.z.number(),
612
+ failures: import_zod7.z.number()
518
613
  })
519
614
  );
520
615
 
521
616
  // src/mode.ts
522
- var groupOptionsSchema = z8.object({
523
- fileRegex: z8.string().optional().refine(
617
+ var groupOptionsSchema = import_zod8.z.object({
618
+ fileRegex: import_zod8.z.string().optional().refine(
524
619
  (pattern) => {
525
620
  if (!pattern) {
526
621
  return true;
@@ -534,10 +629,10 @@ var groupOptionsSchema = z8.object({
534
629
  },
535
630
  { message: "Invalid regular expression pattern" }
536
631
  ),
537
- description: z8.string().optional()
632
+ description: import_zod8.z.string().optional()
538
633
  });
539
- var groupEntrySchema = z8.union([toolGroupsSchema, z8.tuple([toolGroupsSchema, groupOptionsSchema])]);
540
- var groupEntryArraySchema = z8.array(groupEntrySchema).refine(
634
+ var groupEntrySchema = import_zod8.z.union([toolGroupsSchema, import_zod8.z.tuple([toolGroupsSchema, groupOptionsSchema])]);
635
+ var groupEntryArraySchema = import_zod8.z.array(groupEntrySchema).refine(
541
636
  (groups) => {
542
637
  const seen = /* @__PURE__ */ new Set();
543
638
  return groups.every((group) => {
@@ -551,17 +646,17 @@ var groupEntryArraySchema = z8.array(groupEntrySchema).refine(
551
646
  },
552
647
  { message: "Duplicate groups are not allowed" }
553
648
  );
554
- var modeConfigSchema = z8.object({
555
- slug: z8.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
556
- name: z8.string().min(1, "Name is required"),
557
- roleDefinition: z8.string().min(1, "Role definition is required"),
558
- whenToUse: z8.string().optional(),
559
- customInstructions: z8.string().optional(),
649
+ var modeConfigSchema = import_zod8.z.object({
650
+ slug: import_zod8.z.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
651
+ name: import_zod8.z.string().min(1, "Name is required"),
652
+ roleDefinition: import_zod8.z.string().min(1, "Role definition is required"),
653
+ whenToUse: import_zod8.z.string().optional(),
654
+ customInstructions: import_zod8.z.string().optional(),
560
655
  groups: groupEntryArraySchema,
561
- source: z8.enum(["global", "project"]).optional()
656
+ source: import_zod8.z.enum(["global", "project"]).optional()
562
657
  });
563
- var customModesSettingsSchema = z8.object({
564
- customModes: z8.array(modeConfigSchema).refine(
658
+ var customModesSettingsSchema = import_zod8.z.object({
659
+ customModes: import_zod8.z.array(modeConfigSchema).refine(
565
660
  (modes) => {
566
661
  const slugs = /* @__PURE__ */ new Set();
567
662
  return modes.every((mode) => {
@@ -577,16 +672,16 @@ var customModesSettingsSchema = z8.object({
577
672
  }
578
673
  )
579
674
  });
580
- var promptComponentSchema = z8.object({
581
- roleDefinition: z8.string().optional(),
582
- whenToUse: z8.string().optional(),
583
- customInstructions: z8.string().optional()
675
+ var promptComponentSchema = import_zod8.z.object({
676
+ roleDefinition: import_zod8.z.string().optional(),
677
+ whenToUse: import_zod8.z.string().optional(),
678
+ customInstructions: import_zod8.z.string().optional()
584
679
  });
585
- var customModePromptsSchema = z8.record(z8.string(), promptComponentSchema.optional());
586
- var customSupportPromptsSchema = z8.record(z8.string(), z8.string().optional());
680
+ var customModePromptsSchema = import_zod8.z.record(import_zod8.z.string(), promptComponentSchema.optional());
681
+ var customSupportPromptsSchema = import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string().optional());
587
682
 
588
683
  // src/vscode.ts
589
- import { z as z9 } from "zod";
684
+ var import_zod9 = require("zod");
590
685
  var codeActionIds = ["explainCode", "fixCode", "improveCode", "addToContext", "newTask"];
591
686
  var terminalActionIds = ["terminalAddToContext", "terminalFixCommand", "terminalExplainCommand"];
592
687
  var commandIds = [
@@ -626,77 +721,77 @@ var languages = [
626
721
  "zh-CN",
627
722
  "zh-TW"
628
723
  ];
629
- var languagesSchema = z9.enum(languages);
724
+ var languagesSchema = import_zod9.z.enum(languages);
630
725
  var isLanguage = (value) => languages.includes(value);
631
726
 
632
727
  // src/global-settings.ts
633
- var globalSettingsSchema = z10.object({
634
- currentApiConfigName: z10.string().optional(),
635
- listApiConfigMeta: z10.array(providerSettingsEntrySchema).optional(),
636
- pinnedApiConfigs: z10.record(z10.string(), z10.boolean()).optional(),
637
- lastShownAnnouncementId: z10.string().optional(),
638
- customInstructions: z10.string().optional(),
639
- taskHistory: z10.array(historyItemSchema).optional(),
640
- condensingApiConfigId: z10.string().optional(),
641
- customCondensingPrompt: z10.string().optional(),
642
- autoApprovalEnabled: z10.boolean().optional(),
643
- alwaysAllowReadOnly: z10.boolean().optional(),
644
- alwaysAllowReadOnlyOutsideWorkspace: z10.boolean().optional(),
645
- alwaysAllowWrite: z10.boolean().optional(),
646
- alwaysAllowWriteOutsideWorkspace: z10.boolean().optional(),
647
- writeDelayMs: z10.number().optional(),
648
- alwaysAllowBrowser: z10.boolean().optional(),
649
- alwaysApproveResubmit: z10.boolean().optional(),
650
- requestDelaySeconds: z10.number().optional(),
651
- alwaysAllowMcp: z10.boolean().optional(),
652
- alwaysAllowModeSwitch: z10.boolean().optional(),
653
- alwaysAllowSubtasks: z10.boolean().optional(),
654
- alwaysAllowExecute: z10.boolean().optional(),
655
- allowedCommands: z10.array(z10.string()).optional(),
656
- allowedMaxRequests: z10.number().nullish(),
657
- autoCondenseContextPercent: z10.number().optional(),
658
- browserToolEnabled: z10.boolean().optional(),
659
- browserViewportSize: z10.string().optional(),
660
- screenshotQuality: z10.number().optional(),
661
- remoteBrowserEnabled: z10.boolean().optional(),
662
- remoteBrowserHost: z10.string().optional(),
663
- cachedChromeHostUrl: z10.string().optional(),
664
- enableCheckpoints: z10.boolean().optional(),
665
- ttsEnabled: z10.boolean().optional(),
666
- ttsSpeed: z10.number().optional(),
667
- soundEnabled: z10.boolean().optional(),
668
- soundVolume: z10.number().optional(),
669
- maxOpenTabsContext: z10.number().optional(),
670
- maxWorkspaceFiles: z10.number().optional(),
671
- showRooIgnoredFiles: z10.boolean().optional(),
672
- maxReadFileLine: z10.number().optional(),
673
- terminalOutputLineLimit: z10.number().optional(),
674
- terminalShellIntegrationTimeout: z10.number().optional(),
675
- terminalShellIntegrationDisabled: z10.boolean().optional(),
676
- terminalCommandDelay: z10.number().optional(),
677
- terminalPowershellCounter: z10.boolean().optional(),
678
- terminalZshClearEolMark: z10.boolean().optional(),
679
- terminalZshOhMy: z10.boolean().optional(),
680
- terminalZshP10k: z10.boolean().optional(),
681
- terminalZdotdir: z10.boolean().optional(),
682
- terminalCompressProgressBar: z10.boolean().optional(),
683
- rateLimitSeconds: z10.number().optional(),
684
- diffEnabled: z10.boolean().optional(),
685
- fuzzyMatchThreshold: z10.number().optional(),
728
+ var globalSettingsSchema = import_zod10.z.object({
729
+ currentApiConfigName: import_zod10.z.string().optional(),
730
+ listApiConfigMeta: import_zod10.z.array(providerSettingsEntrySchema).optional(),
731
+ pinnedApiConfigs: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.boolean()).optional(),
732
+ lastShownAnnouncementId: import_zod10.z.string().optional(),
733
+ customInstructions: import_zod10.z.string().optional(),
734
+ taskHistory: import_zod10.z.array(historyItemSchema).optional(),
735
+ condensingApiConfigId: import_zod10.z.string().optional(),
736
+ customCondensingPrompt: import_zod10.z.string().optional(),
737
+ autoApprovalEnabled: import_zod10.z.boolean().optional(),
738
+ alwaysAllowReadOnly: import_zod10.z.boolean().optional(),
739
+ alwaysAllowReadOnlyOutsideWorkspace: import_zod10.z.boolean().optional(),
740
+ alwaysAllowWrite: import_zod10.z.boolean().optional(),
741
+ alwaysAllowWriteOutsideWorkspace: import_zod10.z.boolean().optional(),
742
+ writeDelayMs: import_zod10.z.number().optional(),
743
+ alwaysAllowBrowser: import_zod10.z.boolean().optional(),
744
+ alwaysApproveResubmit: import_zod10.z.boolean().optional(),
745
+ requestDelaySeconds: import_zod10.z.number().optional(),
746
+ alwaysAllowMcp: import_zod10.z.boolean().optional(),
747
+ alwaysAllowModeSwitch: import_zod10.z.boolean().optional(),
748
+ alwaysAllowSubtasks: import_zod10.z.boolean().optional(),
749
+ alwaysAllowExecute: import_zod10.z.boolean().optional(),
750
+ allowedCommands: import_zod10.z.array(import_zod10.z.string()).optional(),
751
+ allowedMaxRequests: import_zod10.z.number().nullish(),
752
+ autoCondenseContextPercent: import_zod10.z.number().optional(),
753
+ browserToolEnabled: import_zod10.z.boolean().optional(),
754
+ browserViewportSize: import_zod10.z.string().optional(),
755
+ screenshotQuality: import_zod10.z.number().optional(),
756
+ remoteBrowserEnabled: import_zod10.z.boolean().optional(),
757
+ remoteBrowserHost: import_zod10.z.string().optional(),
758
+ cachedChromeHostUrl: import_zod10.z.string().optional(),
759
+ enableCheckpoints: import_zod10.z.boolean().optional(),
760
+ ttsEnabled: import_zod10.z.boolean().optional(),
761
+ ttsSpeed: import_zod10.z.number().optional(),
762
+ soundEnabled: import_zod10.z.boolean().optional(),
763
+ soundVolume: import_zod10.z.number().optional(),
764
+ maxOpenTabsContext: import_zod10.z.number().optional(),
765
+ maxWorkspaceFiles: import_zod10.z.number().optional(),
766
+ showRooIgnoredFiles: import_zod10.z.boolean().optional(),
767
+ maxReadFileLine: import_zod10.z.number().optional(),
768
+ terminalOutputLineLimit: import_zod10.z.number().optional(),
769
+ terminalShellIntegrationTimeout: import_zod10.z.number().optional(),
770
+ terminalShellIntegrationDisabled: import_zod10.z.boolean().optional(),
771
+ terminalCommandDelay: import_zod10.z.number().optional(),
772
+ terminalPowershellCounter: import_zod10.z.boolean().optional(),
773
+ terminalZshClearEolMark: import_zod10.z.boolean().optional(),
774
+ terminalZshOhMy: import_zod10.z.boolean().optional(),
775
+ terminalZshP10k: import_zod10.z.boolean().optional(),
776
+ terminalZdotdir: import_zod10.z.boolean().optional(),
777
+ terminalCompressProgressBar: import_zod10.z.boolean().optional(),
778
+ rateLimitSeconds: import_zod10.z.number().optional(),
779
+ diffEnabled: import_zod10.z.boolean().optional(),
780
+ fuzzyMatchThreshold: import_zod10.z.number().optional(),
686
781
  experiments: experimentsSchema.optional(),
687
782
  codebaseIndexModels: codebaseIndexModelsSchema.optional(),
688
783
  codebaseIndexConfig: codebaseIndexConfigSchema.optional(),
689
784
  language: languagesSchema.optional(),
690
785
  telemetrySetting: telemetrySettingsSchema.optional(),
691
- mcpEnabled: z10.boolean().optional(),
692
- enableMcpServerCreation: z10.boolean().optional(),
693
- mode: z10.string().optional(),
694
- modeApiConfigs: z10.record(z10.string(), z10.string()).optional(),
695
- customModes: z10.array(modeConfigSchema).optional(),
786
+ mcpEnabled: import_zod10.z.boolean().optional(),
787
+ enableMcpServerCreation: import_zod10.z.boolean().optional(),
788
+ mode: import_zod10.z.string().optional(),
789
+ modeApiConfigs: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.string()).optional(),
790
+ customModes: import_zod10.z.array(modeConfigSchema).optional(),
696
791
  customModePrompts: customModePromptsSchema.optional(),
697
792
  customSupportPrompts: customSupportPromptsSchema.optional(),
698
- enhancementApiConfigId: z10.string().optional(),
699
- historyPreviewCollapsed: z10.boolean().optional()
793
+ enhancementApiConfigId: import_zod10.z.string().optional(),
794
+ historyPreviewCollapsed: import_zod10.z.boolean().optional()
700
795
  });
701
796
  var GLOBAL_SETTINGS_KEYS = keysOf()([
702
797
  "currentApiConfigName",
@@ -795,10 +890,10 @@ var GLOBAL_STATE_KEYS = [...GLOBAL_SETTINGS_KEYS, ...PROVIDER_SETTINGS_KEYS].fil
795
890
  var isGlobalStateKey = (key) => GLOBAL_STATE_KEYS.includes(key);
796
891
 
797
892
  // src/ipc.ts
798
- import { z as z12 } from "zod";
893
+ var import_zod12 = require("zod");
799
894
 
800
895
  // src/message.ts
801
- import { z as z11 } from "zod";
896
+ var import_zod11 = require("zod");
802
897
  var clineAsks = [
803
898
  "followup",
804
899
  "command",
@@ -813,7 +908,7 @@ var clineAsks = [
813
908
  "use_mcp_server",
814
909
  "auto_approval_max_req_reached"
815
910
  ];
816
- var clineAskSchema = z11.enum(clineAsks);
911
+ var clineAskSchema = import_zod11.z.enum(clineAsks);
817
912
  var clineSays = [
818
913
  "error",
819
914
  "api_req_started",
@@ -839,38 +934,38 @@ var clineSays = [
839
934
  "condense_context",
840
935
  "codebase_search_result"
841
936
  ];
842
- var clineSaySchema = z11.enum(clineSays);
843
- var toolProgressStatusSchema = z11.object({
844
- icon: z11.string().optional(),
845
- text: z11.string().optional()
937
+ var clineSaySchema = import_zod11.z.enum(clineSays);
938
+ var toolProgressStatusSchema = import_zod11.z.object({
939
+ icon: import_zod11.z.string().optional(),
940
+ text: import_zod11.z.string().optional()
846
941
  });
847
- var contextCondenseSchema = z11.object({
848
- cost: z11.number(),
849
- prevContextTokens: z11.number(),
850
- newContextTokens: z11.number(),
851
- summary: z11.string()
942
+ var contextCondenseSchema = import_zod11.z.object({
943
+ cost: import_zod11.z.number(),
944
+ prevContextTokens: import_zod11.z.number(),
945
+ newContextTokens: import_zod11.z.number(),
946
+ summary: import_zod11.z.string()
852
947
  });
853
- var clineMessageSchema = z11.object({
854
- ts: z11.number(),
855
- type: z11.union([z11.literal("ask"), z11.literal("say")]),
948
+ var clineMessageSchema = import_zod11.z.object({
949
+ ts: import_zod11.z.number(),
950
+ type: import_zod11.z.union([import_zod11.z.literal("ask"), import_zod11.z.literal("say")]),
856
951
  ask: clineAskSchema.optional(),
857
952
  say: clineSaySchema.optional(),
858
- text: z11.string().optional(),
859
- images: z11.array(z11.string()).optional(),
860
- partial: z11.boolean().optional(),
861
- reasoning: z11.string().optional(),
862
- conversationHistoryIndex: z11.number().optional(),
863
- checkpoint: z11.record(z11.string(), z11.unknown()).optional(),
953
+ text: import_zod11.z.string().optional(),
954
+ images: import_zod11.z.array(import_zod11.z.string()).optional(),
955
+ partial: import_zod11.z.boolean().optional(),
956
+ reasoning: import_zod11.z.string().optional(),
957
+ conversationHistoryIndex: import_zod11.z.number().optional(),
958
+ checkpoint: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.unknown()).optional(),
864
959
  progressStatus: toolProgressStatusSchema.optional(),
865
960
  contextCondense: contextCondenseSchema.optional()
866
961
  });
867
- var tokenUsageSchema = z11.object({
868
- totalTokensIn: z11.number(),
869
- totalTokensOut: z11.number(),
870
- totalCacheWrites: z11.number().optional(),
871
- totalCacheReads: z11.number().optional(),
872
- totalCost: z11.number(),
873
- contextTokens: z11.number()
962
+ var tokenUsageSchema = import_zod11.z.object({
963
+ totalTokensIn: import_zod11.z.number(),
964
+ totalTokensOut: import_zod11.z.number(),
965
+ totalCacheWrites: import_zod11.z.number().optional(),
966
+ totalCacheReads: import_zod11.z.number().optional(),
967
+ totalCost: import_zod11.z.number(),
968
+ contextTokens: import_zod11.z.number()
874
969
  });
875
970
 
876
971
  // src/ipc.ts
@@ -889,30 +984,30 @@ var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
889
984
  RooCodeEventName2["TaskToolFailed"] = "taskToolFailed";
890
985
  return RooCodeEventName2;
891
986
  })(RooCodeEventName || {});
892
- var rooCodeEventsSchema = z12.object({
893
- ["message" /* Message */]: z12.tuple([
894
- z12.object({
895
- taskId: z12.string(),
896
- action: z12.union([z12.literal("created"), z12.literal("updated")]),
987
+ var rooCodeEventsSchema = import_zod12.z.object({
988
+ ["message" /* Message */]: import_zod12.z.tuple([
989
+ import_zod12.z.object({
990
+ taskId: import_zod12.z.string(),
991
+ action: import_zod12.z.union([import_zod12.z.literal("created"), import_zod12.z.literal("updated")]),
897
992
  message: clineMessageSchema
898
993
  })
899
994
  ]),
900
- ["taskCreated" /* TaskCreated */]: z12.tuple([z12.string()]),
901
- ["taskStarted" /* TaskStarted */]: z12.tuple([z12.string()]),
902
- ["taskModeSwitched" /* TaskModeSwitched */]: z12.tuple([z12.string(), z12.string()]),
903
- ["taskPaused" /* TaskPaused */]: z12.tuple([z12.string()]),
904
- ["taskUnpaused" /* TaskUnpaused */]: z12.tuple([z12.string()]),
905
- ["taskAskResponded" /* TaskAskResponded */]: z12.tuple([z12.string()]),
906
- ["taskAborted" /* TaskAborted */]: z12.tuple([z12.string()]),
907
- ["taskSpawned" /* TaskSpawned */]: z12.tuple([z12.string(), z12.string()]),
908
- ["taskCompleted" /* TaskCompleted */]: z12.tuple([z12.string(), tokenUsageSchema, toolUsageSchema]),
909
- ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z12.tuple([z12.string(), tokenUsageSchema]),
910
- ["taskToolFailed" /* TaskToolFailed */]: z12.tuple([z12.string(), toolNamesSchema, z12.string()])
995
+ ["taskCreated" /* TaskCreated */]: import_zod12.z.tuple([import_zod12.z.string()]),
996
+ ["taskStarted" /* TaskStarted */]: import_zod12.z.tuple([import_zod12.z.string()]),
997
+ ["taskModeSwitched" /* TaskModeSwitched */]: import_zod12.z.tuple([import_zod12.z.string(), import_zod12.z.string()]),
998
+ ["taskPaused" /* TaskPaused */]: import_zod12.z.tuple([import_zod12.z.string()]),
999
+ ["taskUnpaused" /* TaskUnpaused */]: import_zod12.z.tuple([import_zod12.z.string()]),
1000
+ ["taskAskResponded" /* TaskAskResponded */]: import_zod12.z.tuple([import_zod12.z.string()]),
1001
+ ["taskAborted" /* TaskAborted */]: import_zod12.z.tuple([import_zod12.z.string()]),
1002
+ ["taskSpawned" /* TaskSpawned */]: import_zod12.z.tuple([import_zod12.z.string(), import_zod12.z.string()]),
1003
+ ["taskCompleted" /* TaskCompleted */]: import_zod12.z.tuple([import_zod12.z.string(), tokenUsageSchema, toolUsageSchema]),
1004
+ ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: import_zod12.z.tuple([import_zod12.z.string(), tokenUsageSchema]),
1005
+ ["taskToolFailed" /* TaskToolFailed */]: import_zod12.z.tuple([import_zod12.z.string(), toolNamesSchema, import_zod12.z.string()])
911
1006
  });
912
- var ackSchema = z12.object({
913
- clientId: z12.string(),
914
- pid: z12.number(),
915
- ppid: z12.number()
1007
+ var ackSchema = import_zod12.z.object({
1008
+ clientId: import_zod12.z.string(),
1009
+ pid: import_zod12.z.number(),
1010
+ ppid: import_zod12.z.number()
916
1011
  });
917
1012
  var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
918
1013
  TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -920,68 +1015,68 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
920
1015
  TaskCommandName2["CloseTask"] = "CloseTask";
921
1016
  return TaskCommandName2;
922
1017
  })(TaskCommandName || {});
923
- var taskCommandSchema = z12.discriminatedUnion("commandName", [
924
- z12.object({
925
- commandName: z12.literal("StartNewTask" /* StartNewTask */),
926
- data: z12.object({
1018
+ var taskCommandSchema = import_zod12.z.discriminatedUnion("commandName", [
1019
+ import_zod12.z.object({
1020
+ commandName: import_zod12.z.literal("StartNewTask" /* StartNewTask */),
1021
+ data: import_zod12.z.object({
927
1022
  configuration: rooCodeSettingsSchema,
928
- text: z12.string(),
929
- images: z12.array(z12.string()).optional(),
930
- newTab: z12.boolean().optional()
1023
+ text: import_zod12.z.string(),
1024
+ images: import_zod12.z.array(import_zod12.z.string()).optional(),
1025
+ newTab: import_zod12.z.boolean().optional()
931
1026
  })
932
1027
  }),
933
- z12.object({
934
- commandName: z12.literal("CancelTask" /* CancelTask */),
935
- data: z12.string()
1028
+ import_zod12.z.object({
1029
+ commandName: import_zod12.z.literal("CancelTask" /* CancelTask */),
1030
+ data: import_zod12.z.string()
936
1031
  }),
937
- z12.object({
938
- commandName: z12.literal("CloseTask" /* CloseTask */),
939
- data: z12.string()
1032
+ import_zod12.z.object({
1033
+ commandName: import_zod12.z.literal("CloseTask" /* CloseTask */),
1034
+ data: import_zod12.z.string()
940
1035
  })
941
1036
  ]);
942
- var taskEventSchema = z12.discriminatedUnion("eventName", [
943
- z12.object({
944
- eventName: z12.literal("message" /* Message */),
1037
+ var taskEventSchema = import_zod12.z.discriminatedUnion("eventName", [
1038
+ import_zod12.z.object({
1039
+ eventName: import_zod12.z.literal("message" /* Message */),
945
1040
  payload: rooCodeEventsSchema.shape["message" /* Message */]
946
1041
  }),
947
- z12.object({
948
- eventName: z12.literal("taskCreated" /* TaskCreated */),
1042
+ import_zod12.z.object({
1043
+ eventName: import_zod12.z.literal("taskCreated" /* TaskCreated */),
949
1044
  payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */]
950
1045
  }),
951
- z12.object({
952
- eventName: z12.literal("taskStarted" /* TaskStarted */),
1046
+ import_zod12.z.object({
1047
+ eventName: import_zod12.z.literal("taskStarted" /* TaskStarted */),
953
1048
  payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */]
954
1049
  }),
955
- z12.object({
956
- eventName: z12.literal("taskModeSwitched" /* TaskModeSwitched */),
1050
+ import_zod12.z.object({
1051
+ eventName: import_zod12.z.literal("taskModeSwitched" /* TaskModeSwitched */),
957
1052
  payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */]
958
1053
  }),
959
- z12.object({
960
- eventName: z12.literal("taskPaused" /* TaskPaused */),
1054
+ import_zod12.z.object({
1055
+ eventName: import_zod12.z.literal("taskPaused" /* TaskPaused */),
961
1056
  payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */]
962
1057
  }),
963
- z12.object({
964
- eventName: z12.literal("taskUnpaused" /* TaskUnpaused */),
1058
+ import_zod12.z.object({
1059
+ eventName: import_zod12.z.literal("taskUnpaused" /* TaskUnpaused */),
965
1060
  payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */]
966
1061
  }),
967
- z12.object({
968
- eventName: z12.literal("taskAskResponded" /* TaskAskResponded */),
1062
+ import_zod12.z.object({
1063
+ eventName: import_zod12.z.literal("taskAskResponded" /* TaskAskResponded */),
969
1064
  payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */]
970
1065
  }),
971
- z12.object({
972
- eventName: z12.literal("taskAborted" /* TaskAborted */),
1066
+ import_zod12.z.object({
1067
+ eventName: import_zod12.z.literal("taskAborted" /* TaskAborted */),
973
1068
  payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */]
974
1069
  }),
975
- z12.object({
976
- eventName: z12.literal("taskSpawned" /* TaskSpawned */),
1070
+ import_zod12.z.object({
1071
+ eventName: import_zod12.z.literal("taskSpawned" /* TaskSpawned */),
977
1072
  payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */]
978
1073
  }),
979
- z12.object({
980
- eventName: z12.literal("taskCompleted" /* TaskCompleted */),
1074
+ import_zod12.z.object({
1075
+ eventName: import_zod12.z.literal("taskCompleted" /* TaskCompleted */),
981
1076
  payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */]
982
1077
  }),
983
- z12.object({
984
- eventName: z12.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
1078
+ import_zod12.z.object({
1079
+ eventName: import_zod12.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
985
1080
  payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]
986
1081
  })
987
1082
  ]);
@@ -998,51 +1093,52 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
998
1093
  IpcOrigin2["Server"] = "server";
999
1094
  return IpcOrigin2;
1000
1095
  })(IpcOrigin || {});
1001
- var ipcMessageSchema = z12.discriminatedUnion("type", [
1002
- z12.object({
1003
- type: z12.literal("Ack" /* Ack */),
1004
- origin: z12.literal("server" /* Server */),
1096
+ var ipcMessageSchema = import_zod12.z.discriminatedUnion("type", [
1097
+ import_zod12.z.object({
1098
+ type: import_zod12.z.literal("Ack" /* Ack */),
1099
+ origin: import_zod12.z.literal("server" /* Server */),
1005
1100
  data: ackSchema
1006
1101
  }),
1007
- z12.object({
1008
- type: z12.literal("TaskCommand" /* TaskCommand */),
1009
- origin: z12.literal("client" /* Client */),
1010
- clientId: z12.string(),
1102
+ import_zod12.z.object({
1103
+ type: import_zod12.z.literal("TaskCommand" /* TaskCommand */),
1104
+ origin: import_zod12.z.literal("client" /* Client */),
1105
+ clientId: import_zod12.z.string(),
1011
1106
  data: taskCommandSchema
1012
1107
  }),
1013
- z12.object({
1014
- type: z12.literal("TaskEvent" /* TaskEvent */),
1015
- origin: z12.literal("server" /* Server */),
1016
- relayClientId: z12.string().optional(),
1108
+ import_zod12.z.object({
1109
+ type: import_zod12.z.literal("TaskEvent" /* TaskEvent */),
1110
+ origin: import_zod12.z.literal("server" /* Server */),
1111
+ relayClientId: import_zod12.z.string().optional(),
1017
1112
  data: taskEventSchema
1018
1113
  })
1019
1114
  ]);
1020
1115
 
1021
1116
  // src/terminal.ts
1022
- import { z as z13 } from "zod";
1023
- var commandExecutionStatusSchema = z13.discriminatedUnion("status", [
1024
- z13.object({
1025
- executionId: z13.string(),
1026
- status: z13.literal("started"),
1027
- pid: z13.number().optional(),
1028
- command: z13.string()
1117
+ var import_zod13 = require("zod");
1118
+ var commandExecutionStatusSchema = import_zod13.z.discriminatedUnion("status", [
1119
+ import_zod13.z.object({
1120
+ executionId: import_zod13.z.string(),
1121
+ status: import_zod13.z.literal("started"),
1122
+ pid: import_zod13.z.number().optional(),
1123
+ command: import_zod13.z.string()
1029
1124
  }),
1030
- z13.object({
1031
- executionId: z13.string(),
1032
- status: z13.literal("output"),
1033
- output: z13.string()
1125
+ import_zod13.z.object({
1126
+ executionId: import_zod13.z.string(),
1127
+ status: import_zod13.z.literal("output"),
1128
+ output: import_zod13.z.string()
1034
1129
  }),
1035
- z13.object({
1036
- executionId: z13.string(),
1037
- status: z13.literal("exited"),
1038
- exitCode: z13.number().optional()
1130
+ import_zod13.z.object({
1131
+ executionId: import_zod13.z.string(),
1132
+ status: import_zod13.z.literal("exited"),
1133
+ exitCode: import_zod13.z.number().optional()
1039
1134
  }),
1040
- z13.object({
1041
- executionId: z13.string(),
1042
- status: z13.literal("fallback")
1135
+ import_zod13.z.object({
1136
+ executionId: import_zod13.z.string(),
1137
+ status: import_zod13.z.literal("fallback")
1043
1138
  })
1044
1139
  ]);
1045
- export {
1140
+ // Annotate the CommonJS export names for ESM import in node:
1141
+ 0 && (module.exports = {
1046
1142
  GLOBAL_SETTINGS_KEYS,
1047
1143
  GLOBAL_STATE_KEYS,
1048
1144
  IpcMessageType,
@@ -1113,5 +1209,5 @@ export {
1113
1209
  toolNamesSchema,
1114
1210
  toolProgressStatusSchema,
1115
1211
  toolUsageSchema
1116
- };
1212
+ });
1117
1213
  //# sourceMappingURL=index.js.map