@kispace-io/extension-ai-system 0.8.0

package/src/service/token-usage-tracker.ts

@@ -0,0 +1,139 @@
+import { persistenceService } from "@kispace-io/core";
+import type { TokenUsage, ProviderTokenUsage } from "../core/types";
+
+interface TokenUsageData {
+    providers: Record<string, ProviderTokenUsage>;
+    total: ProviderTokenUsage;
+    lastUpdated: number;
+}
+
+const TOKEN_USAGE_KEY = "ai_token_usage";
+
+export class TokenUsageTracker {
+    private data: TokenUsageData | null = null;
+    private loadPromise: Promise<TokenUsageData> | null = null;
+
+    private async loadData(): Promise<TokenUsageData> {
+        if (this.data) {
+            return this.data;
+        }
+
+        if (this.loadPromise) {
+            return this.loadPromise;
+        }
+
+        this.loadPromise = (async () => {
+            const stored = await persistenceService.getObject(TOKEN_USAGE_KEY);
+            if (stored) {
+                this.data = stored as TokenUsageData;
+            } else {
+                this.data = {
+                    providers: {},
+                    total: {
+                        promptTokens: 0,
+                        completionTokens: 0,
+                        totalTokens: 0,
+                        requestCount: 0
+                    },
+                    lastUpdated: Date.now()
+                };
+                await this.saveData();
+            }
+            this.loadPromise = null;
+            return this.data;
+        })();
+
+        return this.loadPromise;
+    }
+
+    private async saveData(): Promise<void> {
+        if (this.data) {
+            this.data.lastUpdated = Date.now();
+            await persistenceService.persistObject(TOKEN_USAGE_KEY, this.data);
+        }
+    }
+
+    async recordUsage(providerName: string, usage: TokenUsage): Promise<void> {
+        await this.loadData();
+
+        if (!this.data) {
+            return;
+        }
+
+        if (!this.data.providers[providerName]) {
+            this.data.providers[providerName] = {
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                requestCount: 0
+            };
+        }
+
+        const provider = this.data.providers[providerName];
+        provider.promptTokens += usage.promptTokens;
+        provider.completionTokens += usage.completionTokens;
+        provider.totalTokens += usage.totalTokens;
+        provider.requestCount += 1;
+
+        this.data.total.promptTokens += usage.promptTokens;
+        this.data.total.completionTokens += usage.completionTokens;
+        this.data.total.totalTokens += usage.totalTokens;
+        this.data.total.requestCount += 1;
+
+        await this.saveData();
+    }
+
+    async getProviderUsage(providerName: string): Promise<ProviderTokenUsage | null> {
+        await this.loadData();
+        return this.data?.providers[providerName] || null;
+    }
+
+    async getAllProviderUsage(): Promise<Record<string, ProviderTokenUsage>> {
+        await this.loadData();
+        return this.data?.providers || {};
+    }
+
+    async getTotalUsage(): Promise<ProviderTokenUsage> {
+        await this.loadData();
+        return this.data?.total || {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0,
+            requestCount: 0
+        };
+    }
+
+    async reset(): Promise<void> {
+        this.data = {
+            providers: {},
+            total: {
+                promptTokens: 0,
+                completionTokens: 0,
+                totalTokens: 0,
+                requestCount: 0
+            },
+            lastUpdated: Date.now()
+        };
+        await this.saveData();
+    }
+
+    async resetProvider(providerName: string): Promise<void> {
+        await this.loadData();
+        if (!this.data) {
+            return;
+        }
+
+        const provider = this.data.providers[providerName];
+        if (provider) {
+            this.data.total.promptTokens -= provider.promptTokens;
+            this.data.total.completionTokens -= provider.completionTokens;
+            this.data.total.totalTokens -= provider.totalTokens;
+            this.data.total.requestCount -= provider.requestCount;
+            delete this.data.providers[providerName];
+            await this.saveData();
+        }
+    }
+}
+
+export const tokenUsageTracker = new TokenUsageTracker();
+

package/src/tools/index.ts

@@ -0,0 +1,4 @@
+export * from "./tool-executor";
+export * from "./tool-call-accumulator";
+export * from "./tool-registry";
+

package/src/tools/tool-call-accumulator.ts

