mirror of
https://github.com/QwenLM/qwen-code.git
synced 2025-12-19 09:33:53 +00:00
1314 lines
39 KiB
TypeScript
1314 lines
39 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright 2025 Google LLC
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
// Node built-ins
|
|
import type { EventEmitter } from 'node:events';
|
|
import * as path from 'node:path';
|
|
import process from 'node:process';
|
|
|
|
// External dependencies
|
|
import { ProxyAgent, setGlobalDispatcher } from 'undici';
|
|
|
|
// Types
|
|
import type {
|
|
ContentGenerator,
|
|
ContentGeneratorConfig,
|
|
} from '../core/contentGenerator.js';
|
|
import type { FallbackModelHandler } from '../fallback/types.js';
|
|
import type { MCPOAuthConfig } from '../mcp/oauth-provider.js';
|
|
import type { ShellExecutionConfig } from '../services/shellExecutionService.js';
|
|
import type { AnyToolInvocation } from '../tools/tools.js';
|
|
|
|
// Core
|
|
import { BaseLlmClient } from '../core/baseLlmClient.js';
|
|
import { GeminiClient } from '../core/client.js';
|
|
import {
|
|
AuthType,
|
|
createContentGenerator,
|
|
createContentGeneratorConfig,
|
|
} from '../core/contentGenerator.js';
|
|
import { tokenLimit } from '../core/tokenLimits.js';
|
|
|
|
// Services
|
|
import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
|
|
import {
|
|
type FileSystemService,
|
|
StandardFileSystemService,
|
|
} from '../services/fileSystemService.js';
|
|
import { GitService } from '../services/gitService.js';
|
|
|
|
// Tools
|
|
import { EditTool } from '../tools/edit.js';
|
|
import { ExitPlanModeTool } from '../tools/exitPlanMode.js';
|
|
import { GlobTool } from '../tools/glob.js';
|
|
import { GrepTool } from '../tools/grep.js';
|
|
import { LSTool } from '../tools/ls.js';
|
|
import { MemoryTool, setGeminiMdFilename } from '../tools/memoryTool.js';
|
|
import { ReadFileTool } from '../tools/read-file.js';
|
|
import { ReadManyFilesTool } from '../tools/read-many-files.js';
|
|
import { canUseRipgrep } from '../utils/ripgrepUtils.js';
|
|
import { RipGrepTool } from '../tools/ripGrep.js';
|
|
import { ShellTool } from '../tools/shell.js';
|
|
import { SmartEditTool } from '../tools/smart-edit.js';
|
|
import { TaskTool } from '../tools/task.js';
|
|
import { TodoWriteTool } from '../tools/todoWrite.js';
|
|
import { ToolRegistry } from '../tools/tool-registry.js';
|
|
import { WebFetchTool } from '../tools/web-fetch.js';
|
|
import { WebSearchTool } from '../tools/web-search/index.js';
|
|
import { WriteFileTool } from '../tools/write-file.js';
|
|
|
|
// Other modules
|
|
import { ideContextStore } from '../ide/ideContext.js';
|
|
import { InputFormat, OutputFormat } from '../output/types.js';
|
|
import { PromptRegistry } from '../prompts/prompt-registry.js';
|
|
import { SubagentManager } from '../subagents/subagent-manager.js';
|
|
import {
|
|
DEFAULT_OTLP_ENDPOINT,
|
|
DEFAULT_TELEMETRY_TARGET,
|
|
initializeTelemetry,
|
|
logStartSession,
|
|
logRipgrepFallback,
|
|
RipgrepFallbackEvent,
|
|
StartSessionEvent,
|
|
type TelemetryTarget,
|
|
uiTelemetryService,
|
|
} from '../telemetry/index.js';
|
|
|
|
// Utils
|
|
import { shouldAttemptBrowserLaunch } from '../utils/browser.js';
|
|
import { FileExclusions } from '../utils/ignorePatterns.js';
|
|
import { WorkspaceContext } from '../utils/workspaceContext.js';
|
|
import { isToolEnabled, type ToolName } from '../utils/tool-utils.js';
|
|
import { getErrorMessage } from '../utils/errors.js';
|
|
|
|
// Local config modules
|
|
import type { FileFilteringOptions } from './constants.js';
|
|
import {
|
|
DEFAULT_FILE_FILTERING_OPTIONS,
|
|
DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
|
|
} from './constants.js';
|
|
import { DEFAULT_QWEN_EMBEDDING_MODEL, DEFAULT_QWEN_MODEL } from './models.js';
|
|
import { Storage } from './storage.js';
|
|
import { DEFAULT_DASHSCOPE_BASE_URL } from '../core/openaiContentGenerator/constants.js';
|
|
import { ChatRecordingService } from '../services/chatRecordingService.js';
|
|
import {
|
|
SessionService,
|
|
type ResumedSessionData,
|
|
} from '../services/sessionService.js';
|
|
import { randomUUID } from 'node:crypto';
|
|
|
|
// Re-export types
|
|
export type { AnyToolInvocation, FileFilteringOptions, MCPOAuthConfig };
|
|
export {
|
|
DEFAULT_FILE_FILTERING_OPTIONS,
|
|
DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
|
|
};
|
|
|
|
export enum ApprovalMode {
|
|
PLAN = 'plan',
|
|
DEFAULT = 'default',
|
|
AUTO_EDIT = 'auto-edit',
|
|
YOLO = 'yolo',
|
|
}
|
|
|
|
export const APPROVAL_MODES = Object.values(ApprovalMode);
|
|
|
|
/**
|
|
* Information about an approval mode including display name and description.
|
|
*/
|
|
export interface ApprovalModeInfo {
|
|
id: ApprovalMode;
|
|
name: string;
|
|
description: string;
|
|
}
|
|
|
|
/**
|
|
* Detailed information about each approval mode.
|
|
* Used for UI display and protocol responses.
|
|
*/
|
|
export const APPROVAL_MODE_INFO: Record<ApprovalMode, ApprovalModeInfo> = {
|
|
[ApprovalMode.PLAN]: {
|
|
id: ApprovalMode.PLAN,
|
|
name: 'Plan',
|
|
description: 'Analyze only, do not modify files or execute commands',
|
|
},
|
|
[ApprovalMode.DEFAULT]: {
|
|
id: ApprovalMode.DEFAULT,
|
|
name: 'Default',
|
|
description: 'Require approval for file edits or shell commands',
|
|
},
|
|
[ApprovalMode.AUTO_EDIT]: {
|
|
id: ApprovalMode.AUTO_EDIT,
|
|
name: 'Auto Edit',
|
|
description: 'Automatically approve file edits',
|
|
},
|
|
[ApprovalMode.YOLO]: {
|
|
id: ApprovalMode.YOLO,
|
|
name: 'YOLO',
|
|
description: 'Automatically approve all tools',
|
|
},
|
|
};
|
|
|
|
export interface AccessibilitySettings {
|
|
disableLoadingPhrases?: boolean;
|
|
screenReader?: boolean;
|
|
}
|
|
|
|
export interface BugCommandSettings {
|
|
urlTemplate: string;
|
|
}
|
|
|
|
export interface ChatCompressionSettings {
|
|
contextPercentageThreshold?: number;
|
|
}
|
|
|
|
export interface SummarizeToolOutputSettings {
|
|
tokenBudget?: number;
|
|
}
|
|
|
|
export interface TelemetrySettings {
|
|
enabled?: boolean;
|
|
target?: TelemetryTarget;
|
|
otlpEndpoint?: string;
|
|
otlpProtocol?: 'grpc' | 'http';
|
|
logPrompts?: boolean;
|
|
outfile?: string;
|
|
useCollector?: boolean;
|
|
}
|
|
|
|
export interface OutputSettings {
|
|
format?: OutputFormat;
|
|
}
|
|
|
|
export interface GitCoAuthorSettings {
|
|
enabled?: boolean;
|
|
name?: string;
|
|
email?: string;
|
|
}
|
|
|
|
export interface GeminiCLIExtension {
|
|
name: string;
|
|
version: string;
|
|
isActive: boolean;
|
|
path: string;
|
|
installMetadata?: ExtensionInstallMetadata;
|
|
}
|
|
|
|
export interface ExtensionInstallMetadata {
|
|
source: string;
|
|
type: 'git' | 'local' | 'link' | 'github-release';
|
|
releaseTag?: string; // Only present for github-release installs.
|
|
ref?: string;
|
|
autoUpdate?: boolean;
|
|
}
|
|
|
|
export const DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD = 25_000;
|
|
export const DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES = 1000;
|
|
|
|
export class MCPServerConfig {
|
|
constructor(
|
|
// For stdio transport
|
|
readonly command?: string,
|
|
readonly args?: string[],
|
|
readonly env?: Record<string, string>,
|
|
readonly cwd?: string,
|
|
// For sse transport
|
|
readonly url?: string,
|
|
// For streamable http transport
|
|
readonly httpUrl?: string,
|
|
readonly headers?: Record<string, string>,
|
|
// For websocket transport
|
|
readonly tcp?: string,
|
|
// Common
|
|
readonly timeout?: number,
|
|
readonly trust?: boolean,
|
|
// Metadata
|
|
readonly description?: string,
|
|
readonly includeTools?: string[],
|
|
readonly excludeTools?: string[],
|
|
readonly extensionName?: string,
|
|
// OAuth configuration
|
|
readonly oauth?: MCPOAuthConfig,
|
|
readonly authProviderType?: AuthProviderType,
|
|
// Service Account Configuration
|
|
/* targetAudience format: CLIENT_ID.apps.googleusercontent.com */
|
|
readonly targetAudience?: string,
|
|
/* targetServiceAccount format: <service-account-name>@<project-num>.iam.gserviceaccount.com */
|
|
readonly targetServiceAccount?: string,
|
|
) {}
|
|
}
|
|
|
|
export enum AuthProviderType {
|
|
DYNAMIC_DISCOVERY = 'dynamic_discovery',
|
|
GOOGLE_CREDENTIALS = 'google_credentials',
|
|
SERVICE_ACCOUNT_IMPERSONATION = 'service_account_impersonation',
|
|
}
|
|
|
|
export interface SandboxConfig {
|
|
command: 'docker' | 'podman' | 'sandbox-exec';
|
|
image: string;
|
|
}
|
|
|
|
export interface ConfigParameters {
|
|
sessionId?: string;
|
|
sessionData?: ResumedSessionData;
|
|
embeddingModel?: string;
|
|
sandbox?: SandboxConfig;
|
|
targetDir: string;
|
|
debugMode: boolean;
|
|
includePartialMessages?: boolean;
|
|
question?: string;
|
|
fullContext?: boolean;
|
|
coreTools?: string[];
|
|
allowedTools?: string[];
|
|
excludeTools?: string[];
|
|
toolDiscoveryCommand?: string;
|
|
toolCallCommand?: string;
|
|
mcpServerCommand?: string;
|
|
mcpServers?: Record<string, MCPServerConfig>;
|
|
userMemory?: string;
|
|
geminiMdFileCount?: number;
|
|
approvalMode?: ApprovalMode;
|
|
showMemoryUsage?: boolean;
|
|
contextFileName?: string | string[];
|
|
accessibility?: AccessibilitySettings;
|
|
telemetry?: TelemetrySettings;
|
|
gitCoAuthor?: GitCoAuthorSettings;
|
|
usageStatisticsEnabled?: boolean;
|
|
fileFiltering?: {
|
|
respectGitIgnore?: boolean;
|
|
respectQwenIgnore?: boolean;
|
|
enableRecursiveFileSearch?: boolean;
|
|
disableFuzzySearch?: boolean;
|
|
};
|
|
checkpointing?: boolean;
|
|
proxy?: string;
|
|
cwd: string;
|
|
fileDiscoveryService?: FileDiscoveryService;
|
|
includeDirectories?: string[];
|
|
bugCommand?: BugCommandSettings;
|
|
model?: string;
|
|
extensionContextFilePaths?: string[];
|
|
maxSessionTurns?: number;
|
|
sessionTokenLimit?: number;
|
|
experimentalZedIntegration?: boolean;
|
|
listExtensions?: boolean;
|
|
extensions?: GeminiCLIExtension[];
|
|
blockedMcpServers?: Array<{ name: string; extensionName: string }>;
|
|
noBrowser?: boolean;
|
|
summarizeToolOutput?: Record<string, SummarizeToolOutputSettings>;
|
|
folderTrustFeature?: boolean;
|
|
folderTrust?: boolean;
|
|
ideMode?: boolean;
|
|
authType?: AuthType;
|
|
generationConfig?: Partial<ContentGeneratorConfig>;
|
|
cliVersion?: string;
|
|
loadMemoryFromIncludeDirectories?: boolean;
|
|
// Web search providers
|
|
webSearch?: {
|
|
provider: Array<{
|
|
type: 'tavily' | 'google' | 'dashscope';
|
|
apiKey?: string;
|
|
searchEngineId?: string;
|
|
}>;
|
|
default: string;
|
|
};
|
|
chatCompression?: ChatCompressionSettings;
|
|
interactive?: boolean;
|
|
trustedFolder?: boolean;
|
|
useRipgrep?: boolean;
|
|
useBuiltinRipgrep?: boolean;
|
|
shouldUseNodePtyShell?: boolean;
|
|
skipNextSpeakerCheck?: boolean;
|
|
shellExecutionConfig?: ShellExecutionConfig;
|
|
extensionManagement?: boolean;
|
|
skipLoopDetection?: boolean;
|
|
vlmSwitchMode?: string;
|
|
truncateToolOutputThreshold?: number;
|
|
truncateToolOutputLines?: number;
|
|
enableToolOutputTruncation?: boolean;
|
|
eventEmitter?: EventEmitter;
|
|
useSmartEdit?: boolean;
|
|
output?: OutputSettings;
|
|
skipStartupContext?: boolean;
|
|
inputFormat?: InputFormat;
|
|
outputFormat?: OutputFormat;
|
|
}
|
|
|
|
function normalizeConfigOutputFormat(
|
|
format: OutputFormat | undefined,
|
|
): OutputFormat | undefined {
|
|
if (!format) {
|
|
return undefined;
|
|
}
|
|
switch (format) {
|
|
case 'stream-json':
|
|
return OutputFormat.STREAM_JSON;
|
|
case 'json':
|
|
case OutputFormat.JSON:
|
|
return OutputFormat.JSON;
|
|
case 'text':
|
|
case OutputFormat.TEXT:
|
|
default:
|
|
return OutputFormat.TEXT;
|
|
}
|
|
}
|
|
|
|
export class Config {
|
|
private sessionId: string;
|
|
private sessionData?: ResumedSessionData;
|
|
private toolRegistry!: ToolRegistry;
|
|
private promptRegistry!: PromptRegistry;
|
|
private subagentManager!: SubagentManager;
|
|
private fileSystemService: FileSystemService;
|
|
private contentGeneratorConfig!: ContentGeneratorConfig;
|
|
private contentGenerator!: ContentGenerator;
|
|
private _generationConfig: Partial<ContentGeneratorConfig>;
|
|
private readonly embeddingModel: string;
|
|
private readonly sandbox: SandboxConfig | undefined;
|
|
private readonly targetDir: string;
|
|
private workspaceContext: WorkspaceContext;
|
|
private readonly debugMode: boolean;
|
|
private readonly inputFormat: InputFormat;
|
|
private readonly outputFormat: OutputFormat;
|
|
private readonly includePartialMessages: boolean;
|
|
private readonly question: string | undefined;
|
|
private readonly fullContext: boolean;
|
|
private readonly coreTools: string[] | undefined;
|
|
private readonly allowedTools: string[] | undefined;
|
|
private readonly excludeTools: string[] | undefined;
|
|
private readonly toolDiscoveryCommand: string | undefined;
|
|
private readonly toolCallCommand: string | undefined;
|
|
private readonly mcpServerCommand: string | undefined;
|
|
private readonly mcpServers: Record<string, MCPServerConfig> | undefined;
|
|
private userMemory: string;
|
|
private geminiMdFileCount: number;
|
|
private approvalMode: ApprovalMode;
|
|
private readonly showMemoryUsage: boolean;
|
|
private readonly accessibility: AccessibilitySettings;
|
|
private readonly telemetrySettings: TelemetrySettings;
|
|
private readonly gitCoAuthor: GitCoAuthorSettings;
|
|
private readonly usageStatisticsEnabled: boolean;
|
|
private geminiClient!: GeminiClient;
|
|
private baseLlmClient!: BaseLlmClient;
|
|
private readonly fileFiltering: {
|
|
respectGitIgnore: boolean;
|
|
respectQwenIgnore: boolean;
|
|
enableRecursiveFileSearch: boolean;
|
|
disableFuzzySearch: boolean;
|
|
};
|
|
private fileDiscoveryService: FileDiscoveryService | null = null;
|
|
private gitService: GitService | undefined = undefined;
|
|
private sessionService: SessionService | undefined = undefined;
|
|
private chatRecordingService: ChatRecordingService | undefined = undefined;
|
|
private readonly checkpointing: boolean;
|
|
private readonly proxy: string | undefined;
|
|
private readonly cwd: string;
|
|
private readonly bugCommand: BugCommandSettings | undefined;
|
|
private readonly extensionContextFilePaths: string[];
|
|
private readonly noBrowser: boolean;
|
|
private readonly folderTrustFeature: boolean;
|
|
private readonly folderTrust: boolean;
|
|
private ideMode: boolean;
|
|
|
|
private inFallbackMode = false;
|
|
private readonly maxSessionTurns: number;
|
|
private readonly sessionTokenLimit: number;
|
|
private readonly listExtensions: boolean;
|
|
private readonly _extensions: GeminiCLIExtension[];
|
|
private readonly _blockedMcpServers: Array<{
|
|
name: string;
|
|
extensionName: string;
|
|
}>;
|
|
fallbackModelHandler?: FallbackModelHandler;
|
|
private quotaErrorOccurred: boolean = false;
|
|
private readonly summarizeToolOutput:
|
|
| Record<string, SummarizeToolOutputSettings>
|
|
| undefined;
|
|
private readonly cliVersion?: string;
|
|
private readonly experimentalZedIntegration: boolean = false;
|
|
private readonly loadMemoryFromIncludeDirectories: boolean = false;
|
|
private readonly webSearch?: {
|
|
provider: Array<{
|
|
type: 'tavily' | 'google' | 'dashscope';
|
|
apiKey?: string;
|
|
searchEngineId?: string;
|
|
}>;
|
|
default: string;
|
|
};
|
|
private readonly chatCompression: ChatCompressionSettings | undefined;
|
|
private readonly interactive: boolean;
|
|
private readonly trustedFolder: boolean | undefined;
|
|
private readonly useRipgrep: boolean;
|
|
private readonly useBuiltinRipgrep: boolean;
|
|
private readonly shouldUseNodePtyShell: boolean;
|
|
private readonly skipNextSpeakerCheck: boolean;
|
|
private shellExecutionConfig: ShellExecutionConfig;
|
|
private readonly extensionManagement: boolean = true;
|
|
private readonly skipLoopDetection: boolean;
|
|
private readonly skipStartupContext: boolean;
|
|
private readonly vlmSwitchMode: string | undefined;
|
|
private initialized: boolean = false;
|
|
readonly storage: Storage;
|
|
private readonly fileExclusions: FileExclusions;
|
|
private readonly truncateToolOutputThreshold: number;
|
|
private readonly truncateToolOutputLines: number;
|
|
private readonly enableToolOutputTruncation: boolean;
|
|
private readonly eventEmitter?: EventEmitter;
|
|
private readonly useSmartEdit: boolean;
|
|
|
|
constructor(params: ConfigParameters) {
|
|
this.sessionId = params.sessionId ?? randomUUID();
|
|
this.sessionData = params.sessionData;
|
|
this.embeddingModel = params.embeddingModel ?? DEFAULT_QWEN_EMBEDDING_MODEL;
|
|
this.fileSystemService = new StandardFileSystemService();
|
|
this.sandbox = params.sandbox;
|
|
this.targetDir = path.resolve(params.targetDir);
|
|
this.workspaceContext = new WorkspaceContext(
|
|
this.targetDir,
|
|
params.includeDirectories ?? [],
|
|
);
|
|
this.debugMode = params.debugMode;
|
|
this.inputFormat = params.inputFormat ?? InputFormat.TEXT;
|
|
const normalizedOutputFormat = normalizeConfigOutputFormat(
|
|
params.outputFormat ?? params.output?.format,
|
|
);
|
|
this.outputFormat = normalizedOutputFormat ?? OutputFormat.TEXT;
|
|
this.includePartialMessages = params.includePartialMessages ?? false;
|
|
this.question = params.question;
|
|
this.fullContext = params.fullContext ?? false;
|
|
this.coreTools = params.coreTools;
|
|
this.allowedTools = params.allowedTools;
|
|
this.excludeTools = params.excludeTools;
|
|
this.toolDiscoveryCommand = params.toolDiscoveryCommand;
|
|
this.toolCallCommand = params.toolCallCommand;
|
|
this.mcpServerCommand = params.mcpServerCommand;
|
|
this.mcpServers = params.mcpServers;
|
|
this.userMemory = params.userMemory ?? '';
|
|
this.geminiMdFileCount = params.geminiMdFileCount ?? 0;
|
|
this.approvalMode = params.approvalMode ?? ApprovalMode.DEFAULT;
|
|
this.showMemoryUsage = params.showMemoryUsage ?? false;
|
|
this.accessibility = params.accessibility ?? {};
|
|
this.telemetrySettings = {
|
|
enabled: params.telemetry?.enabled ?? false,
|
|
target: params.telemetry?.target ?? DEFAULT_TELEMETRY_TARGET,
|
|
otlpEndpoint: params.telemetry?.otlpEndpoint ?? DEFAULT_OTLP_ENDPOINT,
|
|
otlpProtocol: params.telemetry?.otlpProtocol,
|
|
logPrompts: params.telemetry?.logPrompts ?? true,
|
|
outfile: params.telemetry?.outfile,
|
|
useCollector: params.telemetry?.useCollector,
|
|
};
|
|
this.gitCoAuthor = {
|
|
enabled: params.gitCoAuthor?.enabled ?? true,
|
|
name: params.gitCoAuthor?.name ?? 'Qwen-Coder',
|
|
email: params.gitCoAuthor?.email ?? 'qwen-coder@alibabacloud.com',
|
|
};
|
|
this.usageStatisticsEnabled = params.usageStatisticsEnabled ?? true;
|
|
|
|
this.fileFiltering = {
|
|
respectGitIgnore: params.fileFiltering?.respectGitIgnore ?? true,
|
|
respectQwenIgnore: params.fileFiltering?.respectQwenIgnore ?? true,
|
|
enableRecursiveFileSearch:
|
|
params.fileFiltering?.enableRecursiveFileSearch ?? true,
|
|
disableFuzzySearch: params.fileFiltering?.disableFuzzySearch ?? false,
|
|
};
|
|
this.checkpointing = params.checkpointing ?? false;
|
|
this.proxy = params.proxy;
|
|
this.cwd = params.cwd ?? process.cwd();
|
|
this.fileDiscoveryService = params.fileDiscoveryService ?? null;
|
|
this.bugCommand = params.bugCommand;
|
|
this.extensionContextFilePaths = params.extensionContextFilePaths ?? [];
|
|
this.maxSessionTurns = params.maxSessionTurns ?? -1;
|
|
this.sessionTokenLimit = params.sessionTokenLimit ?? -1;
|
|
this.experimentalZedIntegration =
|
|
params.experimentalZedIntegration ?? false;
|
|
this.listExtensions = params.listExtensions ?? false;
|
|
this._extensions = params.extensions ?? [];
|
|
this._blockedMcpServers = params.blockedMcpServers ?? [];
|
|
this.noBrowser = params.noBrowser ?? false;
|
|
this.summarizeToolOutput = params.summarizeToolOutput;
|
|
this.folderTrustFeature = params.folderTrustFeature ?? false;
|
|
this.folderTrust = params.folderTrust ?? false;
|
|
this.ideMode = params.ideMode ?? false;
|
|
this._generationConfig = {
|
|
model: params.model,
|
|
...(params.generationConfig || {}),
|
|
baseUrl: params.generationConfig?.baseUrl || DEFAULT_DASHSCOPE_BASE_URL,
|
|
};
|
|
this.contentGeneratorConfig = this
|
|
._generationConfig as ContentGeneratorConfig;
|
|
this.cliVersion = params.cliVersion;
|
|
|
|
this.loadMemoryFromIncludeDirectories =
|
|
params.loadMemoryFromIncludeDirectories ?? false;
|
|
this.chatCompression = params.chatCompression;
|
|
this.interactive = params.interactive ?? false;
|
|
this.trustedFolder = params.trustedFolder;
|
|
this.skipLoopDetection = params.skipLoopDetection ?? false;
|
|
this.skipStartupContext = params.skipStartupContext ?? false;
|
|
|
|
// Web search
|
|
this.webSearch = params.webSearch;
|
|
this.useRipgrep = params.useRipgrep ?? true;
|
|
this.useBuiltinRipgrep = params.useBuiltinRipgrep ?? true;
|
|
this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? false;
|
|
this.skipNextSpeakerCheck = params.skipNextSpeakerCheck ?? true;
|
|
this.shellExecutionConfig = {
|
|
terminalWidth: params.shellExecutionConfig?.terminalWidth ?? 80,
|
|
terminalHeight: params.shellExecutionConfig?.terminalHeight ?? 24,
|
|
showColor: params.shellExecutionConfig?.showColor ?? false,
|
|
pager: params.shellExecutionConfig?.pager ?? 'cat',
|
|
};
|
|
this.truncateToolOutputThreshold =
|
|
params.truncateToolOutputThreshold ??
|
|
DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD;
|
|
this.truncateToolOutputLines =
|
|
params.truncateToolOutputLines ?? DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES;
|
|
this.enableToolOutputTruncation = params.enableToolOutputTruncation ?? true;
|
|
this.useSmartEdit = params.useSmartEdit ?? false;
|
|
this.extensionManagement = params.extensionManagement ?? true;
|
|
this.storage = new Storage(this.targetDir);
|
|
this.vlmSwitchMode = params.vlmSwitchMode;
|
|
this.inputFormat = params.inputFormat ?? InputFormat.TEXT;
|
|
this.fileExclusions = new FileExclusions(this);
|
|
this.eventEmitter = params.eventEmitter;
|
|
if (params.contextFileName) {
|
|
setGeminiMdFilename(params.contextFileName);
|
|
}
|
|
|
|
if (this.telemetrySettings.enabled) {
|
|
initializeTelemetry(this);
|
|
}
|
|
|
|
if (this.getProxy()) {
|
|
setGlobalDispatcher(new ProxyAgent(this.getProxy() as string));
|
|
}
|
|
this.geminiClient = new GeminiClient(this);
|
|
this.chatRecordingService = new ChatRecordingService(this);
|
|
}
|
|
|
|
/**
|
|
* Must only be called once, throws if called again.
|
|
*/
|
|
async initialize(): Promise<void> {
|
|
if (this.initialized) {
|
|
throw Error('Config was already initialized');
|
|
}
|
|
this.initialized = true;
|
|
|
|
// Initialize centralized FileDiscoveryService
|
|
this.getFileService();
|
|
if (this.getCheckpointingEnabled()) {
|
|
await this.getGitService();
|
|
}
|
|
this.promptRegistry = new PromptRegistry();
|
|
this.subagentManager = new SubagentManager(this);
|
|
this.toolRegistry = await this.createToolRegistry();
|
|
|
|
await this.geminiClient.initialize();
|
|
|
|
logStartSession(this, new StartSessionEvent(this));
|
|
}
|
|
|
|
getContentGenerator(): ContentGenerator {
|
|
return this.contentGenerator;
|
|
}
|
|
|
|
/**
|
|
* Updates the credentials in the generation config.
|
|
* This is needed when credentials are set after Config construction.
|
|
*/
|
|
updateCredentials(credentials: {
|
|
apiKey?: string;
|
|
baseUrl?: string;
|
|
model?: string;
|
|
}): void {
|
|
if (credentials.apiKey) {
|
|
this._generationConfig.apiKey = credentials.apiKey;
|
|
}
|
|
if (credentials.baseUrl) {
|
|
this._generationConfig.baseUrl = credentials.baseUrl;
|
|
}
|
|
if (credentials.model) {
|
|
this._generationConfig.model = credentials.model;
|
|
}
|
|
}
|
|
|
|
async refreshAuth(authMethod: AuthType, isInitialAuth?: boolean) {
|
|
// Vertex and Genai have incompatible encryption and sending history with
|
|
// throughtSignature from Genai to Vertex will fail, we need to strip them
|
|
if (
|
|
this.contentGeneratorConfig?.authType === AuthType.USE_GEMINI &&
|
|
authMethod === AuthType.LOGIN_WITH_GOOGLE
|
|
) {
|
|
// Restore the conversation history to the new client
|
|
this.geminiClient.stripThoughtsFromHistory();
|
|
}
|
|
|
|
const newContentGeneratorConfig = createContentGeneratorConfig(
|
|
this,
|
|
authMethod,
|
|
this._generationConfig,
|
|
);
|
|
this.contentGenerator = await createContentGenerator(
|
|
newContentGeneratorConfig,
|
|
this,
|
|
isInitialAuth,
|
|
);
|
|
// Only assign to instance properties after successful initialization
|
|
this.contentGeneratorConfig = newContentGeneratorConfig;
|
|
|
|
// Initialize BaseLlmClient now that the ContentGenerator is available
|
|
this.baseLlmClient = new BaseLlmClient(this.contentGenerator, this);
|
|
|
|
// Reset the session flag since we're explicitly changing auth and using default model
|
|
this.inFallbackMode = false;
|
|
}
|
|
|
|
/**
|
|
* Provides access to the BaseLlmClient for stateless LLM operations.
|
|
*/
|
|
getBaseLlmClient(): BaseLlmClient {
|
|
if (!this.baseLlmClient) {
|
|
// Handle cases where initialization might be deferred or authentication failed
|
|
if (this.contentGenerator) {
|
|
this.baseLlmClient = new BaseLlmClient(
|
|
this.getContentGenerator(),
|
|
this,
|
|
);
|
|
} else {
|
|
throw new Error(
|
|
'BaseLlmClient not initialized. Ensure authentication has occurred and ContentGenerator is ready.',
|
|
);
|
|
}
|
|
}
|
|
return this.baseLlmClient;
|
|
}
|
|
|
|
getSessionId(): string {
|
|
return this.sessionId;
|
|
}
|
|
|
|
/**
|
|
* Starts a new session and resets session-scoped services.
|
|
*/
|
|
startNewSession(sessionId?: string): string {
|
|
this.sessionId = sessionId ?? randomUUID();
|
|
this.sessionData = undefined;
|
|
this.chatRecordingService = new ChatRecordingService(this);
|
|
if (this.initialized) {
|
|
logStartSession(this, new StartSessionEvent(this));
|
|
}
|
|
return this.sessionId;
|
|
}
|
|
|
|
/**
|
|
* Returns the resumed session data if this session was resumed from a previous one.
|
|
*/
|
|
getResumedSessionData(): ResumedSessionData | undefined {
|
|
return this.sessionData;
|
|
}
|
|
|
|
shouldLoadMemoryFromIncludeDirectories(): boolean {
|
|
return this.loadMemoryFromIncludeDirectories;
|
|
}
|
|
|
|
getContentGeneratorConfig(): ContentGeneratorConfig {
|
|
return this.contentGeneratorConfig;
|
|
}
|
|
|
|
getModel(): string {
|
|
return this.contentGeneratorConfig?.model || DEFAULT_QWEN_MODEL;
|
|
}
|
|
|
|
async setModel(
|
|
newModel: string,
|
|
_metadata?: { reason?: string; context?: string },
|
|
): Promise<void> {
|
|
if (this.contentGeneratorConfig) {
|
|
this.contentGeneratorConfig.model = newModel;
|
|
}
|
|
// TODO: Log _metadata for telemetry if needed
|
|
// This _metadata can be used for tracking model switches (reason, context)
|
|
}
|
|
|
|
isInFallbackMode(): boolean {
|
|
return this.inFallbackMode;
|
|
}
|
|
|
|
setFallbackMode(active: boolean): void {
|
|
this.inFallbackMode = active;
|
|
}
|
|
|
|
setFallbackModelHandler(handler: FallbackModelHandler): void {
|
|
this.fallbackModelHandler = handler;
|
|
}
|
|
|
|
getMaxSessionTurns(): number {
|
|
return this.maxSessionTurns;
|
|
}
|
|
|
|
getSessionTokenLimit(): number {
|
|
return this.sessionTokenLimit;
|
|
}
|
|
|
|
setQuotaErrorOccurred(value: boolean): void {
|
|
this.quotaErrorOccurred = value;
|
|
}
|
|
|
|
getQuotaErrorOccurred(): boolean {
|
|
return this.quotaErrorOccurred;
|
|
}
|
|
|
|
getEmbeddingModel(): string {
|
|
return this.embeddingModel;
|
|
}
|
|
|
|
getSandbox(): SandboxConfig | undefined {
|
|
return this.sandbox;
|
|
}
|
|
|
|
isRestrictiveSandbox(): boolean {
|
|
const sandboxConfig = this.getSandbox();
|
|
const seatbeltProfile = process.env['SEATBELT_PROFILE'];
|
|
return (
|
|
!!sandboxConfig &&
|
|
sandboxConfig.command === 'sandbox-exec' &&
|
|
!!seatbeltProfile &&
|
|
seatbeltProfile.startsWith('restrictive-')
|
|
);
|
|
}
|
|
|
|
getTargetDir(): string {
|
|
return this.targetDir;
|
|
}
|
|
|
|
getProjectRoot(): string {
|
|
return this.targetDir;
|
|
}
|
|
|
|
getWorkspaceContext(): WorkspaceContext {
|
|
return this.workspaceContext;
|
|
}
|
|
|
|
getToolRegistry(): ToolRegistry {
|
|
return this.toolRegistry;
|
|
}
|
|
|
|
getPromptRegistry(): PromptRegistry {
|
|
return this.promptRegistry;
|
|
}
|
|
|
|
getDebugMode(): boolean {
|
|
return this.debugMode;
|
|
}
|
|
|
|
getQuestion(): string | undefined {
|
|
return this.question;
|
|
}
|
|
|
|
getFullContext(): boolean {
|
|
return this.fullContext;
|
|
}
|
|
|
|
getCoreTools(): string[] | undefined {
|
|
return this.coreTools;
|
|
}
|
|
|
|
getAllowedTools(): string[] | undefined {
|
|
return this.allowedTools;
|
|
}
|
|
|
|
getExcludeTools(): string[] | undefined {
|
|
return this.excludeTools;
|
|
}
|
|
|
|
getToolDiscoveryCommand(): string | undefined {
|
|
return this.toolDiscoveryCommand;
|
|
}
|
|
|
|
getToolCallCommand(): string | undefined {
|
|
return this.toolCallCommand;
|
|
}
|
|
|
|
getMcpServerCommand(): string | undefined {
|
|
return this.mcpServerCommand;
|
|
}
|
|
|
|
getMcpServers(): Record<string, MCPServerConfig> | undefined {
|
|
return this.mcpServers;
|
|
}
|
|
|
|
getUserMemory(): string {
|
|
return this.userMemory;
|
|
}
|
|
|
|
setUserMemory(newUserMemory: string): void {
|
|
this.userMemory = newUserMemory;
|
|
}
|
|
|
|
getGeminiMdFileCount(): number {
|
|
return this.geminiMdFileCount;
|
|
}
|
|
|
|
setGeminiMdFileCount(count: number): void {
|
|
this.geminiMdFileCount = count;
|
|
}
|
|
|
|
getApprovalMode(): ApprovalMode {
|
|
return this.approvalMode;
|
|
}
|
|
|
|
setApprovalMode(mode: ApprovalMode): void {
|
|
if (
|
|
!this.isTrustedFolder() &&
|
|
mode !== ApprovalMode.DEFAULT &&
|
|
mode !== ApprovalMode.PLAN
|
|
) {
|
|
throw new Error(
|
|
'Cannot enable privileged approval modes in an untrusted folder.',
|
|
);
|
|
}
|
|
this.approvalMode = mode;
|
|
}
|
|
|
|
getShowMemoryUsage(): boolean {
|
|
return this.showMemoryUsage;
|
|
}
|
|
|
|
getInputFormat(): 'text' | 'stream-json' {
|
|
return this.inputFormat;
|
|
}
|
|
|
|
getIncludePartialMessages(): boolean {
|
|
return this.includePartialMessages;
|
|
}
|
|
|
|
getAccessibility(): AccessibilitySettings {
|
|
return this.accessibility;
|
|
}
|
|
|
|
getTelemetryEnabled(): boolean {
|
|
return this.telemetrySettings.enabled ?? false;
|
|
}
|
|
|
|
getTelemetryLogPromptsEnabled(): boolean {
|
|
return this.telemetrySettings.logPrompts ?? true;
|
|
}
|
|
|
|
getTelemetryOtlpEndpoint(): string {
|
|
return this.telemetrySettings.otlpEndpoint ?? DEFAULT_OTLP_ENDPOINT;
|
|
}
|
|
|
|
getTelemetryOtlpProtocol(): 'grpc' | 'http' {
|
|
return this.telemetrySettings.otlpProtocol ?? 'grpc';
|
|
}
|
|
|
|
getTelemetryTarget(): TelemetryTarget {
|
|
return this.telemetrySettings.target ?? DEFAULT_TELEMETRY_TARGET;
|
|
}
|
|
|
|
getTelemetryOutfile(): string | undefined {
|
|
return this.telemetrySettings.outfile;
|
|
}
|
|
|
|
getGitCoAuthor(): GitCoAuthorSettings {
|
|
return this.gitCoAuthor;
|
|
}
|
|
|
|
getTelemetryUseCollector(): boolean {
|
|
return this.telemetrySettings.useCollector ?? false;
|
|
}
|
|
|
|
getGeminiClient(): GeminiClient {
|
|
return this.geminiClient;
|
|
}
|
|
|
|
getEnableRecursiveFileSearch(): boolean {
|
|
return this.fileFiltering.enableRecursiveFileSearch;
|
|
}
|
|
|
|
getFileFilteringDisableFuzzySearch(): boolean {
|
|
return this.fileFiltering.disableFuzzySearch;
|
|
}
|
|
|
|
getFileFilteringRespectGitIgnore(): boolean {
|
|
return this.fileFiltering.respectGitIgnore;
|
|
}
|
|
getFileFilteringRespectQwenIgnore(): boolean {
|
|
return this.fileFiltering.respectQwenIgnore;
|
|
}
|
|
|
|
getFileFilteringOptions(): FileFilteringOptions {
|
|
return {
|
|
respectGitIgnore: this.fileFiltering.respectGitIgnore,
|
|
respectQwenIgnore: this.fileFiltering.respectQwenIgnore,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Gets custom file exclusion patterns from configuration.
|
|
* TODO: This is a placeholder implementation. In the future, this could
|
|
* read from settings files, CLI arguments, or environment variables.
|
|
*/
|
|
getCustomExcludes(): string[] {
|
|
// Placeholder implementation - returns empty array for now
|
|
// Future implementation could read from:
|
|
// - User settings file
|
|
// - Project-specific configuration
|
|
// - Environment variables
|
|
// - CLI arguments
|
|
return [];
|
|
}
|
|
|
|
getCheckpointingEnabled(): boolean {
|
|
return this.checkpointing;
|
|
}
|
|
|
|
getProxy(): string | undefined {
|
|
return this.proxy;
|
|
}
|
|
|
|
getWorkingDir(): string {
|
|
return this.cwd;
|
|
}
|
|
|
|
getBugCommand(): BugCommandSettings | undefined {
|
|
return this.bugCommand;
|
|
}
|
|
|
|
getFileService(): FileDiscoveryService {
|
|
if (!this.fileDiscoveryService) {
|
|
this.fileDiscoveryService = new FileDiscoveryService(this.targetDir);
|
|
}
|
|
return this.fileDiscoveryService;
|
|
}
|
|
|
|
getUsageStatisticsEnabled(): boolean {
|
|
return this.usageStatisticsEnabled;
|
|
}
|
|
|
|
getExtensionContextFilePaths(): string[] {
|
|
return this.extensionContextFilePaths;
|
|
}
|
|
|
|
getExperimentalZedIntegration(): boolean {
|
|
return this.experimentalZedIntegration;
|
|
}
|
|
|
|
getListExtensions(): boolean {
|
|
return this.listExtensions;
|
|
}
|
|
|
|
getExtensionManagement(): boolean {
|
|
return this.extensionManagement;
|
|
}
|
|
|
|
getExtensions(): GeminiCLIExtension[] {
|
|
return this._extensions;
|
|
}
|
|
|
|
getBlockedMcpServers(): Array<{ name: string; extensionName: string }> {
|
|
return this._blockedMcpServers;
|
|
}
|
|
|
|
getNoBrowser(): boolean {
|
|
return this.noBrowser;
|
|
}
|
|
|
|
isBrowserLaunchSuppressed(): boolean {
|
|
return this.getNoBrowser() || !shouldAttemptBrowserLaunch();
|
|
}
|
|
|
|
getSummarizeToolOutputConfig():
|
|
| Record<string, SummarizeToolOutputSettings>
|
|
| undefined {
|
|
return this.summarizeToolOutput;
|
|
}
|
|
|
|
// Web search provider configuration
|
|
getWebSearchConfig() {
|
|
return this.webSearch;
|
|
}
|
|
|
|
getIdeMode(): boolean {
|
|
return this.ideMode;
|
|
}
|
|
|
|
getFolderTrustFeature(): boolean {
|
|
return this.folderTrustFeature;
|
|
}
|
|
|
|
/**
|
|
* Returns 'true' if the workspace is considered "trusted".
|
|
* 'false' for untrusted.
|
|
*/
|
|
getFolderTrust(): boolean {
|
|
return this.folderTrust;
|
|
}
|
|
|
|
isTrustedFolder(): boolean {
|
|
// isWorkspaceTrusted in cli/src/config/trustedFolder.js returns undefined
|
|
// when the file based trust value is unavailable, since it is mainly used
|
|
// in the initialization for trust dialogs, etc. Here we return true since
|
|
// config.isTrustedFolder() is used for the main business logic of blocking
|
|
// tool calls etc in the rest of the application.
|
|
//
|
|
// Default value is true since we load with trusted settings to avoid
|
|
// restarts in the more common path. If the user chooses to mark the folder
|
|
// as untrusted, the CLI will restart and we will have the trust value
|
|
// reloaded.
|
|
const context = ideContextStore.get();
|
|
if (context?.workspaceState?.isTrusted !== undefined) {
|
|
return context.workspaceState.isTrusted;
|
|
}
|
|
|
|
return this.trustedFolder ?? true;
|
|
}
|
|
|
|
setIdeMode(value: boolean): void {
|
|
this.ideMode = value;
|
|
}
|
|
|
|
getAuthType(): AuthType | undefined {
|
|
return this.contentGeneratorConfig.authType;
|
|
}
|
|
|
|
getCliVersion(): string | undefined {
|
|
return this.cliVersion;
|
|
}
|
|
|
|
/**
|
|
* Get the current FileSystemService
|
|
*/
|
|
getFileSystemService(): FileSystemService {
|
|
return this.fileSystemService;
|
|
}
|
|
|
|
/**
|
|
* Set a custom FileSystemService
|
|
*/
|
|
setFileSystemService(fileSystemService: FileSystemService): void {
|
|
this.fileSystemService = fileSystemService;
|
|
}
|
|
|
|
getChatCompression(): ChatCompressionSettings | undefined {
|
|
return this.chatCompression;
|
|
}
|
|
|
|
isInteractive(): boolean {
|
|
return this.interactive;
|
|
}
|
|
|
|
getUseRipgrep(): boolean {
|
|
return this.useRipgrep;
|
|
}
|
|
|
|
getUseBuiltinRipgrep(): boolean {
|
|
return this.useBuiltinRipgrep;
|
|
}
|
|
|
|
getShouldUseNodePtyShell(): boolean {
|
|
return this.shouldUseNodePtyShell;
|
|
}
|
|
|
|
getSkipNextSpeakerCheck(): boolean {
|
|
return this.skipNextSpeakerCheck;
|
|
}
|
|
|
|
getShellExecutionConfig(): ShellExecutionConfig {
|
|
return this.shellExecutionConfig;
|
|
}
|
|
|
|
setShellExecutionConfig(config: ShellExecutionConfig): void {
|
|
this.shellExecutionConfig = {
|
|
terminalWidth:
|
|
config.terminalWidth ?? this.shellExecutionConfig.terminalWidth,
|
|
terminalHeight:
|
|
config.terminalHeight ?? this.shellExecutionConfig.terminalHeight,
|
|
showColor: config.showColor ?? this.shellExecutionConfig.showColor,
|
|
pager: config.pager ?? this.shellExecutionConfig.pager,
|
|
};
|
|
}
|
|
getScreenReader(): boolean {
|
|
return this.accessibility.screenReader ?? false;
|
|
}
|
|
|
|
getSkipLoopDetection(): boolean {
|
|
return this.skipLoopDetection;
|
|
}
|
|
|
|
getSkipStartupContext(): boolean {
|
|
return this.skipStartupContext;
|
|
}
|
|
|
|
getVlmSwitchMode(): string | undefined {
|
|
return this.vlmSwitchMode;
|
|
}
|
|
|
|
getEnableToolOutputTruncation(): boolean {
|
|
return this.enableToolOutputTruncation;
|
|
}
|
|
|
|
getTruncateToolOutputThreshold(): number {
|
|
if (
|
|
!this.enableToolOutputTruncation ||
|
|
this.truncateToolOutputThreshold <= 0
|
|
) {
|
|
return Number.POSITIVE_INFINITY;
|
|
}
|
|
|
|
return Math.min(
|
|
// Estimate remaining context window in characters (1 token ~= 4 chars).
|
|
4 *
|
|
(tokenLimit(this.getModel()) -
|
|
uiTelemetryService.getLastPromptTokenCount()),
|
|
this.truncateToolOutputThreshold,
|
|
);
|
|
}
|
|
|
|
getTruncateToolOutputLines(): number {
|
|
if (!this.enableToolOutputTruncation || this.truncateToolOutputLines <= 0) {
|
|
return Number.POSITIVE_INFINITY;
|
|
}
|
|
|
|
return this.truncateToolOutputLines;
|
|
}
|
|
|
|
getUseSmartEdit(): boolean {
|
|
return this.useSmartEdit;
|
|
}
|
|
|
|
getOutputFormat(): OutputFormat {
|
|
return this.outputFormat;
|
|
}
|
|
|
|
async getGitService(): Promise<GitService> {
|
|
if (!this.gitService) {
|
|
this.gitService = new GitService(this.targetDir, this.storage);
|
|
await this.gitService.initialize();
|
|
}
|
|
return this.gitService;
|
|
}
|
|
|
|
/**
|
|
* Returns the chat recording service.
|
|
*/
|
|
getChatRecordingService(): ChatRecordingService {
|
|
if (!this.chatRecordingService) {
|
|
this.chatRecordingService = new ChatRecordingService(this);
|
|
}
|
|
return this.chatRecordingService;
|
|
}
|
|
|
|
/**
|
|
* Gets or creates a SessionService for managing chat sessions.
|
|
*/
|
|
getSessionService(): SessionService {
|
|
if (!this.sessionService) {
|
|
this.sessionService = new SessionService(this.targetDir);
|
|
}
|
|
return this.sessionService;
|
|
}
|
|
|
|
getFileExclusions(): FileExclusions {
|
|
return this.fileExclusions;
|
|
}
|
|
|
|
getSubagentManager(): SubagentManager {
|
|
return this.subagentManager;
|
|
}
|
|
|
|
async createToolRegistry(): Promise<ToolRegistry> {
|
|
const registry = new ToolRegistry(this, this.eventEmitter);
|
|
|
|
const coreToolsConfig = this.getCoreTools();
|
|
const excludeToolsConfig = this.getExcludeTools();
|
|
|
|
// Helper to create & register core tools that are enabled
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
const registerCoreTool = (ToolClass: any, ...args: unknown[]) => {
|
|
const toolName = ToolClass?.Name as ToolName | undefined;
|
|
const className = ToolClass?.name ?? 'UnknownTool';
|
|
|
|
if (!toolName) {
|
|
// Log warning and skip this tool instead of crashing
|
|
console.warn(
|
|
`[Config] Skipping tool registration: ${className} is missing static Name property. ` +
|
|
`Tools must define a static Name property to be registered. ` +
|
|
`Location: config.ts:registerCoreTool`,
|
|
);
|
|
return;
|
|
}
|
|
|
|
if (isToolEnabled(toolName, coreToolsConfig, excludeToolsConfig)) {
|
|
try {
|
|
registry.registerTool(new ToolClass(...args));
|
|
} catch (error) {
|
|
console.error(
|
|
`[Config] Failed to register tool ${className} (${toolName}):`,
|
|
error,
|
|
);
|
|
throw error; // Re-throw after logging context
|
|
}
|
|
}
|
|
};
|
|
|
|
registerCoreTool(TaskTool, this);
|
|
registerCoreTool(LSTool, this);
|
|
registerCoreTool(ReadFileTool, this);
|
|
|
|
if (this.getUseRipgrep()) {
|
|
let useRipgrep = false;
|
|
let errorString: undefined | string = undefined;
|
|
try {
|
|
useRipgrep = await canUseRipgrep(this.getUseBuiltinRipgrep());
|
|
} catch (error: unknown) {
|
|
errorString = getErrorMessage(error);
|
|
}
|
|
if (useRipgrep) {
|
|
registerCoreTool(RipGrepTool, this);
|
|
} else {
|
|
// Log for telemetry
|
|
logRipgrepFallback(
|
|
this,
|
|
new RipgrepFallbackEvent(
|
|
this.getUseRipgrep(),
|
|
this.getUseBuiltinRipgrep(),
|
|
errorString || 'ripgrep is not available',
|
|
),
|
|
);
|
|
registerCoreTool(GrepTool, this);
|
|
}
|
|
} else {
|
|
registerCoreTool(GrepTool, this);
|
|
}
|
|
|
|
registerCoreTool(GlobTool, this);
|
|
if (this.getUseSmartEdit()) {
|
|
registerCoreTool(SmartEditTool, this);
|
|
} else {
|
|
registerCoreTool(EditTool, this);
|
|
}
|
|
registerCoreTool(WriteFileTool, this);
|
|
registerCoreTool(ReadManyFilesTool, this);
|
|
registerCoreTool(ShellTool, this);
|
|
registerCoreTool(MemoryTool);
|
|
registerCoreTool(TodoWriteTool, this);
|
|
registerCoreTool(ExitPlanModeTool, this);
|
|
registerCoreTool(WebFetchTool, this);
|
|
// Conditionally register web search tool if web search provider is configured
|
|
// buildWebSearchConfig ensures qwen-oauth users get dashscope provider, so
|
|
// if tool is registered, config must exist
|
|
if (this.getWebSearchConfig()) {
|
|
registerCoreTool(WebSearchTool, this);
|
|
}
|
|
|
|
await registry.discoverAllTools();
|
|
return registry;
|
|
}
|
|
}
|