orquesta-cli 0.1.27 → 0.2.1

package/dist/agents/planner/index.d.ts

@@ -7,7 +7,8 @@ export interface PlanningWithDocsResult extends PlanningResult {
 export declare class PlanningLLM {
     private llmClient;
     private askUserCallback;
-    constructor(llmClient: LLMClient);
+    private modelOverride?;
+    constructor(llmClient: LLMClient, modelOverride?: string);
     setAskUserCallback(callback: AskUserCallback): void;
     clearAskUserCallback(): void;
     generateTODOList(userRequest: string, contextMessages?: Message[]): Promise<PlanningResult>;

package/dist/agents/planner/index.js

@@ -5,8 +5,10 @@ import { getProjectContext } from '../../core/project-context.js';
 export class PlanningLLM {
     llmClient;
     askUserCallback = null;
-    constructor(llmClient) {
+    modelOverride;
+    constructor(llmClient, modelOverride) {
         this.llmClient = llmClient;
+        this.modelOverride = modelOverride;
     }
     setAskUserCallback(callback) {
         logger.flow('Setting ask-user callback for Planning LLM');
@@ -73,6 +75,7 @@ Choose one of your 3 tools now.`,
                         tool_choice: 'required',
                         temperature: 0.7,
                         max_tokens: 2000,
+                        ...(this.modelOverride ? { model: this.modelOverride } : {}),
                     });
                     const choicesCount = response.choices?.length ?? 0;
                     const message = response.choices?.[0]?.message;
@@ -174,6 +177,9 @@ Choose one of your 3 tools now.`,
                                 id: todo.id || `todo-${Date.now()}-${index}`,
                                 title: todo.title || 'Untitled task',
                                 status: (index === 0 ? 'in_progress' : 'pending'),
+                                ...(Array.isArray(todo.dependsOn) && todo.dependsOn.length > 0 ? { dependsOn: todo.dependsOn } : {}),
+                                ...(typeof todo.requiresFilesystem === 'boolean' ? { requiresFilesystem: todo.requiresFilesystem } : {}),
+                                ...(typeof todo.parallelGroup === 'string' && todo.parallelGroup ? { parallelGroup: todo.parallelGroup } : {}),
                             }));
                             return {
                                 todos,

package/dist/core/config/config-manager.d.ts

@@ -1,4 +1,4 @@
-import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig } from '../../types/index.js';
+import { OpenConfig, EndpointConfig, ModelInfo, OrquestaConfig, OrchestrationConfig, OrchestrationRole } from '../../types/index.js';
 export declare class ConfigManager {
     private config;
     private initialized;
@@ -51,6 +51,16 @@ export declare class ConfigManager {
         unchanged: number;
     }>;
     getLocalOnlyEndpoints(): EndpointConfig[];
+    getOrchestrationConfig(): OrchestrationConfig;
+    getRoleModel(role: OrchestrationRole): string | null;
+    setRoleModel(role: OrchestrationRole, modelId: string | null): Promise<void>;
+    clearRoleModels(): Promise<void>;
+    getMaxParallelWorkers(): number;
+    setMaxParallelWorkers(n: number): Promise<void>;
+    isRefinerEnabled(): boolean;
+    setRefinerEnabled(enabled: boolean): Promise<void>;
+    isWorktreeIsolationEnabled(): boolean;
+    setWorktreeIsolationEnabled(enabled: boolean): Promise<void>;
 }
 export declare const configManager: ConfigManager;
 //# sourceMappingURL=config-manager.d.ts.map

package/dist/core/config/config-manager.js

@@ -337,6 +337,66 @@ export class ConfigManager {
         const config = this.getConfig();
         return config.endpoints;
     }
+    getOrchestrationConfig() {
+        return this.config?.orchestration ?? {};
+    }
+    getRoleModel(role) {
+        const override = this.config?.orchestration?.roleModels?.[role];
+        if (override)
+            return override;
+        return this.config?.currentModel ?? null;
+    }
+    async setRoleModel(role, modelId) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        if (!config.orchestration.roleModels)
+            config.orchestration.roleModels = {};
+        if (modelId === null) {
+            delete config.orchestration.roleModels[role];
+        }
+        else {
+            config.orchestration.roleModels[role] = modelId;
+        }
+        await this.saveConfig();
+    }
+    async clearRoleModels() {
+        const config = this.getConfig();
+        if (config.orchestration) {
+            config.orchestration.roleModels = {};
+            await this.saveConfig();
+        }
+    }
+    getMaxParallelWorkers() {
+        return this.config?.orchestration?.maxParallelWorkers ?? 3;
+    }
+    async setMaxParallelWorkers(n) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.maxParallelWorkers = Math.max(1, Math.min(10, n));
+        await this.saveConfig();
+    }
+    isRefinerEnabled() {
+        return this.config?.orchestration?.refinerEnabled ?? false;
+    }
+    async setRefinerEnabled(enabled) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.refinerEnabled = enabled;
+        await this.saveConfig();
+    }
+    isWorktreeIsolationEnabled() {
+        return this.config?.orchestration?.worktreeIsolation ?? false;
+    }
+    async setWorktreeIsolationEnabled(enabled) {
+        const config = this.getConfig();
+        if (!config.orchestration)
+            config.orchestration = {};
+        config.orchestration.worktreeIsolation = enabled;
+        await this.saveConfig();
+    }
 }
 export const configManager = new ConfigManager();
 //# sourceMappingURL=config-manager.js.map