@@ -0,0 +1,81 @@
+import type { ToolCall, StreamChunk } from "../core/types";
+
+export class ToolCallAccumulator {
+    private accumulatedToolCalls = new Map<string, ToolCall>();
+    private toolCallIndexMap = new Map<number, string>();
+
+    processChunk(chunk: StreamChunk): void {
+        if (chunk.type === 'token' && chunk.toolCalls && chunk.toolCalls.length > 0) {
+            for (const toolCall of chunk.toolCalls) {
+                const callIndex = (toolCall as any)._index;
+                const callId = toolCall.id;
+                
+                let existing: ToolCall | undefined;
+                let targetId: string;
+                
+                if (callIndex !== undefined && this.toolCallIndexMap.has(callIndex)) {
+                    targetId = this.toolCallIndexMap.get(callIndex)!;
+                    existing = this.accumulatedToolCalls.get(targetId);
+                } else if (callId && this.accumulatedToolCalls.has(callId)) {
+                    targetId = callId;
+                    existing = this.accumulatedToolCalls.get(targetId);
+                } else {
+                    targetId = callId || `call_${callIndex !== undefined ? callIndex : Date.now()}_${Math.random()}`;
+                    existing = undefined;
+                }
+                
+                if (existing) {
+                    const existingArgs = existing.function.arguments || "";
+                    const newArgs = toolCall.function.arguments || "";
+                    const combinedArgs = existingArgs + newArgs;
+                    
+                    this.accumulatedToolCalls.set(targetId, {
+                        id: targetId,
+                        type: toolCall.type || existing.type,
+                        function: {
+                            name: toolCall.function.name || existing.function.name,
+                            arguments: combinedArgs
+                        }
+                    });
+                    
+                    if (callIndex !== undefined && !this.toolCallIndexMap.has(callIndex)) {
+                        this.toolCallIndexMap.set(callIndex, targetId);
+                    }
+                } else {
+                    this.accumulatedToolCalls.set(targetId, {
+                        ...toolCall,
+                        id: targetId
+                    });
+                    
+                    if (callIndex !== undefined) {
+                        this.toolCallIndexMap.set(callIndex, targetId);
+                    }
+                }
+            }
+        }
+    }
+
+    getFinalToolCalls(): ToolCall[] {
+        return Array.from(this.accumulatedToolCalls.values())
+            .filter(tc => tc.function.name && tc.function.name.trim().length > 0)
+            .map(tc => {
+                let args = tc.function.arguments || "";
+                if (!args || args.trim() === "") {
+                    args = "{}";
+                }
+                return {
+                    ...tc,
+                    function: {
+                        ...tc.function,
+                        arguments: args
+                    }
+                };
+            });
+    }
+
+    reset(): void {
+        this.accumulatedToolCalls.clear();
+        this.toolCallIndexMap.clear();
+    }
+}
+

package/src/tools/tool-executor.ts

