@roo-code/types 1.18.0 → 1.20.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 (9) hide show
  1. package/dist/index.cjs +1249 -0
  2. package/dist/index.cjs.map +1 -0
  3. package/dist/index.d.cts +389 -2
  4. package/dist/index.d.ts +389 -2
  5. package/dist/index.js +489 -552
  6. package/dist/index.js.map +1 -1
  7. package/package.json +8 -5
  8. package/dist/index.mjs +0 -1117
  9. package/dist/index.mjs.map +0 -1
package/dist/index.js CHANGED
@@ -1,127 +1,60 @@
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
-
96
1
  // src/codebase-index.ts
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()
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()
104
9
  });
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()
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()
108
13
  });
109
- var codebaseIndexProviderSchema = import_zod.z.object({
110
- codeIndexOpenAiKey: import_zod.z.string().optional(),
111
- codeIndexQdrantApiKey: import_zod.z.string().optional()
14
+ var codebaseIndexProviderSchema = z.object({
15
+ codeIndexOpenAiKey: z.string().optional(),
16
+ codeIndexQdrantApiKey: z.string().optional()
17
+ });
18
+
19
+ // src/cloud.ts
20
+ import { z as z2 } from "zod";
21
+ var organizationAllowListSchema = z2.object({
22
+ allowAll: z2.boolean(),
23
+ providers: z2.record(
24
+ z2.object({
25
+ allowAll: z2.boolean(),
26
+ models: z2.array(z2.string()).optional()
27
+ })
28
+ )
29
+ });
30
+ var ORGANIZATION_ALLOW_ALL = {
31
+ allowAll: true,
32
+ providers: {}
33
+ };
34
+ var organizationSettingsSchema = z2.object({
35
+ version: z2.number(),
36
+ defaultSettings: z2.object({
37
+ enableCheckpoints: z2.boolean().optional(),
38
+ maxOpenTabsContext: z2.number().optional(),
39
+ maxWorkspaceFiles: z2.number().optional(),
40
+ showRooIgnoredFiles: z2.boolean().optional(),
41
+ maxReadFileLine: z2.number().optional(),
42
+ fuzzyMatchThreshold: z2.number().optional()
43
+ }).optional(),
44
+ allowList: organizationAllowListSchema
112
45
  });
113
46
 
114
47
  // src/experiment.ts
115
- var import_zod2 = require("zod");
48
+ import { z as z3 } from "zod";
116
49
  var experimentIds = ["autoCondenseContext", "powerSteering"];
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()
50
+ var experimentIdsSchema = z3.enum(experimentIds);
51
+ var experimentsSchema = z3.object({
52
+ autoCondenseContext: z3.boolean(),
53
+ powerSteering: z3.boolean()
121
54
  });
122
55
 
123
56
  // src/global-settings.ts
124
- var import_zod10 = require("zod");
57
+ import { z as z12 } from "zod";
125
58
 
126
59
  // src/type-fu.ts
127
60
  function keysOf() {
@@ -129,42 +62,42 @@ function keysOf() {
129
62
  }
130
63
 
131
64
  // src/provider-settings.ts
132
- var import_zod4 = require("zod");
65
+ import { z as z5 } from "zod";
133
66
 
134
67
  // src/model.ts
135
- var import_zod3 = require("zod");
68
+ import { z as z4 } from "zod";
136
69
  var reasoningEfforts = ["low", "medium", "high"];
137
- var reasoningEffortsSchema = import_zod3.z.enum(reasoningEfforts);
70
+ var reasoningEffortsSchema = z4.enum(reasoningEfforts);
138
71
  var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
139
- var modelParametersSchema = import_zod3.z.enum(modelParameters);
72
+ var modelParametersSchema = z4.enum(modelParameters);
140
73
  var isModelParameter = (value) => modelParameters.includes(value);
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(),
74
+ var modelInfoSchema = z4.object({
75
+ maxTokens: z4.number().nullish(),
76
+ maxThinkingTokens: z4.number().nullish(),
77
+ contextWindow: z4.number(),
78
+ supportsImages: z4.boolean().optional(),
79
+ supportsComputerUse: z4.boolean().optional(),
80
+ supportsPromptCache: z4.boolean(),
81
+ supportsReasoningBudget: z4.boolean().optional(),
82
+ requiredReasoningBudget: z4.boolean().optional(),
83
+ supportsReasoningEffort: z4.boolean().optional(),
84
+ supportedParameters: z4.array(modelParametersSchema).optional(),
85
+ inputPrice: z4.number().optional(),
86
+ outputPrice: z4.number().optional(),
87
+ cacheWritesPrice: z4.number().optional(),
88
+ cacheReadsPrice: z4.number().optional(),
89
+ description: z4.string().optional(),
157
90
  reasoningEffort: reasoningEffortsSchema.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()
91
+ minTokensPerCachePoint: z4.number().optional(),
92
+ maxCachePoints: z4.number().optional(),
93
+ cachableFields: z4.array(z4.string()).optional(),
94
+ tiers: z4.array(
95
+ z4.object({
96
+ contextWindow: z4.number(),
97
+ inputPrice: z4.number().optional(),
98
+ outputPrice: z4.number().optional(),
99
+ cacheWritesPrice: z4.number().optional(),
100
+ cacheReadsPrice: z4.number().optional()
168
101
  })
169
102
  ).optional()
170
103
  });
@@ -193,162 +126,162 @@ var providerNames = [
193
126
  "chutes",
194
127
  "litellm"
195
128
  ];
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(),
129
+ var providerNamesSchema = z5.enum(providerNames);
130
+ var providerSettingsEntrySchema = z5.object({
131
+ id: z5.string(),
132
+ name: z5.string(),
200
133
  apiProvider: providerNamesSchema.optional()
201
134
  });
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(),
135
+ var baseProviderSettingsSchema = z5.object({
136
+ includeMaxTokens: z5.boolean().optional(),
137
+ diffEnabled: z5.boolean().optional(),
138
+ fuzzyMatchThreshold: z5.number().optional(),
139
+ modelTemperature: z5.number().nullish(),
140
+ rateLimitSeconds: z5.number().optional(),
208
141
  // Model reasoning.
209
- enableReasoningEffort: import_zod4.z.boolean().optional(),
142
+ enableReasoningEffort: z5.boolean().optional(),
210
143
  reasoningEffort: reasoningEffortsSchema.optional(),
211
- modelMaxTokens: import_zod4.z.number().optional(),
212
- modelMaxThinkingTokens: import_zod4.z.number().optional()
144
+ modelMaxTokens: z5.number().optional(),
145
+ modelMaxThinkingTokens: z5.number().optional()
213
146
  });
214
147
  var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
215
- apiModelId: import_zod4.z.string().optional()
148
+ apiModelId: z5.string().optional()
216
149
  });
217
150
  var anthropicSchema = apiModelIdProviderModelSchema.extend({
218
- apiKey: import_zod4.z.string().optional(),
219
- anthropicBaseUrl: import_zod4.z.string().optional(),
220
- anthropicUseAuthToken: import_zod4.z.boolean().optional()
151
+ apiKey: z5.string().optional(),
152
+ anthropicBaseUrl: z5.string().optional(),
153
+ anthropicUseAuthToken: z5.boolean().optional()
221
154
  });
222
155
  var glamaSchema = baseProviderSettingsSchema.extend({
223
- glamaModelId: import_zod4.z.string().optional(),
224
- glamaApiKey: import_zod4.z.string().optional()
156
+ glamaModelId: z5.string().optional(),
157
+ glamaApiKey: z5.string().optional()
225
158
  });
226
159
  var openRouterSchema = baseProviderSettingsSchema.extend({
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()
160
+ openRouterApiKey: z5.string().optional(),
161
+ openRouterModelId: z5.string().optional(),
162
+ openRouterBaseUrl: z5.string().optional(),
163
+ openRouterSpecificProvider: z5.string().optional(),
164
+ openRouterUseMiddleOutTransform: z5.boolean().optional()
232
165
  });
233
166
  var bedrockSchema = apiModelIdProviderModelSchema.extend({
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()
167
+ awsAccessKey: z5.string().optional(),
168
+ awsSecretKey: z5.string().optional(),
169
+ awsSessionToken: z5.string().optional(),
170
+ awsRegion: z5.string().optional(),
171
+ awsUseCrossRegionInference: z5.boolean().optional(),
172
+ awsUsePromptCache: z5.boolean().optional(),
173
+ awsProfile: z5.string().optional(),
174
+ awsUseProfile: z5.boolean().optional(),
175
+ awsCustomArn: z5.string().optional()
243
176
  });
244
177
  var vertexSchema = apiModelIdProviderModelSchema.extend({
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()
178
+ vertexKeyFile: z5.string().optional(),
179
+ vertexJsonCredentials: z5.string().optional(),
180
+ vertexProjectId: z5.string().optional(),
181
+ vertexRegion: z5.string().optional()
249
182
  });
250
183
  var openAiSchema = baseProviderSettingsSchema.extend({
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(),
184
+ openAiBaseUrl: z5.string().optional(),
185
+ openAiApiKey: z5.string().optional(),
186
+ openAiLegacyFormat: z5.boolean().optional(),
187
+ openAiR1FormatEnabled: z5.boolean().optional(),
188
+ openAiModelId: z5.string().optional(),
256
189
  openAiCustomModelInfo: modelInfoSchema.nullish(),
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(),
190
+ openAiUseAzure: z5.boolean().optional(),
191
+ azureApiVersion: z5.string().optional(),
192
+ openAiStreamingEnabled: z5.boolean().optional(),
193
+ openAiHostHeader: z5.string().optional(),
261
194
  // Keep temporarily for backward compatibility during migration.
262
- openAiHeaders: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.string()).optional()
195
+ openAiHeaders: z5.record(z5.string(), z5.string()).optional()
263
196
  });