package/dist/core/config/providers.js

@@ -36,6 +36,22 @@ export const PROVIDERS = [
             { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', maxTokens: 200000, capabilities: ['vision', 'tools', 'streaming'] },
         ],
     },
+    {
+        id: 'anthropic-direct',
+        name: 'Anthropic (OpenAI-compat)',
+        baseUrl: 'https://api.anthropic.com/v1/openai',
+        authMethod: 'bearer',
+        envVars: ['ANTHROPIC_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', maxTokens: 200000, capabilities: ['vision', 'tools', 'streaming'] },
+        ],
+    },
     {
         id: 'google',
         name: 'Google Gemini',
@@ -151,6 +167,20 @@ export const PROVIDERS = [
             { id: 'grok-3-mini', name: 'Grok 3 Mini', maxTokens: 131072, capabilities: ['tools', 'streaming'] },
         ],
     },
+    {
+        id: 'kimi-code',
+        name: 'Kimi For Coding',
+        baseUrl: 'https://api.kimi.com/coding',
+        authMethod: 'x-api-key',
+        envVars: ['KIMI_CODE_API_KEY', 'KIMI_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        openaiCompatible: false,
+        extraHeaders: { 'anthropic-version': '2023-06-01' },
+        knownModels: [
+            { id: 'kimi-for-coding', name: 'Kimi For Coding (K2.6)', maxTokens: 200000, capabilities: ['tools', 'streaming'] },
+        ],
+    },
     {
         id: 'perplexity',
         name: 'Perplexity',
@@ -208,6 +238,7 @@ export const PROVIDERS = [
             { id: 'mistral-large-latest', name: 'Mistral Large', maxTokens: 128000, capabilities: ['tools', 'json_mode', 'streaming'] },
             { id: 'grok-4', name: 'Grok 4', maxTokens: 131072, capabilities: ['tools', 'streaming'] },
             { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B (Groq)', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'kimi-for-coding', name: 'Kimi For Coding (K2.6)', maxTokens: 200000, capabilities: ['tools', 'streaming'] },
         ],
     },
     {

package/dist/core/git-auto-updater.d.ts

@@ -0,0 +1,58 @@
+export type UpdateStatus = {
+    type: 'checking';
+} | {
+    type: 'no_update';
+} | {
+    type: 'first_run';
+    step: number;
+    totalSteps: number;
+    message: string;
+} | {
+    type: 'updating';
+    step: number;
+    totalSteps: number;
+    message: string;
+} | {
+    type: 'complete';
+    needsRestart: boolean;
+    message: string;
+} | {
+    type: 'error';
+    message: string;
+} | {
+    type: 'skipped';
+    reason: string;
+};
+export type StatusCallback = (status: UpdateStatus) => void;
+export declare class GitAutoUpdater {
+    private repoUrl;
+    private repoDir;
+    private commitFile;
+    private enabled;
+    private onStatus;
+    constructor(options?: {
+        repoUrl?: string;
+        enabled?: boolean;
+        onStatus?: StatusCallback;
+    });
+    setStatusCallback(callback: StatusCallback): void;
+    private emitStatus;
+    run(options?: {
+        noUpdate?: boolean;
+    }): Promise<boolean>;
+    private runBinaryMode;
+    private getRemoteCommit;
+    private getSavedCommit;
+    private saveCommit;
+    private updateBinary;
+    private initialSetup;
+    private pullAndUpdate;
+    private freshClone;
+    private rebuildAndLink;
+    private copyBinariesInternal;
+    private ensurePathConfigured;
+    private unlinkNpm;
+    private cleanupRepo;
+}
+export default GitAutoUpdater;
+//# sourceMappingURL=git-auto-updater.d.ts.map

package/dist/core/git-auto-updater.js

@@ -0,0 +1,374 @@
+import { spawn } from 'child_process';
+import fs, { createReadStream, createWriteStream } from 'fs';
+import { rm, copyFile, chmod } from 'fs/promises';
+import { pipeline } from 'stream/promises';
+import path from 'path';
+import os from 'os';
+import zlib from 'zlib';
+import { logger } from '../utils/logger.js';
+function isRunningAsBinary() {
+    const execPath = process.execPath;
+    const isNodeRuntime = execPath.includes('node') || execPath.includes('nodejs');
+    return !isNodeRuntime;
+}
+function execAsync(command, options = {}) {
+    return new Promise((resolve, reject) => {
+        const [cmd, ...args] = command.split(' ');
+        const child = spawn(cmd, args, {
+            cwd: options.cwd,
+            shell: true,
+            stdio: 'pipe',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve({ stdout, stderr });
+            }
+            else {
+                const error = new Error(`Command failed: ${command}`);
+                error.stdout = stdout;
+                error.stderr = stderr;
+                error.code = code;
+                reject(error);
+            }
+        });
+        child.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+export class GitAutoUpdater {
+    repoUrl = 'https://github.com/A2G-Dev-Space/Local-CLI.git';
+    repoDir;
+    commitFile;
+    enabled = true;
+    onStatus = null;
+    constructor(options) {
+        this.repoDir = path.join(os.homedir(), '.local-cli', 'repo');
+        this.commitFile = path.join(os.homedir(), '.local-cli', 'current-commit');
+        if (options?.repoUrl) {
+            this.repoUrl = options.repoUrl;
+        }
+        if (options?.enabled !== undefined) {
+            this.enabled = options.enabled;
+        }
+        if (options?.onStatus) {
+            this.onStatus = options.onStatus;
+        }
+    }
+    setStatusCallback(callback) {
+        this.onStatus = callback;
+    }
+    emitStatus(status) {
+        if (this.onStatus) {
+            this.onStatus(status);
+        }
+    }
+    async run(options = {}) {
+        logger.enter('GitAutoUpdater.run', {
+            noUpdate: options.noUpdate,
+            enabled: this.enabled,
+            repoDir: this.repoDir
+        });
+        if (options.noUpdate || !this.enabled) {
+            logger.flow('Git auto-update disabled - skipping');
+            this.emitStatus({ type: 'skipped', reason: 'disabled' });
+            return false;
+        }
+        this.emitStatus({ type: 'checking' });
+        try {
+            if (isRunningAsBinary() && fs.existsSync(this.repoDir)) {
+                logger.flow('Cleaning up leftover repo from previous version');
+                await this.cleanupRepo();
+            }
+            if (isRunningAsBinary()) {
+                return await this.runBinaryMode();
+            }
+            logger.flow('Checking repository directory');
+            if (!fs.existsSync(this.repoDir)) {
+                logger.flow('First run detected - need initial setup');
+                return await this.initialSetup();
+            }
+            else {
+                return await this.pullAndUpdate();
+            }
+        }
+        catch (error) {
+            logger.error('Git auto-update failed', error);
+            this.emitStatus({ type: 'error', message: 'Auto-update failed, continuing with current version' });
+        }
+        return false;
+    }
+    async runBinaryMode() {
+        logger.flow('Running in binary mode - using ls-remote for update check');
+        try {
+            const remoteCommit = await this.getRemoteCommit();
+            if (!remoteCommit) {
+                logger.error('Failed to get remote commit');
+                this.emitStatus({ type: 'error', message: 'Failed to check for updates' });
+                return false;
+            }
+            const savedCommit = this.getSavedCommit();
+            logger.debug('Version check', { remote: remoteCommit.slice(0, 7), saved: savedCommit?.slice(0, 7) || 'none' });
+            if (savedCommit === remoteCommit) {
+                logger.flow('Already up to date');
+                this.emitStatus({ type: 'no_update' });
+                return false;
+            }
+            logger.flow('Update available, starting update process');
+            return await this.updateBinary(remoteCommit);
+        }
+        catch (error) {
+            logger.error('Binary mode update failed', error);
+            this.emitStatus({ type: 'error', message: 'Update check failed' });
+            return false;
+        }
+    }
+    async getRemoteCommit() {
+        try {
+            const result = await execAsync(`git ls-remote ${this.repoUrl} refs/heads/main`);
+            const match = result.stdout.match(/^([a-f0-9]+)/);
+            return match && match[1] ? match[1] : null;
+        }
+        catch (error) {
+            logger.error('Failed to get remote commit via ls-remote', error);
+            return null;
+        }
+    }
+    getSavedCommit() {
+        try {
+            if (fs.existsSync(this.commitFile)) {
+                return fs.readFileSync(this.commitFile, 'utf-8').trim();
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to read saved commit: ' + (error instanceof Error ? error.message : String(error)));
+        }
+        return null;
+    }
+    saveCommit(commit) {
+        try {
+            const dir = path.dirname(this.commitFile);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.commitFile, commit);
+            logger.debug('Saved commit hash: ' + commit.slice(0, 7));
+        }
+        catch (error) {
+            logger.debug('Failed to save commit: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async updateBinary(remoteCommit) {
+        const totalSteps = 3;
+        const isFirstRun = !this.getSavedCommit();
+        try {
+            const statusType = isFirstRun ? 'first_run' : 'updating';
+            this.emitStatus({ type: statusType, step: 1, totalSteps, message: 'Downloading update...' });
+            const parentDir = path.dirname(this.repoDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            await execAsync(`git clone --depth 1 ${this.repoUrl} ${this.repoDir}`);
+            this.emitStatus({ type: statusType, step: 2, totalSteps, message: 'Installing update...' });
+            const success = await this.copyBinariesInternal();
+            if (!success) {
+                return false;
+            }
+            this.emitStatus({ type: statusType, step: 3, totalSteps, message: 'Finalizing...' });
+            await this.cleanupRepo();
+            this.saveCommit(remoteCommit);
+            const shell = process.env['SHELL'] || '/bin/bash';
+            const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+            const restartMsg = isFirstRun
+                ? `Setup complete! Run: source ${rcFile} && lcli`
+                : 'Update complete! Please restart.';
+            this.emitStatus({ type: 'complete', needsRestart: true, message: restartMsg });
+            return true;
+        }
+        catch (error) {
+            logger.error('Binary update failed', error);
+            await this.cleanupRepo();
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Update failed: ${message}` });
+            return false;
+        }
+    }
+    async initialSetup() {
+        logger.enter('initialSetup', {
+            repoDir: this.repoDir,
+            repoUrl: this.repoUrl
+        });
+        const totalSteps = 4;
+        try {
+            this.emitStatus({ type: 'first_run', step: 1, totalSteps, message: 'Cloning repository...' });
+            const parentDir = path.dirname(this.repoDir);
+            if (!fs.existsSync(parentDir)) {
+                fs.mkdirSync(parentDir, { recursive: true });
+            }
+            await execAsync(`git clone ${this.repoUrl} ${this.repoDir}`);
+            this.emitStatus({ type: 'first_run', step: 2, totalSteps, message: 'Installing dependencies...' });
+            await execAsync('npm install', { cwd: this.repoDir });
+            this.emitStatus({ type: 'first_run', step: 3, totalSteps, message: 'Building project...' });
+            await execAsync('npm run build', { cwd: this.repoDir });
+            this.emitStatus({ type: 'first_run', step: 4, totalSteps, message: 'Creating global link...' });
+            await execAsync('npm link', { cwd: this.repoDir });
+            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Setup complete! Please restart.' });
+            return true;
+        }
+        catch (error) {
+            logger.error('Initial setup failed', error);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Setup failed: ${message}` });
+            return false;
+        }
+    }
+    async pullAndUpdate() {
+        logger.debug('Checking for updates', { repoDir: this.repoDir });
+        try {
+            await execAsync('git fetch origin main', { cwd: this.repoDir });
+            const currentResult = await execAsync('git rev-parse HEAD', { cwd: this.repoDir });
+            const latestResult = await execAsync('git rev-parse origin/main', { cwd: this.repoDir });
+            const currentCommit = currentResult.stdout.trim();
+            const latestCommit = latestResult.stdout.trim();
+            if (currentCommit === latestCommit) {
+                logger.debug('Already up to date, no rebuild needed');
+                this.emitStatus({ type: 'no_update' });
+                return false;
+            }
+            logger.debug('Resetting to latest commit...', { from: currentCommit.slice(0, 7), to: latestCommit.slice(0, 7) });
+            await execAsync('git reset --hard origin/main', { cwd: this.repoDir });
+            return await this.rebuildAndLink();
+        }
+        catch (error) {
+            logger.error('Pull/reset failed, attempting fresh clone', error);
+            return await this.freshClone();
+        }
+    }
+    async freshClone() {
+        logger.flow('Performing fresh clone');
+        try {
+            this.emitStatus({ type: 'updating', step: 1, totalSteps: 4, message: 'Removing old repository...' });
+            await rm(this.repoDir, { recursive: true, force: true });
+            return await this.initialSetup();
+        }
+        catch (error) {
+            logger.error('Fresh clone failed', error);
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Fresh clone failed: ${message}` });
+            return false;
+        }
+    }
+    async rebuildAndLink() {
+        const totalSteps = 3;
+        try {
+            this.emitStatus({ type: 'updating', step: 1, totalSteps, message: 'Updating dependencies...' });
+            await execAsync('npm install', { cwd: this.repoDir });
+            this.emitStatus({ type: 'updating', step: 2, totalSteps, message: 'Building project...' });
+            await execAsync('npm run build', { cwd: this.repoDir });
+            this.emitStatus({ type: 'updating', step: 3, totalSteps, message: 'Updating global link...' });
+            await execAsync('npm link', { cwd: this.repoDir });
+            this.emitStatus({ type: 'complete', needsRestart: true, message: 'Update complete! Please restart.' });
+            return true;
+        }
+        catch (buildError) {
+            logger.error('Build/link failed', buildError);
+            const message = buildError instanceof Error ? buildError.message : 'Unknown error';
+            this.emitStatus({ type: 'error', message: `Build failed: ${message}` });
+            return false;
+        }
+    }
+    async copyBinariesInternal() {
+        try {
+            const repoBinDir = path.join(this.repoDir, 'bin');
+            const installDir = path.join(os.homedir(), '.local', 'bin');
+            const lcliGzSrc = path.join(repoBinDir, 'lcli.gz');
+            const yogaSrc = path.join(repoBinDir, 'yoga.wasm');
+            const lcliDest = path.join(installDir, 'lcli');
+            const yogaDest = path.join(installDir, 'yoga.wasm');
+            if (!fs.existsSync(lcliGzSrc)) {
+                this.emitStatus({ type: 'error', message: 'Binary not found in repository (bin/lcli.gz)' });
+                return false;
+            }
+            if (!fs.existsSync(installDir)) {
+                fs.mkdirSync(installDir, { recursive: true });
+            }
+            await rm(lcliDest, { force: true });
+            await pipeline(createReadStream(lcliGzSrc), zlib.createGunzip(), createWriteStream(lcliDest));
+            await chmod(lcliDest, 0o755);
+            if (fs.existsSync(yogaSrc)) {
+                await copyFile(yogaSrc, yogaDest);
+            }
+            await this.ensurePathConfigured(installDir);
+            await this.unlinkNpm();
+            logger.debug('Binaries copied successfully');
+            return true;
+        }
+        catch (error) {
+            logger.error('Copy binaries internal failed', error);
+            return false;
+        }
+    }
+    async ensurePathConfigured(binDir) {
+        const pathExport = `export PATH="${binDir}:$PATH"`;
+        const marker = '# local-cli binary';
+        const shell = process.env['SHELL'] || '/bin/bash';
+        let rcFile;
+        if (shell.includes('zsh')) {
+            rcFile = path.join(os.homedir(), '.zshrc');
+        }
+        else {
+            rcFile = path.join(os.homedir(), '.bashrc');
+        }
+        try {
+            let content = '';
+            if (fs.existsSync(rcFile)) {
+                content = fs.readFileSync(rcFile, 'utf-8');
+            }
+            if (content.includes(marker)) {
+                logger.debug('PATH already configured (marker found)');
+                return;
+            }
+            const currentPath = process.env['PATH'] || '';
+            if (currentPath.split(':').includes(binDir)) {
+                logger.debug('PATH already contains binDir, adding marker for future reference');
+                fs.appendFileSync(rcFile, `\n${marker}\n# PATH already configured elsewhere\n`);
+                return;
+            }
+            const addition = `\n${marker}\n${pathExport}\n`;
+            fs.appendFileSync(rcFile, addition);
+            logger.debug('PATH configuration added to ' + rcFile);
+        }
+        catch (error) {
+            logger.debug('Failed to configure PATH: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+    async unlinkNpm() {
+        try {
+            await execAsync('npm unlink -g local-cli');
+        }
+        catch (error) {
+        }
+    }
+    async cleanupRepo() {
+        try {
+            if (fs.existsSync(this.repoDir)) {
+                logger.debug('Cleaning up repo directory to prevent source code exposure');
+                await rm(this.repoDir, { recursive: true, force: true });
+                logger.debug('Repo directory removed successfully');
+            }
+        }
+        catch (error) {
+            logger.debug('Failed to cleanup repo: ' + (error instanceof Error ? error.message : String(error)));
+        }
+    }
+}
+export default GitAutoUpdater;
+//# sourceMappingURL=git-auto-updater.js.map

package/dist/core/llm/llm-client.d.ts

@@ -61,6 +61,7 @@ export declare class LLMClient {
     chatCompletionWithTools(messages: Message[], tools: import('../../types/index.js').ToolDefinition[], options?: {
         getPendingMessage?: () => string | null;
         clearPendingMessage?: () => void;
+        model?: string;
     }): Promise<{
         message: Message;
         toolCalls: Array<{

package/dist/core/llm/llm-client.js

@@ -415,6 +415,7 @@ export class LLMClient {
         }
     }
     async chatCompletionWithTools(messages, tools, options) {
+        const roleModel = options?.model;
         let workingMessages = [...messages];
         const toolCallHistory = [];
         let iterations = 0;
@@ -443,6 +444,7 @@ export class LLMClient {
                     messages: workingMessages,
                     tools,
                     tool_choice: 'required',
+                    ...(roleModel ? { model: roleModel } : {}),
                 });
             }
             catch (error) {

package/dist/core/pricing.js

@@ -21,6 +21,8 @@ export const MODEL_PRICING = {
     'codestral-latest': { input: 0.30, output: 0.90 },
     'grok-4': { input: 5, output: 15 },
     'grok-3': { input: 5, output: 15 },
+    'kimi-for-coding': { input: 0, output: 0 },
+    'kimi-k2-coding': { input: 0, output: 0 },
     'claude-cli': { input: 0, output: 0 },
 };
 export function estimateCost(modelId, inputTokens, outputTokens) {