@@ -0,0 +1,174 @@
+import type { Command, ExecutionContext } from "@kispace-io/core";
+import { commandRegistry } from "@kispace-io/core";
+import type { ToolCall, ToolResult } from "../core/types";
+import { ToolCallAccumulator } from "./tool-call-accumulator";
+
+export class ToolExecutor {
+    private sanitizeFunctionName(name: string): string {
+        return name
+            .replace(/[^a-zA-Z0-9_-]/g, '_')
+            .replace(/^[^a-zA-Z]/, 'cmd_$&')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+
+    findCommand(toolCall: ToolCall, context: ExecutionContext): Command | null {
+        const sanitizedFunctionName = toolCall.function.name;
+        
+        // First try direct lookup (in case command ID matches sanitized name)
+        const directCommand = commandRegistry.getCommand(sanitizedFunctionName);
+        if (directCommand) {
+            return directCommand;
+        }
+        
+        // If not found, search through all commands to find one whose sanitized ID matches
+        const allCommands = commandRegistry.listCommands();
+        for (const [commandId, command] of Object.entries(allCommands)) {
+            const sanitizedId = this.sanitizeFunctionName(commandId);
+            if (sanitizedId === sanitizedFunctionName) {
+                return command;
+            }
+        }
+        
+        return null;
+    }
+
+    private parseArguments(argsStr: string): Record<string, any> {
+        if (!argsStr || argsStr.trim() === "" || argsStr === "{}") {
+            return {};
+        }
+        
+        try {
+            const parsed = JSON.parse(argsStr);
+            return parsed && typeof parsed === 'object' ? parsed : {};
+        } catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            console.error(`[ToolExecutor] Failed to parse arguments: ${argsStr} - ${errorMsg}`);
+            return {};
+        }
+    }
+
+    private sanitizeArguments(
+        args: Record<string, any>,
+        command: Command | null
+    ): Record<string, any> {
+        if (!command || !command.parameters || !args || typeof args !== 'object') {
+            return args || {};
+        }
+
+        const sanitizedArgs: Record<string, any> = {};
+        command.parameters.forEach(param => {
+            const sanitizedParamName = this.sanitizeFunctionName(param.name);
+            if (sanitizedParamName in args) {
+                sanitizedArgs[param.name] = args[sanitizedParamName];
+            }
+        });
+
+        return sanitizedArgs;
+    }
+
+    async executeToolCall(toolCall: ToolCall, context: ExecutionContext): Promise<ToolResult> {
+        try {
+            const command = this.findCommand(toolCall, context);
+            const commandId = command?.id || toolCall.function.name;
+            
+            const argsStr = toolCall.function.arguments || "{}";
+            const args = this.parseArguments(argsStr);
+            const sanitizedArgs = this.sanitizeArguments(args, command);
+            
+            const freshContext = commandRegistry.createExecutionContext(sanitizedArgs);
+            const execContext: ExecutionContext = {
+                ...context,
+                ...freshContext,
+                params: sanitizedArgs
+            };
+            
+            let commandResult = await commandRegistry.execute(commandId, execContext);
+            
+            const commandName = command?.name || commandId;
+            const resultMessage: any = {
+                success: true,
+                message: `Command "${commandName}" executed successfully`,
+                command: commandId
+            };
+            
+            if (sanitizedArgs && typeof sanitizedArgs === 'object' && Object.keys(sanitizedArgs).length > 0) {
+                resultMessage.parameters = sanitizedArgs;
+            }
+            
+            if (!!commandResult) {
+                let resolvedResult = commandResult;
+                if (resolvedResult instanceof Promise) {
+                    resolvedResult = await resolvedResult;
+                }
+                resultMessage.result = resolvedResult;
+                
+                if (command?.output && command.output.length > 0) {
+                    const outputDescriptions = command.output.map(v => `${v.name}: ${v.description || v.type || 'value'}`).join(', ');
+                    resultMessage.output = outputDescriptions;
+                }
+            }
+            
+            return {
+                id: toolCall.id,
+                result: resultMessage
+            };
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            let command: Command | null = null;
+            try {
+                command = this.findCommand(toolCall, context);
+            } catch {
+                command = null;
+            }
+            const commandName = command?.name || toolCall.function.name;
+            
+            let detailedError = errorMessage;
+            
+            if (errorMessage.includes('No handler found') || errorMessage.includes('No handlers registered')) {
+                detailedError = `Command "${commandName}" cannot be executed. ${errorMessage}. This usually means the command is not available in the current context (e.g., a map editor may not be open or active).`;
+            } else if (errorMessage.includes('not available') || errorMessage.includes('GsMapEditor')) {
+                detailedError = `Command "${commandName}" cannot be executed: ${errorMessage}. Please ensure the required editor or component is open and active.`;
+            }
+            
+            return {
+                id: toolCall.id,
+                result: null,
+                error: detailedError
+            };
+        }
+    }
+
+    async executeToolCalls(
+        toolCalls: ToolCall[],
+        context: ExecutionContext
+    ): Promise<ToolResult[]> {
+        const results: ToolResult[] = [];
+        for (const toolCall of toolCalls) {
+            const result = await this.executeToolCall(toolCall, context);
+            results.push(result);
+        }
+        return results;
+    }
+
+    createToolCallAccumulator(): ToolCallAccumulator {
+        return new ToolCallAccumulator();
+    }
+
+    createToolCallSignature(toolCall: ToolCall): string {
+        const argsStr = toolCall.function.arguments || "{}";
+        let args: any = {};
+        try {
+            const parsed = JSON.parse(argsStr);
+            args = parsed && typeof parsed === 'object' ? parsed : {};
+        } catch (e) {
+            args = {};
+        }
+        const sortedArgs = args && typeof args === 'object' ? Object.keys(args).sort().reduce((acc, key) => {
+            acc[key] = args[key];
+            return acc;
+        }, {} as any) : {};
+        return `${toolCall.function.name}:${JSON.stringify(sortedArgs)}`;
+    }
+}
+

package/src/tools/tool-registry.ts