264
197
  var ollamaSchema = baseProviderSettingsSchema.extend({
265
- ollamaModelId: import_zod4.z.string().optional(),
266
- ollamaBaseUrl: import_zod4.z.string().optional()
198
+ ollamaModelId: z5.string().optional(),
199
+ ollamaBaseUrl: z5.string().optional()
267
200
  });
268
201
  var vsCodeLmSchema = baseProviderSettingsSchema.extend({
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()
202
+ vsCodeLmModelSelector: z5.object({
203
+ vendor: z5.string().optional(),
204
+ family: z5.string().optional(),
205
+ version: z5.string().optional(),
206
+ id: z5.string().optional()
274
207
  }).optional()
275
208
  });
276
209
  var lmStudioSchema = baseProviderSettingsSchema.extend({
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()
210
+ lmStudioModelId: z5.string().optional(),
211
+ lmStudioBaseUrl: z5.string().optional(),
212
+ lmStudioDraftModelId: z5.string().optional(),
213
+ lmStudioSpeculativeDecodingEnabled: z5.boolean().optional()
281
214
  });
282
215
  var geminiSchema = apiModelIdProviderModelSchema.extend({
283
- geminiApiKey: import_zod4.z.string().optional(),
284
- googleGeminiBaseUrl: import_zod4.z.string().optional()
216
+ geminiApiKey: z5.string().optional(),
217
+ googleGeminiBaseUrl: z5.string().optional()
285
218
  });
286
219
  var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
287
- openAiNativeApiKey: import_zod4.z.string().optional(),
288
- openAiNativeBaseUrl: import_zod4.z.string().optional()
220
+ openAiNativeApiKey: z5.string().optional(),
221
+ openAiNativeBaseUrl: z5.string().optional()
289
222
  });
290
223
  var mistralSchema = apiModelIdProviderModelSchema.extend({
291
- mistralApiKey: import_zod4.z.string().optional(),
292
- mistralCodestralUrl: import_zod4.z.string().optional()
224
+ mistralApiKey: z5.string().optional(),
225
+ mistralCodestralUrl: z5.string().optional()
293
226
  });
