@roo-code/types
Version:
TypeScript type definitions for Roo Code.
1,088 lines (1,074 loc) • 165 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var index_exports = {};
__export(index_exports, {
ANTHROPIC_DEFAULT_MAX_TOKENS: () => ANTHROPIC_DEFAULT_MAX_TOKENS,
ANTHROPIC_STYLE_PROVIDERS: () => ANTHROPIC_STYLE_PROVIDERS,
AWS_INFERENCE_PROFILE_MAPPING: () => AWS_INFERENCE_PROFILE_MAPPING,
BEDROCK_CLAUDE_SONNET_4_MODEL_ID: () => BEDROCK_CLAUDE_SONNET_4_MODEL_ID,
BEDROCK_DEFAULT_CONTEXT: () => BEDROCK_DEFAULT_CONTEXT,
BEDROCK_DEFAULT_TEMPERATURE: () => BEDROCK_DEFAULT_TEMPERATURE,
BEDROCK_MAX_TOKENS: () => BEDROCK_MAX_TOKENS,
BEDROCK_REGIONS: () => BEDROCK_REGIONS,
CLAUDE_CODE_DEFAULT_MAX_OUTPUT_TOKENS: () => CLAUDE_CODE_DEFAULT_MAX_OUTPUT_TOKENS,
CODEBASE_INDEX_DEFAULTS: () => CODEBASE_INDEX_DEFAULTS,
DEEP_SEEK_DEFAULT_TEMPERATURE: () => DEEP_SEEK_DEFAULT_TEMPERATURE,
DEFAULT_CONSECUTIVE_MISTAKE_LIMIT: () => DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
DEFAULT_MODES: () => DEFAULT_MODES,
DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT: () => DEFAULT_TERMINAL_OUTPUT_CHARACTER_LIMIT,
DEFAULT_USAGE_COLLECTION_TIMEOUT_MS: () => DEFAULT_USAGE_COLLECTION_TIMEOUT_MS,
DEFAULT_WRITE_DELAY_MS: () => DEFAULT_WRITE_DELAY_MS,
DOUBAO_API_BASE_URL: () => DOUBAO_API_BASE_URL,
DOUBAO_API_CHAT_PATH: () => DOUBAO_API_CHAT_PATH,
EVALS_SETTINGS: () => EVALS_SETTINGS,
EVALS_TIMEOUT: () => EVALS_TIMEOUT,
GLAMA_DEFAULT_TEMPERATURE: () => GLAMA_DEFAULT_TEMPERATURE,
GLOBAL_SETTINGS_KEYS: () => GLOBAL_SETTINGS_KEYS,
GLOBAL_STATE_KEYS: () => GLOBAL_STATE_KEYS,
GPT5_DEFAULT_TEMPERATURE: () => GPT5_DEFAULT_TEMPERATURE,
HUGGINGFACE_API_URL: () => HUGGINGFACE_API_URL,
HUGGINGFACE_CACHE_DURATION: () => HUGGINGFACE_CACHE_DURATION,
HUGGINGFACE_DEFAULT_CONTEXT_WINDOW: () => HUGGINGFACE_DEFAULT_CONTEXT_WINDOW,
HUGGINGFACE_DEFAULT_MAX_TOKENS: () => HUGGINGFACE_DEFAULT_MAX_TOKENS,
HUGGINGFACE_MAX_TOKENS_FALLBACK: () => HUGGINGFACE_MAX_TOKENS_FALLBACK,
HUGGINGFACE_SLIDER_MIN: () => HUGGINGFACE_SLIDER_MIN,
HUGGINGFACE_SLIDER_STEP: () => HUGGINGFACE_SLIDER_STEP,
HUGGINGFACE_TEMPERATURE_MAX_VALUE: () => HUGGINGFACE_TEMPERATURE_MAX_VALUE,
IO_INTELLIGENCE_CACHE_DURATION: () => IO_INTELLIGENCE_CACHE_DURATION,
IpcMessageType: () => IpcMessageType,
IpcOrigin: () => IpcOrigin,
LITELLM_COMPUTER_USE_MODELS: () => LITELLM_COMPUTER_USE_MODELS,
LMSTUDIO_DEFAULT_TEMPERATURE: () => LMSTUDIO_DEFAULT_TEMPERATURE,
MISTRAL_DEFAULT_TEMPERATURE: () => MISTRAL_DEFAULT_TEMPERATURE,
MODEL_ID_KEYS: () => MODEL_ID_KEYS,
MOONSHOT_DEFAULT_TEMPERATURE: () => MOONSHOT_DEFAULT_TEMPERATURE,
OPENAI_AZURE_AI_INFERENCE_PATH: () => OPENAI_AZURE_AI_INFERENCE_PATH,
OPENAI_NATIVE_DEFAULT_TEMPERATURE: () => OPENAI_NATIVE_DEFAULT_TEMPERATURE,
OPENROUTER_DEFAULT_PROVIDER_NAME: () => OPENROUTER_DEFAULT_PROVIDER_NAME,
OPEN_ROUTER_COMPUTER_USE_MODELS: () => OPEN_ROUTER_COMPUTER_USE_MODELS,
OPEN_ROUTER_PROMPT_CACHING_MODELS: () => OPEN_ROUTER_PROMPT_CACHING_MODELS,
OPEN_ROUTER_REASONING_BUDGET_MODELS: () => OPEN_ROUTER_REASONING_BUDGET_MODELS,
OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS: () => OPEN_ROUTER_REQUIRED_REASONING_BUDGET_MODELS,
PROVIDER_SETTINGS_KEYS: () => PROVIDER_SETTINGS_KEYS,
RooCodeEventName: () => RooCodeEventName,
SECRET_STATE_KEYS: () => SECRET_STATE_KEYS,
TaskCommandName: () => TaskCommandName,
TelemetryEventName: () => TelemetryEventName,
VERTEX_REGIONS: () => VERTEX_REGIONS,
ZAI_DEFAULT_TEMPERATURE: () => ZAI_DEFAULT_TEMPERATURE,
ackSchema: () => ackSchema,
anthropicDefaultModelId: () => anthropicDefaultModelId,
anthropicModels: () => anthropicModels,
appPropertiesSchema: () => appPropertiesSchema,
azureOpenAiDefaultApiVersion: () => azureOpenAiDefaultApiVersion,
bedrockDefaultModelId: () => bedrockDefaultModelId,
bedrockDefaultPromptRouterModelId: () => bedrockDefaultPromptRouterModelId,
bedrockModels: () => bedrockModels,
blockingAsks: () => blockingAsks,
cerebrasDefaultModelId: () => cerebrasDefaultModelId,
cerebrasModels: () => cerebrasModels,
chutesDefaultModelId: () => chutesDefaultModelId,
chutesModels: () => chutesModels,
claudeCodeDefaultModelId: () => claudeCodeDefaultModelId,
claudeCodeModels: () => claudeCodeModels,
clineAskSchema: () => clineAskSchema,
clineAsks: () => clineAsks,
clineMessageSchema: () => clineMessageSchema,
clineSaySchema: () => clineSaySchema,
clineSays: () => clineSays,
codeActionIds: () => codeActionIds,
codebaseIndexConfigSchema: () => codebaseIndexConfigSchema,
codebaseIndexModelsSchema: () => codebaseIndexModelsSchema,
codebaseIndexProviderSchema: () => codebaseIndexProviderSchema,
commandExecutionStatusSchema: () => commandExecutionStatusSchema,
commandIds: () => commandIds,
contextCondenseSchema: () => contextCondenseSchema,
convertModelNameForVertex: () => convertModelNameForVertex,
customModePromptsSchema: () => customModePromptsSchema,
customModesSettingsSchema: () => customModesSettingsSchema,
customSupportPromptsSchema: () => customSupportPromptsSchema,
deepSeekDefaultModelId: () => deepSeekDefaultModelId,
deepSeekModels: () => deepSeekModels,
discriminatedProviderSettingsWithIdSchema: () => discriminatedProviderSettingsWithIdSchema,
doubaoDefaultModelId: () => doubaoDefaultModelId,
doubaoDefaultModelInfo: () => doubaoDefaultModelInfo,
doubaoModels: () => doubaoModels,
experimentIds: () => experimentIds,
experimentIdsSchema: () => experimentIdsSchema,
experimentsSchema: () => experimentsSchema,
extendedReasoningEffortsSchema: () => extendedReasoningEffortsSchema,
fireworksDefaultModelId: () => fireworksDefaultModelId,
fireworksModels: () => fireworksModels,
followUpDataSchema: () => followUpDataSchema,
geminiDefaultModelId: () => geminiDefaultModelId,
geminiModels: () => geminiModels,
getApiProtocol: () => getApiProtocol,
getClaudeCodeModelId: () => getClaudeCodeModelId,
getModelId: () => getModelId,
gitPropertiesSchema: () => gitPropertiesSchema,
glamaDefaultModelId: () => glamaDefaultModelId,
glamaDefaultModelInfo: () => glamaDefaultModelInfo,
globalSettingsSchema: () => globalSettingsSchema,
groqDefaultModelId: () => groqDefaultModelId,
groqModels: () => groqModels,
groupEntrySchema: () => groupEntrySchema,
groupOptionsSchema: () => groupOptionsSchema,
historyItemSchema: () => historyItemSchema,
installMarketplaceItemOptionsSchema: () => installMarketplaceItemOptionsSchema,
internationalZAiDefaultModelId: () => internationalZAiDefaultModelId,
internationalZAiModels: () => internationalZAiModels,
ioIntelligenceDefaultBaseUrl: () => ioIntelligenceDefaultBaseUrl,
ioIntelligenceDefaultModelId: () => ioIntelligenceDefaultModelId,
ioIntelligenceModels: () => ioIntelligenceModels,
ipcMessageSchema: () => ipcMessageSchema,
isBlockingAsk: () => isBlockingAsk,
isGlobalStateKey: () => isGlobalStateKey,
isLanguage: () => isLanguage,
isModelParameter: () => isModelParameter,
isSecretStateKey: () => isSecretStateKey,
lMStudioDefaultModelId: () => lMStudioDefaultModelId,
lMStudioDefaultModelInfo: () => lMStudioDefaultModelInfo,
languages: () => languages,
languagesSchema: () => languagesSchema,
litellmDefaultModelId: () => litellmDefaultModelId,
litellmDefaultModelInfo: () => litellmDefaultModelInfo,
mainlandZAiDefaultModelId: () => mainlandZAiDefaultModelId,
mainlandZAiModels: () => mainlandZAiModels,
marketplaceItemSchema: () => marketplaceItemSchema,
marketplaceItemTypeSchema: () => marketplaceItemTypeSchema,
mcpExecutionStatusSchema: () => mcpExecutionStatusSchema,
mcpInstallationMethodSchema: () => mcpInstallationMethodSchema,
mcpMarketplaceItemSchema: () => mcpMarketplaceItemSchema,
mcpParameterSchema: () => mcpParameterSchema,
mistralDefaultModelId: () => mistralDefaultModelId,
mistralModels: () => mistralModels,
modeConfigSchema: () => modeConfigSchema,
modeMarketplaceItemSchema: () => modeMarketplaceItemSchema,
modelInfoSchema: () => modelInfoSchema,
modelParameters: () => modelParameters,
modelParametersSchema: () => modelParametersSchema,
moonshotDefaultModelId: () => moonshotDefaultModelId,
moonshotModels: () => moonshotModels,
ollamaDefaultModelId: () => ollamaDefaultModelId,
ollamaDefaultModelInfo: () => ollamaDefaultModelInfo,
openAiModelInfoSaneDefaults: () => openAiModelInfoSaneDefaults,
openAiNativeDefaultModelId: () => openAiNativeDefaultModelId,
openAiNativeModels: () => openAiNativeModels,
openRouterDefaultModelId: () => openRouterDefaultModelId,
openRouterDefaultModelInfo: () => openRouterDefaultModelInfo,
promptComponentSchema: () => promptComponentSchema,
providerNames: () => providerNames,
providerNamesSchema: () => providerNamesSchema,
providerSettingsEntrySchema: () => providerSettingsEntrySchema,
providerSettingsSchema: () => providerSettingsSchema,
providerSettingsSchemaDiscriminated: () => providerSettingsSchemaDiscriminated,
providerSettingsWithIdSchema: () => providerSettingsWithIdSchema,
reasoningEfforts: () => reasoningEfforts,
reasoningEffortsSchema: () => reasoningEffortsSchema,
requestyDefaultModelId: () => requestyDefaultModelId,
requestyDefaultModelInfo: () => requestyDefaultModelInfo,
rooCodeEventsSchema: () => rooCodeEventsSchema,
rooCodeSettingsSchema: () => rooCodeSettingsSchema,
rooCodeTelemetryEventSchema: () => rooCodeTelemetryEventSchema,
sambaNovaDefaultModelId: () => sambaNovaDefaultModelId,
sambaNovaModels: () => sambaNovaModels,
suggestionItemSchema: () => suggestionItemSchema,
taskCommandSchema: () => taskCommandSchema,
taskEventSchema: () => taskEventSchema,
taskPropertiesSchema: () => taskPropertiesSchema,
telemetryPropertiesSchema: () => telemetryPropertiesSchema,
telemetrySettings: () => telemetrySettings,
telemetrySettingsSchema: () => telemetrySettingsSchema,
terminalActionIds: () => terminalActionIds,
todoItemSchema: () => todoItemSchema,
todoStatusSchema: () => todoStatusSchema,
tokenUsageSchema: () => tokenUsageSchema,
toolGroups: () => toolGroups,
toolGroupsSchema: () => toolGroupsSchema,
toolNames: () => toolNames,
toolNamesSchema: () => toolNamesSchema,
toolProgressStatusSchema: () => toolProgressStatusSchema,
toolUsageSchema: () => toolUsageSchema,
unboundDefaultModelId: () => unboundDefaultModelId,
unboundDefaultModelInfo: () => unboundDefaultModelInfo,
verbosityLevels: () => verbosityLevels,
verbosityLevelsSchema: () => verbosityLevelsSchema,
vertexDefaultModelId: () => vertexDefaultModelId,
vertexModels: () => vertexModels,
vscodeLlmDefaultModelId: () => vscodeLlmDefaultModelId,
vscodeLlmModels: () => vscodeLlmModels,
xaiDefaultModelId: () => xaiDefaultModelId,
xaiModels: () => xaiModels
});
module.exports = __toCommonJS(index_exports);
// src/codebase-index.ts
var import_zod = require("zod");
var CODEBASE_INDEX_DEFAULTS = {
MIN_SEARCH_RESULTS: 10,
MAX_SEARCH_RESULTS: 200,
DEFAULT_SEARCH_RESULTS: 50,
SEARCH_RESULTS_STEP: 10,
MIN_SEARCH_SCORE: 0,
MAX_SEARCH_SCORE: 1,
DEFAULT_SEARCH_MIN_SCORE: 0.4,
SEARCH_SCORE_STEP: 0.05
};
var codebaseIndexConfigSchema = import_zod.z.object({
codebaseIndexEnabled: import_zod.z.boolean().optional(),
codebaseIndexQdrantUrl: import_zod.z.string().optional(),
codebaseIndexEmbedderProvider: import_zod.z.enum(["openai", "ollama", "openai-compatible", "gemini", "mistral"]).optional(),
codebaseIndexEmbedderBaseUrl: import_zod.z.string().optional(),
codebaseIndexEmbedderModelId: import_zod.z.string().optional(),
codebaseIndexEmbedderModelDimension: import_zod.z.number().optional(),
codebaseIndexSearchMinScore: import_zod.z.number().min(0).max(1).optional(),
codebaseIndexSearchMaxResults: import_zod.z.number().min(CODEBASE_INDEX_DEFAULTS.MIN_SEARCH_RESULTS).max(CODEBASE_INDEX_DEFAULTS.MAX_SEARCH_RESULTS).optional(),
// OpenAI Compatible specific fields
codebaseIndexOpenAiCompatibleBaseUrl: import_zod.z.string().optional(),
codebaseIndexOpenAiCompatibleModelDimension: import_zod.z.number().optional()
});
var codebaseIndexModelsSchema = import_zod.z.object({
openai: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
ollama: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
"openai-compatible": import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
gemini: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional(),
mistral: import_zod.z.record(import_zod.z.string(), import_zod.z.object({ dimension: import_zod.z.number() })).optional()
});
var codebaseIndexProviderSchema = import_zod.z.object({
codeIndexOpenAiKey: import_zod.z.string().optional(),
codeIndexQdrantApiKey: import_zod.z.string().optional(),
codebaseIndexOpenAiCompatibleBaseUrl: import_zod.z.string().optional(),
codebaseIndexOpenAiCompatibleApiKey: import_zod.z.string().optional(),
codebaseIndexOpenAiCompatibleModelDimension: import_zod.z.number().optional(),
codebaseIndexGeminiApiKey: import_zod.z.string().optional(),
codebaseIndexMistralApiKey: import_zod.z.string().optional()
});
// src/events.ts
var import_zod4 = require("zod");
// src/message.ts
var import_zod2 = require("zod");
var clineAsks = [
"followup",
"command",
"command_output",
"completion_result",
"tool",
"api_req_failed",
"resume_task",
"resume_completed_task",
"mistake_limit_reached",
"browser_action_launch",
"use_mcp_server",
"auto_approval_max_req_reached"
];
var clineAskSchema = import_zod2.z.enum(clineAsks);
var blockingAsks = [
"api_req_failed",
"mistake_limit_reached",
"completion_result",
"resume_task",
"resume_completed_task",
"command_output",
"auto_approval_max_req_reached"
];
function isBlockingAsk(ask) {
return blockingAsks.includes(ask);
}
var clineSays = [
"error",
"api_req_started",
"api_req_finished",
"api_req_retried",
"api_req_retry_delayed",
"api_req_deleted",
"text",
"reasoning",
"completion_result",
"user_feedback",
"user_feedback_diff",
"command_output",
"shell_integration_warning",
"browser_action",
"browser_action_result",
"mcp_server_request_started",
"mcp_server_response",
"subtask_result",
"checkpoint_saved",
"rooignore_error",
"diff_error",
"condense_context",
"condense_context_error",
"codebase_search_result",
"user_edit_todos"
];
var clineSaySchema = import_zod2.z.enum(clineSays);
var toolProgressStatusSchema = import_zod2.z.object({
icon: import_zod2.z.string().optional(),
text: import_zod2.z.string().optional()
});
var contextCondenseSchema = import_zod2.z.object({
cost: import_zod2.z.number(),
prevContextTokens: import_zod2.z.number(),
newContextTokens: import_zod2.z.number(),
summary: import_zod2.z.string()
});
var clineMessageSchema = import_zod2.z.object({
ts: import_zod2.z.number(),
type: import_zod2.z.union([import_zod2.z.literal("ask"), import_zod2.z.literal("say")]),
ask: clineAskSchema.optional(),
say: clineSaySchema.optional(),
text: import_zod2.z.string().optional(),
images: import_zod2.z.array(import_zod2.z.string()).optional(),
partial: import_zod2.z.boolean().optional(),
reasoning: import_zod2.z.string().optional(),
conversationHistoryIndex: import_zod2.z.number().optional(),
checkpoint: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
progressStatus: toolProgressStatusSchema.optional(),
contextCondense: contextCondenseSchema.optional(),
isProtected: import_zod2.z.boolean().optional(),
apiProtocol: import_zod2.z.union([import_zod2.z.literal("openai"), import_zod2.z.literal("anthropic")]).optional(),
metadata: import_zod2.z.object({
gpt5: import_zod2.z.object({
previous_response_id: import_zod2.z.string().optional(),
instructions: import_zod2.z.string().optional(),
reasoning_summary: import_zod2.z.string().optional()
}).optional()
}).optional()
});
var tokenUsageSchema = import_zod2.z.object({
totalTokensIn: import_zod2.z.number(),
totalTokensOut: import_zod2.z.number(),
totalCacheWrites: import_zod2.z.number().optional(),
totalCacheReads: import_zod2.z.number().optional(),
totalCost: import_zod2.z.number(),
contextTokens: import_zod2.z.number()
});
// src/tool.ts
var import_zod3 = require("zod");
var toolGroups = ["read", "edit", "browser", "command", "mcp", "modes"];
var toolGroupsSchema = import_zod3.z.enum(toolGroups);
var toolNames = [
"execute_command",
"read_file",
"write_to_file",
"apply_diff",
"insert_content",
"search_and_replace",
"search_files",
"list_files",
"list_code_definition_names",
"browser_action",
"use_mcp_tool",
"access_mcp_resource",
"ask_followup_question",
"attempt_completion",
"switch_mode",
"new_task",
"fetch_instructions",
"codebase_search",
"update_todo_list"
];
var toolNamesSchema = import_zod3.z.enum(toolNames);
var toolUsageSchema = import_zod3.z.record(
toolNamesSchema,
import_zod3.z.object({
attempts: import_zod3.z.number(),
failures: import_zod3.z.number()
})
);
// src/events.ts
var RooCodeEventName = /* @__PURE__ */ ((RooCodeEventName2) => {
RooCodeEventName2["TaskCreated"] = "taskCreated";
RooCodeEventName2["TaskStarted"] = "taskStarted";
RooCodeEventName2["TaskCompleted"] = "taskCompleted";
RooCodeEventName2["TaskAborted"] = "taskAborted";
RooCodeEventName2["TaskFocused"] = "taskFocused";
RooCodeEventName2["TaskUnfocused"] = "taskUnfocused";
RooCodeEventName2["TaskActive"] = "taskActive";
RooCodeEventName2["TaskIdle"] = "taskIdle";
RooCodeEventName2["TaskPaused"] = "taskPaused";
RooCodeEventName2["TaskUnpaused"] = "taskUnpaused";
RooCodeEventName2["TaskSpawned"] = "taskSpawned";
RooCodeEventName2["Message"] = "message";
RooCodeEventName2["TaskModeSwitched"] = "taskModeSwitched";
RooCodeEventName2["TaskAskResponded"] = "taskAskResponded";
RooCodeEventName2["TaskTokenUsageUpdated"] = "taskTokenUsageUpdated";
RooCodeEventName2["TaskToolFailed"] = "taskToolFailed";
RooCodeEventName2["EvalPass"] = "evalPass";
RooCodeEventName2["EvalFail"] = "evalFail";
return RooCodeEventName2;
})(RooCodeEventName || {});
var rooCodeEventsSchema = import_zod4.z.object({
["taskCreated" /* TaskCreated */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskStarted" /* TaskStarted */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskCompleted" /* TaskCompleted */]: import_zod4.z.tuple([
import_zod4.z.string(),
tokenUsageSchema,
toolUsageSchema,
import_zod4.z.object({
isSubtask: import_zod4.z.boolean()
})
]),
["taskAborted" /* TaskAborted */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskFocused" /* TaskFocused */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskUnfocused" /* TaskUnfocused */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskActive" /* TaskActive */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskIdle" /* TaskIdle */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskPaused" /* TaskPaused */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskUnpaused" /* TaskUnpaused */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskSpawned" /* TaskSpawned */]: import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]),
["message" /* Message */]: import_zod4.z.tuple([
import_zod4.z.object({
taskId: import_zod4.z.string(),
action: import_zod4.z.union([import_zod4.z.literal("created"), import_zod4.z.literal("updated")]),
message: clineMessageSchema
})
]),
["taskModeSwitched" /* TaskModeSwitched */]: import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]),
["taskAskResponded" /* TaskAskResponded */]: import_zod4.z.tuple([import_zod4.z.string()]),
["taskToolFailed" /* TaskToolFailed */]: import_zod4.z.tuple([import_zod4.z.string(), toolNamesSchema, import_zod4.z.string()]),
["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */]: import_zod4.z.tuple([import_zod4.z.string(), tokenUsageSchema])
});
var taskEventSchema = import_zod4.z.discriminatedUnion("eventName", [
// Task Provider Lifecycle
import_zod4.z.object({
eventName: import_zod4.z.literal("taskCreated" /* TaskCreated */),
payload: rooCodeEventsSchema.shape["taskCreated" /* TaskCreated */],
taskId: import_zod4.z.number().optional()
}),
// Task Lifecycle
import_zod4.z.object({
eventName: import_zod4.z.literal("taskStarted" /* TaskStarted */),
payload: rooCodeEventsSchema.shape["taskStarted" /* TaskStarted */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskCompleted" /* TaskCompleted */),
payload: rooCodeEventsSchema.shape["taskCompleted" /* TaskCompleted */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskAborted" /* TaskAborted */),
payload: rooCodeEventsSchema.shape["taskAborted" /* TaskAborted */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskFocused" /* TaskFocused */),
payload: rooCodeEventsSchema.shape["taskFocused" /* TaskFocused */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskUnfocused" /* TaskUnfocused */),
payload: rooCodeEventsSchema.shape["taskUnfocused" /* TaskUnfocused */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskActive" /* TaskActive */),
payload: rooCodeEventsSchema.shape["taskActive" /* TaskActive */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskIdle" /* TaskIdle */),
payload: rooCodeEventsSchema.shape["taskIdle" /* TaskIdle */],
taskId: import_zod4.z.number().optional()
}),
// Subtask Lifecycle
import_zod4.z.object({
eventName: import_zod4.z.literal("taskPaused" /* TaskPaused */),
payload: rooCodeEventsSchema.shape["taskPaused" /* TaskPaused */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskUnpaused" /* TaskUnpaused */),
payload: rooCodeEventsSchema.shape["taskUnpaused" /* TaskUnpaused */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskSpawned" /* TaskSpawned */),
payload: rooCodeEventsSchema.shape["taskSpawned" /* TaskSpawned */],
taskId: import_zod4.z.number().optional()
}),
// Task Execution
import_zod4.z.object({
eventName: import_zod4.z.literal("message" /* Message */),
payload: rooCodeEventsSchema.shape["message" /* Message */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskModeSwitched" /* TaskModeSwitched */),
payload: rooCodeEventsSchema.shape["taskModeSwitched" /* TaskModeSwitched */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskAskResponded" /* TaskAskResponded */),
payload: rooCodeEventsSchema.shape["taskAskResponded" /* TaskAskResponded */],
taskId: import_zod4.z.number().optional()
}),
// Task Analytics
import_zod4.z.object({
eventName: import_zod4.z.literal("taskToolFailed" /* TaskToolFailed */),
payload: rooCodeEventsSchema.shape["taskToolFailed" /* TaskToolFailed */],
taskId: import_zod4.z.number().optional()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("taskTokenUsageUpdated" /* TaskTokenUsageUpdated */),
payload: rooCodeEventsSchema.shape["taskTokenUsageUpdated" /* TaskTokenUsageUpdated */],
taskId: import_zod4.z.number().optional()
}),
// Evals
import_zod4.z.object({
eventName: import_zod4.z.literal("evalPass" /* EvalPass */),
payload: import_zod4.z.undefined(),
taskId: import_zod4.z.number()
}),
import_zod4.z.object({
eventName: import_zod4.z.literal("evalFail" /* EvalFail */),
payload: import_zod4.z.undefined(),
taskId: import_zod4.z.number()
})
]);
// src/experiment.ts
var import_zod5 = require("zod");
var experimentIds = ["powerSteering", "multiFileApplyDiff", "preventFocusDisruption", "assistantMessageParser"];
var experimentIdsSchema = import_zod5.z.enum(experimentIds);
var experimentsSchema = import_zod5.z.object({
powerSteering: import_zod5.z.boolean().optional(),
multiFileApplyDiff: import_zod5.z.boolean().optional(),
preventFocusDisruption: import_zod5.z.boolean().optional(),
assistantMessageParser: import_zod5.z.boolean().optional()
});
// src/followup.ts
var import_zod6 = require("zod");
var suggestionItemSchema = import_zod6.z.object({
answer: import_zod6.z.string(),
mode: import_zod6.z.string().optional()
});
var followUpDataSchema = import_zod6.z.object({
question: import_zod6.z.string().optional(),
suggest: import_zod6.z.array(suggestionItemSchema).optional()
});
// src/global-settings.ts
var import_zod13 = require("zod");
// src/provider-settings.ts
var import_zod8 = require("zod");
// src/model.ts
var import_zod7 = require("zod");
var reasoningEfforts = ["low", "medium", "high"];
var reasoningEffortsSchema = import_zod7.z.enum(reasoningEfforts);
var verbosityLevels = ["low", "medium", "high"];
var verbosityLevelsSchema = import_zod7.z.enum(verbosityLevels);
var modelParameters = ["max_tokens", "temperature", "reasoning", "include_reasoning"];
var modelParametersSchema = import_zod7.z.enum(modelParameters);
var isModelParameter = (value) => modelParameters.includes(value);
var modelInfoSchema = import_zod7.z.object({
maxTokens: import_zod7.z.number().nullish(),
maxThinkingTokens: import_zod7.z.number().nullish(),
contextWindow: import_zod7.z.number(),
supportsImages: import_zod7.z.boolean().optional(),
supportsComputerUse: import_zod7.z.boolean().optional(),
supportsPromptCache: import_zod7.z.boolean(),
// Capability flag to indicate whether the model supports an output verbosity parameter
supportsVerbosity: import_zod7.z.boolean().optional(),
supportsReasoningBudget: import_zod7.z.boolean().optional(),
requiredReasoningBudget: import_zod7.z.boolean().optional(),
supportsReasoningEffort: import_zod7.z.boolean().optional(),
supportedParameters: import_zod7.z.array(modelParametersSchema).optional(),
inputPrice: import_zod7.z.number().optional(),
outputPrice: import_zod7.z.number().optional(),
cacheWritesPrice: import_zod7.z.number().optional(),
cacheReadsPrice: import_zod7.z.number().optional(),
description: import_zod7.z.string().optional(),
reasoningEffort: reasoningEffortsSchema.optional(),
minTokensPerCachePoint: import_zod7.z.number().optional(),
maxCachePoints: import_zod7.z.number().optional(),
cachableFields: import_zod7.z.array(import_zod7.z.string()).optional(),
tiers: import_zod7.z.array(
import_zod7.z.object({
contextWindow: import_zod7.z.number(),
inputPrice: import_zod7.z.number().optional(),
outputPrice: import_zod7.z.number().optional(),
cacheWritesPrice: import_zod7.z.number().optional(),
cacheReadsPrice: import_zod7.z.number().optional()
})
).optional()
});
// src/provider-settings.ts
var BEDROCK_CLAUDE_SONNET_4_MODEL_ID = "anthropic.claude-sonnet-4-20250514-v1:0";
var extendedReasoningEffortsSchema = import_zod8.z.union([reasoningEffortsSchema, import_zod8.z.literal("minimal")]);
var providerNames = [
"anthropic",
"claude-code",
"glama",
"openrouter",
"bedrock",
"vertex",
"openai",
"ollama",
"vscode-lm",
"lmstudio",
"gemini",
"gemini-cli",
"openai-native",
"mistral",
"moonshot",
"deepseek",
"doubao",
"unbound",
"requesty",
"human-relay",
"fake-ai",
"xai",
"groq",
"chutes",
"litellm",
"huggingface",
"cerebras",
"sambanova",
"zai",
"fireworks",
"io-intelligence"
];
var providerNamesSchema = import_zod8.z.enum(providerNames);
var providerSettingsEntrySchema = import_zod8.z.object({
id: import_zod8.z.string(),
name: import_zod8.z.string(),
apiProvider: providerNamesSchema.optional()
});
var DEFAULT_CONSECUTIVE_MISTAKE_LIMIT = 3;
var baseProviderSettingsSchema = import_zod8.z.object({
includeMaxTokens: import_zod8.z.boolean().optional(),
diffEnabled: import_zod8.z.boolean().optional(),
todoListEnabled: import_zod8.z.boolean().optional(),
fuzzyMatchThreshold: import_zod8.z.number().optional(),
modelTemperature: import_zod8.z.number().nullish(),
rateLimitSeconds: import_zod8.z.number().optional(),
consecutiveMistakeLimit: import_zod8.z.number().min(0).optional(),
// Model reasoning.
enableReasoningEffort: import_zod8.z.boolean().optional(),
reasoningEffort: extendedReasoningEffortsSchema.optional(),
modelMaxTokens: import_zod8.z.number().optional(),
modelMaxThinkingTokens: import_zod8.z.number().optional(),
// Model verbosity.
verbosity: verbosityLevelsSchema.optional()
});
var apiModelIdProviderModelSchema = baseProviderSettingsSchema.extend({
apiModelId: import_zod8.z.string().optional()
});
var anthropicSchema = apiModelIdProviderModelSchema.extend({
apiKey: import_zod8.z.string().optional(),
anthropicBaseUrl: import_zod8.z.string().optional(),
anthropicUseAuthToken: import_zod8.z.boolean().optional(),
anthropicBeta1MContext: import_zod8.z.boolean().optional()
// Enable 'context-1m-2025-08-07' beta for 1M context window
});
var claudeCodeSchema = apiModelIdProviderModelSchema.extend({
claudeCodePath: import_zod8.z.string().optional(),
claudeCodeMaxOutputTokens: import_zod8.z.number().int().min(1).max(2e5).optional()
});
var glamaSchema = baseProviderSettingsSchema.extend({
glamaModelId: import_zod8.z.string().optional(),
glamaApiKey: import_zod8.z.string().optional()
});
var openRouterSchema = baseProviderSettingsSchema.extend({
openRouterApiKey: import_zod8.z.string().optional(),
openRouterModelId: import_zod8.z.string().optional(),
openRouterBaseUrl: import_zod8.z.string().optional(),
openRouterSpecificProvider: import_zod8.z.string().optional(),
openRouterUseMiddleOutTransform: import_zod8.z.boolean().optional()
});
var bedrockSchema = apiModelIdProviderModelSchema.extend({
awsAccessKey: import_zod8.z.string().optional(),
awsSecretKey: import_zod8.z.string().optional(),
awsSessionToken: import_zod8.z.string().optional(),
awsRegion: import_zod8.z.string().optional(),
awsUseCrossRegionInference: import_zod8.z.boolean().optional(),
awsUsePromptCache: import_zod8.z.boolean().optional(),
awsProfile: import_zod8.z.string().optional(),
awsUseProfile: import_zod8.z.boolean().optional(),
awsApiKey: import_zod8.z.string().optional(),
awsUseApiKey: import_zod8.z.boolean().optional(),
awsCustomArn: import_zod8.z.string().optional(),
awsModelContextWindow: import_zod8.z.number().optional(),
awsBedrockEndpointEnabled: import_zod8.z.boolean().optional(),
awsBedrockEndpoint: import_zod8.z.string().optional(),
awsBedrock1MContext: import_zod8.z.boolean().optional()
// Enable 'context-1m-2025-08-07' beta for 1M context window
});
var vertexSchema = apiModelIdProviderModelSchema.extend({
vertexKeyFile: import_zod8.z.string().optional(),
vertexJsonCredentials: import_zod8.z.string().optional(),
vertexProjectId: import_zod8.z.string().optional(),
vertexRegion: import_zod8.z.string().optional()
});
var openAiSchema = baseProviderSettingsSchema.extend({
openAiBaseUrl: import_zod8.z.string().optional(),
openAiApiKey: import_zod8.z.string().optional(),
openAiLegacyFormat: import_zod8.z.boolean().optional(),
openAiR1FormatEnabled: import_zod8.z.boolean().optional(),
openAiModelId: import_zod8.z.string().optional(),
openAiCustomModelInfo: modelInfoSchema.nullish(),
openAiUseAzure: import_zod8.z.boolean().optional(),
azureApiVersion: import_zod8.z.string().optional(),
openAiStreamingEnabled: import_zod8.z.boolean().optional(),
openAiHostHeader: import_zod8.z.string().optional(),
// Keep temporarily for backward compatibility during migration.
openAiHeaders: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional()
});
var ollamaSchema = baseProviderSettingsSchema.extend({
ollamaModelId: import_zod8.z.string().optional(),
ollamaBaseUrl: import_zod8.z.string().optional()
});
var vsCodeLmSchema = baseProviderSettingsSchema.extend({
vsCodeLmModelSelector: import_zod8.z.object({
vendor: import_zod8.z.string().optional(),
family: import_zod8.z.string().optional(),
version: import_zod8.z.string().optional(),
id: import_zod8.z.string().optional()
}).optional()
});
var lmStudioSchema = baseProviderSettingsSchema.extend({
lmStudioModelId: import_zod8.z.string().optional(),
lmStudioBaseUrl: import_zod8.z.string().optional(),
lmStudioDraftModelId: import_zod8.z.string().optional(),
lmStudioSpeculativeDecodingEnabled: import_zod8.z.boolean().optional()
});
var geminiSchema = apiModelIdProviderModelSchema.extend({
geminiApiKey: import_zod8.z.string().optional(),
googleGeminiBaseUrl: import_zod8.z.string().optional(),
enableUrlContext: import_zod8.z.boolean().optional(),
enableGrounding: import_zod8.z.boolean().optional()
});
var geminiCliSchema = apiModelIdProviderModelSchema.extend({
geminiCliOAuthPath: import_zod8.z.string().optional(),
geminiCliProjectId: import_zod8.z.string().optional()
});
var openAiNativeSchema = apiModelIdProviderModelSchema.extend({
openAiNativeApiKey: import_zod8.z.string().optional(),
openAiNativeBaseUrl: import_zod8.z.string().optional()
});
var mistralSchema = apiModelIdProviderModelSchema.extend({
mistralApiKey: import_zod8.z.string().optional(),
mistralCodestralUrl: import_zod8.z.string().optional()
});
var deepSeekSchema = apiModelIdProviderModelSchema.extend({
deepSeekBaseUrl: import_zod8.z.string().optional(),
deepSeekApiKey: import_zod8.z.string().optional()
});
var doubaoSchema = apiModelIdProviderModelSchema.extend({
doubaoBaseUrl: import_zod8.z.string().optional(),
doubaoApiKey: import_zod8.z.string().optional()
});
var moonshotSchema = apiModelIdProviderModelSchema.extend({
moonshotBaseUrl: import_zod8.z.union([import_zod8.z.literal("https://api.moonshot.ai/v1"), import_zod8.z.literal("https://api.moonshot.cn/v1")]).optional(),
moonshotApiKey: import_zod8.z.string().optional()
});
var unboundSchema = baseProviderSettingsSchema.extend({
unboundApiKey: import_zod8.z.string().optional(),
unboundModelId: import_zod8.z.string().optional()
});
var requestySchema = baseProviderSettingsSchema.extend({
requestyBaseUrl: import_zod8.z.string().optional(),
requestyApiKey: import_zod8.z.string().optional(),
requestyModelId: import_zod8.z.string().optional()
});
var humanRelaySchema = baseProviderSettingsSchema;
var fakeAiSchema = baseProviderSettingsSchema.extend({
fakeAi: import_zod8.z.unknown().optional()
});
var xaiSchema = apiModelIdProviderModelSchema.extend({
xaiApiKey: import_zod8.z.string().optional()
});
var groqSchema = apiModelIdProviderModelSchema.extend({
groqApiKey: import_zod8.z.string().optional()
});
var huggingFaceSchema = baseProviderSettingsSchema.extend({
huggingFaceApiKey: import_zod8.z.string().optional(),
huggingFaceModelId: import_zod8.z.string().optional(),
huggingFaceInferenceProvider: import_zod8.z.string().optional()
});
var chutesSchema = apiModelIdProviderModelSchema.extend({
chutesApiKey: import_zod8.z.string().optional()
});
var litellmSchema = baseProviderSettingsSchema.extend({
litellmBaseUrl: import_zod8.z.string().optional(),
litellmApiKey: import_zod8.z.string().optional(),
litellmModelId: import_zod8.z.string().optional(),
litellmUsePromptCache: import_zod8.z.boolean().optional()
});
var cerebrasSchema = apiModelIdProviderModelSchema.extend({
cerebrasApiKey: import_zod8.z.string().optional()
});
var sambaNovaSchema = apiModelIdProviderModelSchema.extend({
sambaNovaApiKey: import_zod8.z.string().optional()
});
var zaiSchema = apiModelIdProviderModelSchema.extend({
zaiApiKey: import_zod8.z.string().optional(),
zaiApiLine: import_zod8.z.union([import_zod8.z.literal("china"), import_zod8.z.literal("international")]).optional()
});
var fireworksSchema = apiModelIdProviderModelSchema.extend({
fireworksApiKey: import_zod8.z.string().optional()
});
var ioIntelligenceSchema = apiModelIdProviderModelSchema.extend({
ioIntelligenceModelId: import_zod8.z.string().optional(),
ioIntelligenceApiKey: import_zod8.z.string().optional()
});
var defaultSchema = import_zod8.z.object({
apiProvider: import_zod8.z.undefined()
});
var providerSettingsSchemaDiscriminated = import_zod8.z.discriminatedUnion("apiProvider", [
anthropicSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("anthropic") })),
claudeCodeSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("claude-code") })),
glamaSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("glama") })),
openRouterSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("openrouter") })),
bedrockSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("bedrock") })),
vertexSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("vertex") })),
openAiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("openai") })),
ollamaSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("ollama") })),
vsCodeLmSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("vscode-lm") })),
lmStudioSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("lmstudio") })),
geminiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("gemini") })),
geminiCliSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("gemini-cli") })),
openAiNativeSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("openai-native") })),
mistralSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("mistral") })),
deepSeekSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("deepseek") })),
doubaoSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("doubao") })),
moonshotSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("moonshot") })),
unboundSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("unbound") })),
requestySchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("requesty") })),
humanRelaySchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("human-relay") })),
fakeAiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("fake-ai") })),
xaiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("xai") })),
groqSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("groq") })),
huggingFaceSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("huggingface") })),
chutesSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("chutes") })),
litellmSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("litellm") })),
cerebrasSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("cerebras") })),
sambaNovaSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("sambanova") })),
zaiSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("zai") })),
fireworksSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("fireworks") })),
ioIntelligenceSchema.merge(import_zod8.z.object({ apiProvider: import_zod8.z.literal("io-intelligence") })),
defaultSchema
]);
var providerSettingsSchema = import_zod8.z.object({
apiProvider: providerNamesSchema.optional(),
...anthropicSchema.shape,
...claudeCodeSchema.shape,
...glamaSchema.shape,
...openRouterSchema.shape,
...bedrockSchema.shape,
...vertexSchema.shape,
...openAiSchema.shape,
...ollamaSchema.shape,
...vsCodeLmSchema.shape,
...lmStudioSchema.shape,
...geminiSchema.shape,
...geminiCliSchema.shape,
...openAiNativeSchema.shape,
...mistralSchema.shape,
...deepSeekSchema.shape,
...doubaoSchema.shape,
...moonshotSchema.shape,
...unboundSchema.shape,
...requestySchema.shape,
...humanRelaySchema.shape,
...fakeAiSchema.shape,
...xaiSchema.shape,
...groqSchema.shape,
...huggingFaceSchema.shape,
...chutesSchema.shape,
...litellmSchema.shape,
...cerebrasSchema.shape,
...sambaNovaSchema.shape,
...zaiSchema.shape,
...fireworksSchema.shape,
...ioIntelligenceSchema.shape,
...codebaseIndexProviderSchema.shape
});
var providerSettingsWithIdSchema = providerSettingsSchema.extend({ id: import_zod8.z.string().optional() });
var discriminatedProviderSettingsWithIdSchema = providerSettingsSchemaDiscriminated.and(
import_zod8.z.object({ id: import_zod8.z.string().optional() })
);
var PROVIDER_SETTINGS_KEYS = providerSettingsSchema.keyof().options;
var MODEL_ID_KEYS = [
"apiModelId",
"glamaModelId",
"openRouterModelId",
"openAiModelId",
"ollamaModelId",
"lmStudioModelId",
"lmStudioDraftModelId",
"unboundModelId",
"requestyModelId",
"litellmModelId",
"huggingFaceModelId",
"ioIntelligenceModelId"
];
var getModelId = (settings) => {
const modelIdKey = MODEL_ID_KEYS.find((key) => settings[key]);
return modelIdKey ? settings[modelIdKey] : void 0;
};
var ANTHROPIC_STYLE_PROVIDERS = ["anthropic", "claude-code", "bedrock"];
var getApiProtocol = (provider, modelId) => {
if (provider && ANTHROPIC_STYLE_PROVIDERS.includes(provider)) {
return "anthropic";
}
if (provider && provider === "vertex" && modelId && modelId.toLowerCase().includes("claude")) {
return "anthropic";
}
return "openai";
};
// src/history.ts
var import_zod9 = require("zod");
var historyItemSchema = import_zod9.z.object({
id: import_zod9.z.string(),
number: import_zod9.z.number(),
ts: import_zod9.z.number(),
task: import_zod9.z.string(),
tokensIn: import_zod9.z.number(),
tokensOut: import_zod9.z.number(),
cacheWrites: import_zod9.z.number().optional(),
cacheReads: import_zod9.z.number().optional(),
totalCost: import_zod9.z.number(),
size: import_zod9.z.number().optional(),
workspace: import_zod9.z.string().optional(),
mode: import_zod9.z.string().optional()
});
// src/telemetry.ts
var import_zod10 = require("zod");
var telemetrySettings = ["unset", "enabled", "disabled"];
var telemetrySettingsSchema = import_zod10.z.enum(telemetrySettings);
var TelemetryEventName = /* @__PURE__ */ ((TelemetryEventName2) => {
TelemetryEventName2["TASK_CREATED"] = "Task Created";
TelemetryEventName2["TASK_RESTARTED"] = "Task Reopened";
TelemetryEventName2["TASK_COMPLETED"] = "Task Completed";
TelemetryEventName2["TASK_MESSAGE"] = "Task Message";
TelemetryEventName2["TASK_CONVERSATION_MESSAGE"] = "Conversation Message";
TelemetryEventName2["LLM_COMPLETION"] = "LLM Completion";
TelemetryEventName2["MODE_SWITCH"] = "Mode Switched";
TelemetryEventName2["MODE_SELECTOR_OPENED"] = "Mode Selector Opened";
TelemetryEventName2["TOOL_USED"] = "Tool Used";
TelemetryEventName2["CHECKPOINT_CREATED"] = "Checkpoint Created";
TelemetryEventName2["CHECKPOINT_RESTORED"] = "Checkpoint Restored";
TelemetryEventName2["CHECKPOINT_DIFFED"] = "Checkpoint Diffed";
TelemetryEventName2["TAB_SHOWN"] = "Tab Shown";
TelemetryEventName2["MODE_SETTINGS_CHANGED"] = "Mode Setting Changed";
TelemetryEventName2["CUSTOM_MODE_CREATED"] = "Custom Mode Created";
TelemetryEventName2["CONTEXT_CONDENSED"] = "Context Condensed";
TelemetryEventName2["SLIDING_WINDOW_TRUNCATION"] = "Sliding Window Truncation";
TelemetryEventName2["CODE_ACTION_USED"] = "Code Action Used";
TelemetryEventName2["PROMPT_ENHANCED"] = "Prompt Enhanced";
TelemetryEventName2["TITLE_BUTTON_CLICKED"] = "Title Button Clicked";
TelemetryEventName2["AUTHENTICATION_INITIATED"] = "Authentication Initiated";
TelemetryEventName2["MARKETPLACE_ITEM_INSTALLED"] = "Marketplace Item Installed";
TelemetryEventName2["MARKETPLACE_ITEM_REMOVED"] = "Marketplace Item Removed";
TelemetryEventName2["MARKETPLACE_TAB_VIEWED"] = "Marketplace Tab Viewed";
TelemetryEventName2["MARKETPLACE_INSTALL_BUTTON_CLICKED"] = "Marketplace Install Button Clicked";
TelemetryEventName2["SHARE_BUTTON_CLICKED"] = "Share Button Clicked";
TelemetryEventName2["SHARE_ORGANIZATION_CLICKED"] = "Share Organization Clicked";
TelemetryEventName2["SHARE_PUBLIC_CLICKED"] = "Share Public Clicked";
TelemetryEventName2["SHARE_CONNECT_TO_CLOUD_CLICKED"] = "Share Connect To Cloud Clicked";
TelemetryEventName2["ACCOUNT_CONNECT_CLICKED"] = "Account Connect Clicked";
TelemetryEventName2["ACCOUNT_CONNECT_SUCCESS"] = "Account Connect Success";
TelemetryEventName2["ACCOUNT_LOGOUT_CLICKED"] = "Account Logout Clicked";
TelemetryEventName2["ACCOUNT_LOGOUT_SUCCESS"] = "Account Logout Success";
TelemetryEventName2["SCHEMA_VALIDATION_ERROR"] = "Schema Validation Error";
TelemetryEventName2["DIFF_APPLICATION_ERROR"] = "Diff Application Error";
TelemetryEventName2["SHELL_INTEGRATION_ERROR"] = "Shell Integration Error";
TelemetryEventName2["CONSECUTIVE_MISTAKE_ERROR"] = "Consecutive Mistake Error";
TelemetryEventName2["CODE_INDEX_ERROR"] = "Code Index Error";
return TelemetryEventName2;
})(TelemetryEventName || {});
var appPropertiesSchema = import_zod10.z.object({
appName: import_zod10.z.string(),
appVersion: import_zod10.z.string(),
vscodeVersion: import_zod10.z.string(),
platform: import_zod10.z.string(),
editorName: import_zod10.z.string(),
language: import_zod10.z.string(),
mode: import_zod10.z.string(),
cloudIsAuthenticated: import_zod10.z.boolean().optional()
});
var taskPropertiesSchema = import_zod10.z.object({
taskId: import_zod10.z.string().optional(),
apiProvider: import_zod10.z.enum(providerNames).optional(),
modelId: import_zod10.z.string().optional(),
diffStrategy: import_zod10.z.string().optional(),
isSubtask: import_zod10.z.boolean().optional(),
todos: import_zod10.z.object({
total: import_zod10.z.number(),
completed: import_zod10.z.number(),
inProgress: import_zod10.z.number(),
pending: import_zod10.z.number()
}).optional()
});
var gitPropertiesSchema = import_zod10.z.object({
repositoryUrl: import_zod10.z.string().optional(),
repositoryName: import_zod10.z.string().optional(),
defaultBranch: import_zod10.z.string().optional()
});
var telemetryPropertiesSchema = import_zod10.z.object({
...appPropertiesSchema.shape,
...taskPropertiesSchema.shape,
...gitPropertiesSchema.shape
});
var rooCodeTelemetryEventSchema = import_zod10.z.discriminatedUnion("type", [
import_zod10.z.object({
type: import_zod10.z.enum([
"Task Created" /* TASK_CREATED */,
"Task Reopened" /* TASK_RESTARTED */,
"Task Completed" /* TASK_COMPLETED */,
"Conversation Message" /* TASK_CONVERSATION_MESSAGE */,
"Mode Switched" /* MODE_SWITCH */,
"Mode Selector Opened" /* MODE_SELECTOR_OPENED */,
"Tool Used" /* TOOL_USED */,
"Checkpoint Created" /* CHECKPOINT_CREATED */,
"Checkpoint Restored" /* CHECKPOINT_RESTORED */,
"Checkpoint Diffed" /* CHECKPOINT_DIFFED */,
"Code Action Used" /* CODE_ACTION_USED */,
"Prompt Enhanced" /* PROMPT_ENHANCED */,
"Title Button Clicked" /* TITLE_BUTTON_CLICKED */,
"Authentication Initiated" /* AUTHENTICATION_INITIATED */,
"Marketplace Item Installed" /* MARKETPLACE_ITEM_INSTALLED */,
"Marketplace Item Removed" /* MARKETPLACE_ITEM_REMOVED */,
"Marketplace Tab Viewed" /* MARKETPLACE_TAB_VIEWED */,
"Marketplace Install Button Clicked" /* MARKETPLACE_INSTALL_BUTTON_CLICKED */,
"Share Button Clicked" /* SHARE_BUTTON_CLICKED */,
"Share Organization Clicked" /* SHARE_ORGANIZATION_CLICKED */,
"Share Public Clicked" /* SHARE_PUBLIC_CLICKED */,
"Share Connect To Cloud Clicked" /* SHARE_CONNECT_TO_CLOUD_CLICKED */,
"Account Connect Clicked" /* ACCOUNT_CONNECT_CLICKED */,
"Account Connect Success" /* ACCOUNT_CONNECT_SUCCESS */,
"Account Logout Clicked" /* ACCOUNT_LOGOUT_CLICKED */,
"Account Logout Success" /* ACCOUNT_LOGOUT_SUCCESS */,
"Schema Validation Error" /* SCHEMA_VALIDATION_ERROR */,
"Diff Application Error" /* DIFF_APPLICATION_ERROR */,
"Shell Integration Error" /* SHELL_INTEGRATION_ERROR */,
"Consecutive Mistake Error" /* CONSECUTIVE_MISTAKE_ERROR */,
"Code Index Error" /* CODE_INDEX_ERROR */,
"Context Condensed" /* CONTEXT_CONDENSED */,
"Sliding Window Truncation" /* SLIDING_WINDOW_TRUNCATION */,
"Tab Shown" /* TAB_SHOWN */,
"Mode Setting Changed" /* MODE_SETTINGS_CHANGED */,
"Custom Mode Created" /* CUSTOM_MODE_CREATED */
]),
properties: telemetryPropertiesSchema
}),
import_zod10.z.object({
type: import_zod10.z.literal("Task Message" /* TASK_MESSAGE */),
properties: import_zod10.z.