@@ -0,0 +1,70 @@
+import type { Command, ExecutionContext } from "@kispace-io/core";
+import { commandRegistry } from "@kispace-io/core";
+import type { ToolDefinition } from "../core/types";
+
+export class ToolRegistry {
+    private sanitizeFunctionName(name: string): string {
+        return name
+            .replace(/[^a-zA-Z0-9_-]/g, '_')
+            .replace(/^[^a-zA-Z]/, 'cmd_$&')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+
+    commandToTool(command: Command, context: ExecutionContext): ToolDefinition {
+        const properties: Record<string, {
+            type: string;
+            description: string;
+            enum?: string[];
+        }> = {};
+        const required: string[] = [];
+        
+        command.parameters?.forEach(param => {
+            const sanitizedParamName = this.sanitizeFunctionName(param.name);
+            properties[sanitizedParamName] = {
+                type: param.type || "string",
+                description: param.description,
+                ...(param.allowedValues && { enum: param.allowedValues })
+            };
+            if (param.required === true) {
+                required.push(sanitizedParamName);
+            }
+        });
+        
+        const sanitizedFunctionName = this.sanitizeFunctionName(command.id);
+        
+        const toolDef: ToolDefinition = {
+            type: "function",
+            function: {
+                name: sanitizedFunctionName,
+                description: command.description || command.name,
+                parameters: {
+                    type: "object",
+                    properties,
+                    required
+                }
+            }
+        };
+        
+        return toolDef;
+    }
+
+    getAvailableTools(
+        context: ExecutionContext,
+        commandFilter?: (command: Command, context: ExecutionContext) => boolean
+    ): ToolDefinition[] {
+        // list all commands without context as tools might modify the state of the application when executed
+        // this increases token usage but allows for more precise tool selection and execution
+        const availableCommands = commandRegistry.listCommands();
+        let commandsArray = Object.values(availableCommands) as Command[];
+        
+        if (commandFilter) {
+            commandsArray = commandsArray.filter((cmd: Command) => 
+                commandFilter(cmd, context)
+            );
+        }
+        
+        return commandsArray.map((cmd: Command) => this.commandToTool(cmd, context));
+    }
+}
+

package/src/translation.ts

@@ -0,0 +1,3 @@
+import { i18n } from "@kispace-io/core";
+
+export const t = i18n('aisystem');

package/src/utils/token-estimator.ts

@@ -0,0 +1,87 @@
+import type { ApiMessage, ToolDefinition, ToolCall } from "../core/types";
+
+export class TokenEstimator {
+    private static readonly AVERAGE_CHARS_PER_TOKEN = 4;
+    private static readonly TOOL_DEFINITION_OVERHEAD = 50;
+    private static readonly MESSAGE_OVERHEAD = 4;
+
+    static estimateTokens(text: string): number {
+        if (!text || text.trim().length === 0) {
+            return 0;
+        }
+
+        const trimmed = text.trim();
+        const charCount = trimmed.length;
+        const wordCount = trimmed.split(/\s+/).filter(w => w.length > 0).length;
+
+        const tokenEstimate = Math.ceil(
+            charCount / this.AVERAGE_CHARS_PER_TOKEN + wordCount * 0.3
+        );
+
+        return Math.max(1, tokenEstimate);
+    }
+
+    static estimateMessageTokens(message: ApiMessage): number {
+        let tokens = this.MESSAGE_OVERHEAD;
+
+        if (message.content) {
+            tokens += this.estimateTokens(message.content);
+        }
+
+        if (message.role) {
+            tokens += this.estimateTokens(message.role);
+        }
+
+        if (message.tool_calls) {
+            for (const toolCall of message.tool_calls) {
+                tokens += this.estimateTokens(toolCall.function.name || '');
+                tokens += this.estimateTokens(toolCall.function.arguments || '{}');
+                tokens += 10;
+            }
+        }
+
+        if (message.tool_call_id) {
+            tokens += this.estimateTokens(message.tool_call_id);
+        }
+
+        return tokens;
+    }
+
+    static estimatePromptTokens(messages: ApiMessage[], tools?: ToolDefinition[]): number {
+        let totalTokens = 0;
+
+        for (const message of messages) {
+            totalTokens += this.estimateMessageTokens(message);
+        }
+
+        if (tools && tools.length > 0) {
+            for (const tool of tools) {
+                totalTokens += this.TOOL_DEFINITION_OVERHEAD;
+                totalTokens += this.estimateTokens(tool.function.name || '');
+                totalTokens += this.estimateTokens(tool.function.description || '');
+                
+                if (tool.function.parameters) {
+                    const paramsJson = JSON.stringify(tool.function.parameters);
+                    totalTokens += this.estimateTokens(paramsJson);
+                }
+            }
+        }
+
+        return totalTokens;
+    }
+
+    static estimateCompletionTokens(content: string, toolCalls?: ToolCall[]): number {
+        let tokens = this.estimateTokens(content);
+
+        if (toolCalls && toolCalls.length > 0) {
+            for (const toolCall of toolCalls) {
+                tokens += 10;
+                tokens += this.estimateTokens(toolCall.function?.name || '');
+                tokens += this.estimateTokens(toolCall.function?.arguments || '{}');
+            }
+        }
+
+        return tokens;
+    }
+}
+