294
227
  var deepSeekSchema = apiModelIdProviderModelSchema.extend({
295
- deepSeekBaseUrl: import_zod4.z.string().optional(),
296
- deepSeekApiKey: import_zod4.z.string().optional()
228
+ deepSeekBaseUrl: z5.string().optional(),
229
+ deepSeekApiKey: z5.string().optional()
297
230
  });
298
231
  var unboundSchema = baseProviderSettingsSchema.extend({
299
- unboundApiKey: import_zod4.z.string().optional(),
300
- unboundModelId: import_zod4.z.string().optional()
232
+ unboundApiKey: z5.string().optional(),
233
+ unboundModelId: z5.string().optional()
301
234
  });
302
235
  var requestySchema = baseProviderSettingsSchema.extend({
303
- requestyApiKey: import_zod4.z.string().optional(),
304
- requestyModelId: import_zod4.z.string().optional()
236
+ requestyApiKey: z5.string().optional(),
237
+ requestyModelId: z5.string().optional()
305
238
  });
306
239
  var humanRelaySchema = baseProviderSettingsSchema;
307
240
  var fakeAiSchema = baseProviderSettingsSchema.extend({
308
- fakeAi: import_zod4.z.unknown().optional()
241
+ fakeAi: z5.unknown().optional()
309
242
  });
310
243
  var xaiSchema = apiModelIdProviderModelSchema.extend({
311
- xaiApiKey: import_zod4.z.string().optional()
244
+ xaiApiKey: z5.string().optional()
312
245
  });
313
246
  var groqSchema = apiModelIdProviderModelSchema.extend({
314
- groqApiKey: import_zod4.z.string().optional()
247
+ groqApiKey: z5.string().optional()
315
248
  });
316
249
  var chutesSchema = apiModelIdProviderModelSchema.extend({
317
- chutesApiKey: import_zod4.z.string().optional()
250
+ chutesApiKey: z5.string().optional()
318
251
  });
319
252
  var litellmSchema = baseProviderSettingsSchema.extend({
320
- litellmBaseUrl: import_zod4.z.string().optional(),
321
- litellmApiKey: import_zod4.z.string().optional(),
322
- litellmModelId: import_zod4.z.string().optional()
253
+ litellmBaseUrl: z5.string().optional(),
254
+ litellmApiKey: z5.string().optional(),
255
+ litellmModelId: z5.string().optional()
323
256
  });
324
- var defaultSchema = import_zod4.z.object({
325
- apiProvider: import_zod4.z.undefined()
257
+ var defaultSchema = z5.object({
258
+ apiProvider: z5.undefined()
326
259
  });
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") })),
260
+ var providerSettingsSchemaDiscriminated = z5.discriminatedUnion("apiProvider", [
261
+ anthropicSchema.merge(z5.object({ apiProvider: z5.literal("anthropic") })),
262
+ glamaSchema.merge(z5.object({ apiProvider: z5.literal("glama") })),
263
+ openRouterSchema.merge(z5.object({ apiProvider: z5.literal("openrouter") })),
264
+ bedrockSchema.merge(z5.object({ apiProvider: z5.literal("bedrock") })),
265
+ vertexSchema.merge(z5.object({ apiProvider: z5.literal("vertex") })),
266
+ openAiSchema.merge(z5.object({ apiProvider: z5.literal("openai") })),
267
+ ollamaSchema.merge(z5.object({ apiProvider: z5.literal("ollama") })),
268
+ vsCodeLmSchema.merge(z5.object({ apiProvider: z5.literal("vscode-lm") })),
269
+ lmStudioSchema.merge(z5.object({ apiProvider: z5.literal("lmstudio") })),
270
+ geminiSchema.merge(z5.object({ apiProvider: z5.literal("gemini") })),
271
+ openAiNativeSchema.merge(z5.object({ apiProvider: z5.literal("openai-native") })),
272
+ mistralSchema.merge(z5.object({ apiProvider: z5.literal("mistral") })),
273
+ deepSeekSchema.merge(z5.object({ apiProvider: z5.literal("deepseek") })),
274
+ unboundSchema.merge(z5.object({ apiProvider: z5.literal("unbound") })),
275
+ requestySchema.merge(z5.object({ apiProvider: z5.literal("requesty") })),
276
+ humanRelaySchema.merge(z5.object({ apiProvider: z5.literal("human-relay") })),
277
+ fakeAiSchema.merge(z5.object({ apiProvider: z5.literal("fake-ai") })),
278
+ xaiSchema.merge(z5.object({ apiProvider: z5.literal("xai") })),
279
+ groqSchema.merge(z5.object({ apiProvider: z5.literal("groq") })),
280
+ chutesSchema.merge(z5.object({ apiProvider: z5.literal("chutes") })),
281
+ litellmSchema.merge(z5.object({ apiProvider: z5.literal("litellm") })),
349
282
  defaultSchema
350
283
  ]);
351
- var providerSettingsSchema = import_zod4.z.object({
284
+ var providerSettingsSchema = z5.object({
352
285
  apiProvider: providerNamesSchema.optional(),
353
286
  ...anthropicSchema.shape,
354
287
  ...glamaSchema.shape,
@@ -473,29 +406,108 @@ var PROVIDER_SETTINGS_KEYS = keysOf()([
473
406
  ]);
474
407
 
475
408
  // src/history.ts
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()
409
+ import { z as z6 } from "zod";
410
+ var historyItemSchema = z6.object({
411
+ id: z6.string(),
412
+ number: z6.number(),
413
+ ts: z6.number(),
414
+ task: z6.string(),
415
+ tokensIn: z6.number(),
416
+ tokensOut: z6.number(),
417
+ cacheWrites: z6.number().optional(),
418
+ cacheReads: z6.number().optional(),
419
+ totalCost: z6.number(),
420
+ size: z6.number().optional(),
421
+ workspace: z6.string().optional()
422
+ });
423
+
424
+ // src/telemetry.ts
425
+ import { z as z8 } from "zod";
426
+
427
+ // src/message.ts
428
+ import { z as z7 } from "zod";
429
+ var clineAsks = [
430
+ "followup",
431
+ "command",
432
+ "command_output",
433
+ "completion_result",
434
+ "tool",
435
+ "api_req_failed",
436
+ "resume_task",
437
+ "resume_completed_task",
438
+ "mistake_limit_reached",
439
+ "browser_action_launch",
440
+ "use_mcp_server",
441
+ "auto_approval_max_req_reached"
442
+ ];
443
+ var clineAskSchema = z7.enum(clineAsks);
444
+ var clineSays = [
445
+ "error",
446
+ "api_req_started",
447
+ "api_req_finished",
448
+ "api_req_retried",
449
+ "api_req_retry_delayed",
450
+ "api_req_deleted",
451
+ "text",
452
+ "reasoning",
453
+ "completion_result",
454
+ "user_feedback",
455
+ "user_feedback_diff",
456
+ "command_output",
457
+ "shell_integration_warning",
458
+ "browser_action",
459
+ "browser_action_result",
460
+ "mcp_server_request_started",
461
+ "mcp_server_response",
462
+ "subtask_result",
463
+ "checkpoint_saved",
464
+ "rooignore_error",
465
+ "diff_error",
466
+ "condense_context",
467
+ "codebase_search_result"
468
+ ];
469
+ var clineSaySchema = z7.enum(clineSays);
470
+ var toolProgressStatusSchema = z7.object({
471
+ icon: z7.string().optional(),
472
+ text: z7.string().optional()
473
+ });
474
+ var contextCondenseSchema = z7.object({
475
+ cost: z7.number(),
476
+ prevContextTokens: z7.number(),
477
+ newContextTokens: z7.number(),
478
+ summary: z7.string()
479
+ });
480
+ var clineMessageSchema = z7.object({
481
+ ts: z7.number(),
482
+ type: z7.union([z7.literal("ask"), z7.literal("say")]),
483
+ ask: clineAskSchema.optional(),
484
+ say: clineSaySchema.optional(),
485
+ text: z7.string().optional(),
486
+ images: z7.array(z7.string()).optional(),
487
+ partial: z7.boolean().optional(),
488
+ reasoning: z7.string().optional(),
489
+ conversationHistoryIndex: z7.number().optional(),
490
+ checkpoint: z7.record(z7.string(), z7.unknown()).optional(),
491
+ progressStatus: toolProgressStatusSchema.optional(),
492
+ contextCondense: contextCondenseSchema.optional()
493
+ });
494
+ var tokenUsageSchema = z7.object({
495
+ totalTokensIn: z7.number(),
496
+ totalTokensOut: z7.number(),
497
+ totalCacheWrites: z7.number().optional(),
498
+ totalCacheReads: z7.number().optional(),
499
+ totalCost: z7.number(),
500
+ contextTokens: z7.number()
489
501
  });
490
502
 
491
503
  // src/telemetry.ts
492
- var import_zod6 = require("zod");
493
504
  var telemetrySettings = ["unset", "enabled", "disabled"];
494
- var telemetrySettingsSchema = import_zod6.z.enum(telemetrySettings);
505
+ var telemetrySettingsSchema = z8.enum(telemetrySettings);
495
506
  var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
496
507
  TelemetryEventName2["TASK_CREATED"] = "Task Created";
497
508
  TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
498
509
  TelemetryEventName2["TASK_COMPLETED"] = "Task Completed";
510
+ TelemetryEventName2["TASK_MESSAGE"] = "Task Message";
499
511
  TelemetryEventName2["TASK_CONVERSATION_MESSAGE"] = "Conversation Message";
500
512
  TelemetryEventName2["LLM_COMPLETION"] = "LLM Completion";
501
513
  TelemetryEventName2["MODE_SWITCH"] = "Mode Switched";
@@ -515,35 +527,28 @@ var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
515
527
  TelemetryEventName2["CONSECUTIVE_MISTAKE_ERROR"] = "Consecutive Mistake Error";
516
528
  return TelemetryEventName2;
517
529
  })(TelemetryEventName || {});
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()
530
+ var appPropertiesSchema = z8.object({
531
+ appVersion: z8.string(),
532
+ vscodeVersion: z8.string(),
533
+ platform: z8.string(),
534
+ editorName: z8.string(),
535
+ language: z8.string(),
536
+ mode: z8.string()
525
537
  });
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()
538
+ var taskPropertiesSchema = z8.object({
539
+ taskId: z8.string().optional(),
540
+ apiProvider: z8.enum(providerNames).optional(),
541
+ modelId: z8.string().optional(),
542
+ diffStrategy: z8.string().optional(),
543
+ isSubtask: z8.boolean().optional()
532
544
  });
533
- var telemetryPropertiesSchema = import_zod6.z.object({
545
+ var telemetryPropertiesSchema = z8.object({
534
546
  ...appPropertiesSchema.shape,
535
547
  ...taskPropertiesSchema.shape
536
548
  });
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()
543
- });
544
- var rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
545
- import_zod6.z.object({
546
- type: import_zod6.z.enum([
549
+ var rooCodeTelemetryEventSchema = z8.discriminatedUnion("type", [
550
+ z8.object({
551
+ type: z8.enum([
547
552
  "Task Created" /* TASK_CREATED */,
548
553
  "Task Reopened" /* TASK_RESTARTED */,
549
554
  "Task Completed" /* TASK_COMPLETED */,
@@ -562,28 +567,35 @@ var rooCodeTelemetryEventSchema = import_zod6.z.discriminatedUnion("type", [
562
567
  "Shell Integration Error" /* SHELL_INTEGRATION_ERROR */,
563
568
  "Consecutive Mistake Error" /* CONSECUTIVE_MISTAKE_ERROR */
564
569
  ]),
565
- properties: import_zod6.z.object({
566
- ...appPropertiesSchema.shape,
567
- ...taskPropertiesSchema.shape
570
+ properties: telemetryPropertiesSchema
571
+ }),
572
+ z8.object({
573
+ type: z8.literal("Task Message" /* TASK_MESSAGE */),
574
+ properties: z8.object({
575
+ ...telemetryPropertiesSchema.shape,
576
+ message: clineMessageSchema
568
577
  })
569
578
  }),
570
- import_zod6.z.object({
571
- type: import_zod6.z.literal("LLM Completion" /* LLM_COMPLETION */),
572
- properties: import_zod6.z.object({
573
- ...appPropertiesSchema.shape,
574
- ...taskPropertiesSchema.shape,
575
- ...completionPropertiesSchema.shape
579
+ z8.object({
580
+ type: z8.literal("LLM Completion" /* LLM_COMPLETION */),
581
+ properties: z8.object({
582
+ ...telemetryPropertiesSchema.shape,
583
+ inputTokens: z8.number(),
584
+ outputTokens: z8.number(),
585
+ cacheReadTokens: z8.number().optional(),
586
+ cacheWriteTokens: z8.number().optional(),
587
+ cost: z8.number().optional()
576
588
  })
577
589
  })
578
590
  ]);
579
591
 
580
592
  // src/mode.ts
581
- var import_zod8 = require("zod");
593
+ import { z as z10 } from "zod";
582
594
 
583
595
  // src/tool.ts
584
- var import_zod7 = require("zod");
596
+ import { z as z9 } from "zod";
585
597
  var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
586
- var toolGroupsSchema = import_zod7.z.enum(toolGroups);
598
+ var toolGroupsSchema = z9.enum(toolGroups);
587
599
  var toolNames = [
588
600
  "execute_command",
589
601
  "read_file",
@@ -604,18 +616,18 @@ var toolNames = [
604
616
  "fetch_instructions",
605
617
  "codebase_search"
606
618
  ];
607
- var toolNamesSchema = import_zod7.z.enum(toolNames);
608
- var toolUsageSchema = import_zod7.z.record(
619
+ var toolNamesSchema = z9.enum(toolNames);
620
+ var toolUsageSchema = z9.record(
609
621
  toolNamesSchema,
610
- import_zod7.z.object({
611
- attempts: import_zod7.z.number(),
612
- failures: import_zod7.z.number()
622
+ z9.object({
623
+ attempts: z9.number(),
624
+ failures: z9.number()
613
625
  })
614
626
  );
615
627
 
616
628
  // src/mode.ts
617
- var groupOptionsSchema = import_zod8.z.object({
618
- fileRegex: import_zod8.z.string().optional().refine(
629
+ var groupOptionsSchema = z10.object({
630
+ fileRegex: z10.string().optional().refine(
619
631
  (pattern) => {
620
632
  if (!pattern) {
621
633
  return true;
@@ -629,10 +641,10 @@ var groupOptionsSchema = import_zod8.z.object({
629
641
  },
630
642
  { message: "Invalid regular expression pattern" }
631
643
  ),
632
- description: import_zod8.z.string().optional()
644
+ description: z10.string().optional()
633
645
  });
634
- var groupEntrySchema = import_zod8.z.union([toolGroupsSchema, import_zod8.z.tuple([toolGroupsSchema, groupOptionsSchema])]);
635
- var groupEntryArraySchema = import_zod8.z.array(groupEntrySchema).refine(
646
+ var groupEntrySchema = z10.union([toolGroupsSchema, z10.tuple([toolGroupsSchema, groupOptionsSchema])]);
647
+ var groupEntryArraySchema = z10.array(groupEntrySchema).refine(
636
648
  (groups) => {
637
649
  const seen = /* @__PURE__ */ new Set();
638
650
  return groups.every((group) => {
@@ -646,17 +658,17 @@ var groupEntryArraySchema = import_zod8.z.array(groupEntrySchema).refine(
646
658
  },
647
659
  { message: "Duplicate groups are not allowed" }
648
660
  );
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(),
661
+ var modeConfigSchema = z10.object({
662
+ slug: z10.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
663
+ name: z10.string().min(1, "Name is required"),
664
+ roleDefinition: z10.string().min(1, "Role definition is required"),
665
+ whenToUse: z10.string().optional(),
666
+ customInstructions: z10.string().optional(),
655
667
  groups: groupEntryArraySchema,
656
- source: import_zod8.z.enum(["global", "project"]).optional()
668
+ source: z10.enum(["global", "project"]).optional()
657
669
  });
658
- var customModesSettingsSchema = import_zod8.z.object({
659
- customModes: import_zod8.z.array(modeConfigSchema).refine(
670
+ var customModesSettingsSchema = z10.object({
671
+ customModes: z10.array(modeConfigSchema).refine(
660
672
  (modes) => {
661
673
  const slugs = /* @__PURE__ */ new Set();
662
674
  return modes.every((mode) => {
@@ -672,16 +684,16 @@ var customModesSettingsSchema = import_zod8.z.object({
672
684
  }
673
685
  )
674
686
  });
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()
687
+ var promptComponentSchema = z10.object({
688
+ roleDefinition: z10.string().optional(),
689
+ whenToUse: z10.string().optional(),
690
+ customInstructions: z10.string().optional()
679
691
  });
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());
692
+ var customModePromptsSchema = z10.record(z10.string(), promptComponentSchema.optional());
693
+ var customSupportPromptsSchema = z10.record(z10.string(), z10.string().optional());
682
694
 
683
695
  // src/vscode.ts
684
- var import_zod9 = require("zod");
696
+ import { z as z11 } from "zod";
685
697
  var codeActionIds = ["explainCode", "fixCode", "improveCode", "addToContext", "newTask"];
686
698
  var terminalActionIds = ["terminalAddToContext", "terminalFixCommand", "terminalExplainCommand"];
687
699
  var commandIds = [
@@ -691,6 +703,7 @@ var commandIds = [
691
703
  "mcpButtonClicked",
692
704
  "historyButtonClicked",
693
705
  "popoutButtonClicked",
706
+ "accountButtonClicked",
694
707
  "settingsButtonClicked",
695
708
  "openInNewTab",
696
709
  "showHumanRelayDialog",
@@ -721,77 +734,77 @@ var languages = [
721
734
  "zh-CN",
722
735
  "zh-TW"
723
736
  ];
724
- var languagesSchema = import_zod9.z.enum(languages);
737
+ var languagesSchema = z11.enum(languages);
725
738
  var isLanguage = (value) => languages.includes(value);
726
739
 
727
740
  // src/global-settings.ts
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(),
741
+ var globalSettingsSchema = z12.object({
742
+ currentApiConfigName: z12.string().optional(),
743
+ listApiConfigMeta: z12.array(providerSettingsEntrySchema).optional(),
744
+ pinnedApiConfigs: z12.record(z12.string(), z12.boolean()).optional(),
745
+ lastShownAnnouncementId: z12.string().optional(),
746
+ customInstructions: z12.string().optional(),
747
+ taskHistory: z12.array(historyItemSchema).optional(),
748
+ condensingApiConfigId: z12.string().optional(),
749
+ customCondensingPrompt: z12.string().optional(),
750
+ autoApprovalEnabled: z12.boolean().optional(),
751
+ alwaysAllowReadOnly: z12.boolean().optional(),
752
+ alwaysAllowReadOnlyOutsideWorkspace: z12.boolean().optional(),
753
+ alwaysAllowWrite: z12.boolean().optional(),
754
+ alwaysAllowWriteOutsideWorkspace: z12.boolean().optional(),
755
+ writeDelayMs: z12.number().optional(),
756
+ alwaysAllowBrowser: z12.boolean().optional(),
757
+ alwaysApproveResubmit: z12.boolean().optional(),
758
+ requestDelaySeconds: z12.number().optional(),
759
+ alwaysAllowMcp: z12.boolean().optional(),
760
+ alwaysAllowModeSwitch: z12.boolean().optional(),
761
+ alwaysAllowSubtasks: z12.boolean().optional(),
762
+ alwaysAllowExecute: z12.boolean().optional(),
763
+ allowedCommands: z12.array(z12.string()).optional(),
764
+ allowedMaxRequests: z12.number().nullish(),
765
+ autoCondenseContextPercent: z12.number().optional(),
766
+ browserToolEnabled: z12.boolean().optional(),
767
+ browserViewportSize: z12.string().optional(),
768
+ screenshotQuality: z12.number().optional(),
769
+ remoteBrowserEnabled: z12.boolean().optional(),
770
+ remoteBrowserHost: z12.string().optional(),
771
+ cachedChromeHostUrl: z12.string().optional(),
772
+ enableCheckpoints: z12.boolean().optional(),
773
+ ttsEnabled: z12.boolean().optional(),
774
+ ttsSpeed: z12.number().optional(),
775
+ soundEnabled: z12.boolean().optional(),
776
+ soundVolume: z12.number().optional(),
777
+ maxOpenTabsContext: z12.number().optional(),
778
+ maxWorkspaceFiles: z12.number().optional(),
779
+ showRooIgnoredFiles: z12.boolean().optional(),
780
+ maxReadFileLine: z12.number().optional(),
781
+ terminalOutputLineLimit: z12.number().optional(),
782
+ terminalShellIntegrationTimeout: z12.number().optional(),
783
+ terminalShellIntegrationDisabled: z12.boolean().optional(),
784
+ terminalCommandDelay: z12.number().optional(),
785
+ terminalPowershellCounter: z12.boolean().optional(),
786
+ terminalZshClearEolMark: z12.boolean().optional(),
787
+ terminalZshOhMy: z12.boolean().optional(),
788
+ terminalZshP10k: z12.boolean().optional(),
789
+ terminalZdotdir: z12.boolean().optional(),
790
+ terminalCompressProgressBar: z12.boolean().optional(),
791
+ rateLimitSeconds: z12.number().optional(),
792
+ diffEnabled: z12.boolean().optional(),
793
+ fuzzyMatchThreshold: z12.number().optional(),
781
794
  experiments: experimentsSchema.optional(),
782
795
  codebaseIndexModels: codebaseIndexModelsSchema.optional(),
783
796
  codebaseIndexConfig: codebaseIndexConfigSchema.optional(),
784
797
  language: languagesSchema.optional(),
785
798
  telemetrySetting: telemetrySettingsSchema.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(),
799
+ mcpEnabled: z12.boolean().optional(),
800
+ enableMcpServerCreation: z12.boolean().optional(),
801
+ mode: z12.string().optional(),
802
+ modeApiConfigs: z12.record(z12.string(), z12.string()).optional(),
803
+ customModes: z12.array(modeConfigSchema).optional(),
791
804
  customModePrompts: customModePromptsSchema.optional(),
792
805
  customSupportPrompts: customSupportPromptsSchema.optional(),
793
- enhancementApiConfigId: import_zod10.z.string().optional(),
794
- historyPreviewCollapsed: import_zod10.z.boolean().optional()
806
+ enhancementApiConfigId: z12.string().optional(),
807
+ historyPreviewCollapsed: z12.boolean().optional()
795
808
  });
796
809
  var GLOBAL_SETTINGS_KEYS = keysOf()([
797
810
  "currentApiConfigName",
@@ -890,85 +903,7 @@ var GLOBAL_STATE_KEYS = [...GLOBAL_SETTINGS_KEYS, ...PROVIDER_SETTINGS_KEYS].fil
890
903
  var isGlobalStateKey = (key) => GLOBAL_STATE_KEYS.includes(key);
891
904
 
892
905
  // src/ipc.ts
893
- var import_zod12 = require("zod");
894
-
895
- // src/message.ts
896
- var import_zod11 = require("zod");
897
- var clineAsks = [
898
- "followup",
899
- "command",
900
- "command_output",
901
- "completion_result",
902
- "tool",
903
- "api_req_failed",
904
- "resume_task",
905
- "resume_completed_task",
906
- "mistake_limit_reached",
907
- "browser_action_launch",
908
- "use_mcp_server",
909
- "auto_approval_max_req_reached"
910
- ];
911
- var clineAskSchema = import_zod11.z.enum(clineAsks);
912
- var clineSays = [
913
- "error",
914
- "api_req_started",
915
- "api_req_finished",
916
- "api_req_retried",
917
- "api_req_retry_delayed",
918
- "api_req_deleted",
919
- "text",
920
- "reasoning",
921
- "completion_result",
922
- "user_feedback",
923
- "user_feedback_diff",
924
- "command_output",
925
- "shell_integration_warning",
926
- "browser_action",
927
- "browser_action_result",
928
- "mcp_server_request_started",
929
- "mcp_server_response",
930
- "subtask_result",
931
- "checkpoint_saved",
932
- "rooignore_error",
933
- "diff_error",
934
- "condense_context",
935
- "codebase_search_result"
936
- ];
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()
941
- });
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()
947
- });
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")]),
951
- ask: clineAskSchema.optional(),
952
- say: clineSaySchema.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(),
959
- progressStatus: toolProgressStatusSchema.optional(),
960
- contextCondense: contextCondenseSchema.optional()
961
- });
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()
969
- });
970
-
971
- // src/ipc.ts
906
+ import { z as z13 } from "zod";
972
907
  var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
973
908
  RooCodeEventName2["Message"] = "message";
974
909
  RooCodeEventName2["TaskCreated"] = "taskCreated";
@@ -984,30 +919,30 @@ var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
984
919
  RooCodeEventName2["TaskToolFailed"] = "taskToolFailed";
985
920
  return RooCodeEventName2;
986
921
  })(RooCodeEventName || {});
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")]),
922
+ var rooCodeEventsSchema = z13.object({
923
+ ["message" /* Message */]: z13.tuple([
924
+ z13.object({
925
+ taskId: z13.string(),
926
+ action: z13.union([z13.literal("created"), z13.literal("updated")]),
992
927
  message: clineMessageSchema
993
928
  })
994
929
  ]),
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()])
930
+ ["taskCreated" /* TaskCreated */]: z13.tuple([z13.string()]),
931
+ ["taskStarted" /* TaskStarted */]: z13.tuple([z13.string()]),
932
+ ["taskModeSwitched" /* TaskModeSwitched */]: z13.tuple([z13.string(), z13.string()]),
933
+ ["taskPaused" /* TaskPaused */]: z13.tuple([z13.string()]),
934
+ ["taskUnpaused" /* TaskUnpaused */]: z13.tuple([z13.string()]),
935
+ ["taskAskResponded" /* TaskAskResponded */]: z13.tuple([z13.string()]),
936
+ ["taskAborted" /* TaskAborted */]: z13.tuple([z13.string()]),
937
+ ["taskSpawned" /* TaskSpawned */]: z13.tuple([z13.string(), z13.string()]),
938
+ ["taskCompleted" /* TaskCompleted */]: z13.tuple([z13.string(), tokenUsageSchema, toolUsageSchema]),
939
+ ["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: z13.tuple([z13.string(), tokenUsageSchema]),
940
+ ["taskToolFailed" /* TaskToolFailed */]: z13.tuple([z13.string(), toolNamesSchema, z13.string()])
1006
941
  });
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()
942
+ var ackSchema = z13.object({
943
+ clientId: z13.string(),
944
+ pid: z13.number(),
945
+ ppid: z13.number()
1011
946
  });
1012
947
  var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
1013
948
  TaskCommandName2["StartNewTask"] = "StartNewTask";
@@ -1015,68 +950,68 @@ var TaskCommandName = /* @__PURE__ */ ((TaskCommandName2) => {
1015
950
  TaskCommandName2["CloseTask"] = "CloseTask";
1016
951
  return TaskCommandName2;
1017
952
  })(TaskCommandName || {});
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({
953
+ var taskCommandSchema = z13.discriminatedUnion("commandName", [
954
+ z13.object({
955
+ commandName: z13.literal("StartNewTask" /* StartNewTask */),
956
+ data: z13.object({
1022
957
  configuration: rooCodeSettingsSchema,
1023
- text: import_zod12.z.string(),
1024
- images: import_zod12.z.array(import_zod12.z.string()).optional(),
1025
- newTab: import_zod12.z.boolean().optional()
958
+ text: z13.string(),
959
+ images: z13.array(z13.string()).optional(),
960
+ newTab: z13.boolean().optional()
1026
961
  })
1027
962
  }),
1028
- import_zod12.z.object({
1029
- commandName: import_zod12.z.literal("CancelTask" /* CancelTask */),
1030
- data: import_zod12.z.string()
963
+ z13.object({
964
+ commandName: z13.literal("CancelTask" /* CancelTask */),
965
+ data: z13.string()
1031
966
  }),
1032
- import_zod12.z.object({
1033
- commandName: import_zod12.z.literal("CloseTask" /* CloseTask */),
1034
- data: import_zod12.z.string()
967
+ z13.object({
968
+ commandName: z13.literal("CloseTask" /* CloseTask */),
969
+ data: z13.string()
1035
970
  })
1036
971
  ]);
1037
- var taskEventSchema = import_zod12.z.discriminatedUnion("eventName", [
1038
- import_zod12.z.object({
1039
- eventName: import_zod12.z.literal("message" /* Message */),
972
+ var taskEventSchema = z13.discriminatedUnion("eventName", [
973
+ z13.object({
974
+ eventName: z13.literal("message" /* Message */),
1040
975
  payload: rooCodeEventsSchema.shape["message" /* Message */]
1041
976
  }),
1042
- import_zod12.z.object({
1043
- eventName: import_zod12.z.literal("taskCreated" /* TaskCreated */),
977
+ z13.object({
978
+ eventName: z13.literal("taskCreated" /* TaskCreated */),
1044
979
  payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */]
1045
980
  }),
1046
- import_zod12.z.object({
1047
- eventName: import_zod12.z.literal("taskStarted" /* TaskStarted */),
981
+ z13.object({
982
+ eventName: z13.literal("taskStarted" /* TaskStarted */),
1048
983
  payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */]
1049
984
  }),
1050
- import_zod12.z.object({
1051
- eventName: import_zod12.z.literal("taskModeSwitched" /* TaskModeSwitched */),
985
+ z13.object({
986
+ eventName: z13.literal("taskModeSwitched" /* TaskModeSwitched */),
1052
987
  payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */]
1053
988
  }),
1054
- import_zod12.z.object({
1055
- eventName: import_zod12.z.literal("taskPaused" /* TaskPaused */),
989
+ z13.object({
990
+ eventName: z13.literal("taskPaused" /* TaskPaused */),
1056
991
  payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */]
1057
992
  }),
1058
- import_zod12.z.object({
1059
- eventName: import_zod12.z.literal("taskUnpaused" /* TaskUnpaused */),
993
+ z13.object({
994
+ eventName: z13.literal("taskUnpaused" /* TaskUnpaused */),
1060
995
  payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */]
1061
996
  }),
1062
- import_zod12.z.object({
1063
- eventName: import_zod12.z.literal("taskAskResponded" /* TaskAskResponded */),
997
+ z13.object({
998
+ eventName: z13.literal("taskAskResponded" /* TaskAskResponded */),
1064
999
  payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */]
1065
1000
  }),
1066
- import_zod12.z.object({
1067
- eventName: import_zod12.z.literal("taskAborted" /* TaskAborted */),
1001
+ z13.object({
1002
+ eventName: z13.literal("taskAborted" /* TaskAborted */),
1068
1003
  payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */]
1069
1004
  }),
1070
- import_zod12.z.object({
1071
- eventName: import_zod12.z.literal("taskSpawned" /* TaskSpawned */),
1005
+ z13.object({
1006
+ eventName: z13.literal("taskSpawned" /* TaskSpawned */),
1072
1007
  payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */]
1073
1008
  }),
1074
- import_zod12.z.object({
1075
- eventName: import_zod12.z.literal("taskCompleted" /* TaskCompleted */),
1009
+ z13.object({
1010
+ eventName: z13.literal("taskCompleted" /* TaskCompleted */),
1076
1011
  payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */]
1077
1012
  }),
1078
- import_zod12.z.object({
1079
- eventName: import_zod12.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
1013
+ z13.object({
1014
+ eventName: z13.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
1080
1015
  payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]
1081
1016
  })
1082
1017
  ]);
@@ -1093,56 +1028,56 @@ var IpcOrigin = /* @__PURE__ */ ((IpcOrigin2) => {
1093
1028
  IpcOrigin2["Server"] = "server";
1094
1029
  return IpcOrigin2;
1095
1030
  })(IpcOrigin || {});
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 */),
1031
+ var ipcMessageSchema = z13.discriminatedUnion("type", [
1032
+ z13.object({
1033
+ type: z13.literal("Ack" /* Ack */),
1034
+ origin: z13.literal("server" /* Server */),
1100
1035
  data: ackSchema
1101
1036
  }),
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(),
1037
+ z13.object({
1038
+ type: z13.literal("TaskCommand" /* TaskCommand */),
1039
+ origin: z13.literal("client" /* Client */),
1040
+ clientId: z13.string(),
1106
1041
  data: taskCommandSchema
1107
1042
  }),
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(),
1043
+ z13.object({
1044
+ type: z13.literal("TaskEvent" /* TaskEvent */),
1045
+ origin: z13.literal("server" /* Server */),
1046
+ relayClientId: z13.string().optional(),
1112
1047
  data: taskEventSchema
1113
1048
  })
1114
1049
  ]);
1115
1050
 
1116
1051
  // src/terminal.ts
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()
1052
+ import { z as z14 } from "zod";
1053
+ var commandExecutionStatusSchema = z14.discriminatedUnion("status", [
1054
+ z14.object({
1055
+ executionId: z14.string(),
1056
+ status: z14.literal("started"),
1057
+ pid: z14.number().optional(),
1058
+ command: z14.string()
1124
1059
  }),
1125
- import_zod13.z.object({
1126
- executionId: import_zod13.z.string(),
1127
- status: import_zod13.z.literal("output"),
1128
- output: import_zod13.z.string()
1060
+ z14.object({
1061
+ executionId: z14.string(),
1062
+ status: z14.literal("output"),
1063
+ output: z14.string()
1129
1064
  }),
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()
1065
+ z14.object({
1066
+ executionId: z14.string(),
1067
+ status: z14.literal("exited"),
1068
+ exitCode: z14.number().optional()
1134
1069
  }),
1135
- import_zod13.z.object({
1136
- executionId: import_zod13.z.string(),
1137
- status: import_zod13.z.literal("fallback")
1070
+ z14.object({
1071
+ executionId: z14.string(),
1072
+ status: z14.literal("fallback")
1138
1073
  })
1139
1074
  ]);
1140
- // Annotate the CommonJS export names for ESM import in node:
1141
- 0 && (module.exports = {
1075
+ export {
1142
1076
  GLOBAL_SETTINGS_KEYS,
1143
1077
  GLOBAL_STATE_KEYS,
1144
1078
  IpcMessageType,
1145
1079
  IpcOrigin,
1080
+ ORGANIZATION_ALLOW_ALL,
1146
1081
  PROVIDER_SETTINGS_KEYS,
1147
1082
  RooCodeEventName,
1148
1083
  SECRET_STATE_KEYS,
@@ -1184,6 +1119,8 @@ var commandExecutionStatusSchema = import_zod13.z.discriminatedUnion("status", [
1184
1119
  modelInfoSchema,
1185
1120
  modelParameters,
1186
1121
  modelParametersSchema,
1122
+ organizationAllowListSchema,
1123
+ organizationSettingsSchema,
1187
1124
  promptComponentSchema,
1188
1125
  providerNames,
1189
1126
  providerNamesSchema,
@@ -1209,5 +1146,5 @@ var commandExecutionStatusSchema = import_zod13.z.discriminatedUnion("status", [
1209
1146
  toolNamesSchema,
1210
1147
  toolProgressStatusSchema,
1211
1148
  toolUsageSchema
1212
- });
1149
+ };
1213
1150
  //# sourceMappingURL=index.js.map