@kkeve/suite 0.0.1 → 0.0.2

package/dist/llm/index.js

@@ -1,158 +0,0 @@
-"use strict";
-/**
- * LLM client with MacroTool support
- *
- * Key features:
- * - Direct fetch to OpenAI API (no LangChain dependency)
- * - Zod schema for tool definitions
- * - toolChoiceName support (force specific tool call)
- * - parallel_tool_calls: false (one tool per step)
- * - Retry with error classification
- * - Model-specific patches (Claude, Qwen, GPT, etc.)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LLM = exports.extractXMLTag = exports.parseXMLExtractionResponse = exports.InvokeErrorType = exports.InvokeError = void 0;
-exports.parseLLMConfig = parseLLMConfig;
-const OpenAIClient_1 = require("./OpenAIClient");
-const constants_1 = require("./constants");
-const errors_1 = require("./errors");
-Object.defineProperty(exports, "InvokeError", { enumerable: true, get: function () { return errors_1.InvokeError; } });
-Object.defineProperty(exports, "InvokeErrorType", { enumerable: true, get: function () { return errors_1.InvokeErrorType; } });
-const utils_1 = require("./utils");
-Object.defineProperty(exports, "parseXMLExtractionResponse", { enumerable: true, get: function () { return utils_1.parseXMLExtractionResponse; } });
-Object.defineProperty(exports, "extractXMLTag", { enumerable: true, get: function () { return utils_1.extractXMLTag; } });
-function parseLLMConfig(config) {
-    if (!config.baseURL || !config.model) {
-        throw new Error('[EVEAgent] LLM configuration required. Please provide: baseURL, model.');
-    }
-    return {
-        baseURL: config.baseURL,
-        model: config.model,
-        apiKey: config.apiKey || '',
-        temperature: config.temperature ?? constants_1.DEFAULT_TEMPERATURE,
-        maxRetries: config.maxRetries ?? constants_1.LLM_MAX_RETRIES,
-        disableNamedToolChoice: config.disableNamedToolChoice ?? false,
-        customFetch: (config.customFetch ?? fetch).bind(globalThis),
-    };
-}
-class LLM extends EventTarget {
-    config;
-    client;
-    constructor(config) {
-        super();
-        this.config = parseLLMConfig(config);
-        this.client = new OpenAIClient_1.OpenAIClient(this.config);
-    }
-    /**
-     * Call LLM API once, invoke tool call once, return the result.
-     * This is the core method used by gui-agent's MacroTool loop.
-     */
-    async invoke(messages, tools, abortSignal, options) {
-        const signal = abortSignal || new AbortController().signal;
-        return await withRetry(async () => {
-            if (signal.aborted)
-                throw new Error('AbortError');
-            return await this.client.invoke(messages, tools, signal, options);
-        }, {
-            maxRetries: this.config.maxRetries,
-            onRetry: (attempt) => {
-                this.dispatchEvent(new CustomEvent('retry', { detail: { attempt, maxAttempts: this.config.maxRetries } }));
-            },
-            onError: (error) => {
-                this.dispatchEvent(new CustomEvent('error', { detail: { error } }));
-            },
-        });
-    }
-    /**
-     * Simple chat call — no tools, just text generation.
-     * Used for validation and other non-tool-call LLM tasks.
-     */
-    async chat(messages, abortSignal) {
-        const requestBody = {
-            model: this.config.model,
-            temperature: this.config.temperature,
-            messages,
-        };
-        (0, utils_1.modelPatch)(requestBody);
-        const response = await this.config.customFetch(`${this.config.baseURL}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...(this.config.apiKey && { Authorization: `Bearer ${this.config.apiKey}` }),
-            },
-            body: JSON.stringify(requestBody),
-            signal: abortSignal,
-        });
-        if (!response.ok) {
-            const errorData = await response.json().catch(() => ({}));
-            throw new Error(`LLM chat failed: HTTP ${response.status} - ${errorData.error?.message || response.statusText}`);
-        }
-        const data = await response.json();
-        const content = data.choices?.[0]?.message?.content || '';
-        return {
-            content,
-            usage: {
-                prompt_tokens: data.usage?.prompt_tokens ?? 0,
-                completion_tokens: data.usage?.completion_tokens ?? 0,
-                total_tokens: data.usage?.total_tokens ?? 0,
-            },
-        };
-    }
-    /**
-     * Agent loop chat — call LLM with tools and return the full assistant message.
-     * Unlike invoke(), this does NOT execute tools. The agent loop handles tool
-     * execution via its own ToolRegistry after getting the response.
-     *
-     * Uses tool_choice: 'auto' by default (LLM can choose text or tool_calls).
-     * Includes retry logic with exponential backoff.
-     */
-    async chatWithTools(messages, tools, abortSignal, options) {
-        const signal = abortSignal || new AbortController().signal;
-        return await withRetry(async () => {
-            if (signal.aborted)
-                throw new Error('AbortError');
-            return await this.client.chat(messages, tools, signal, options);
-        }, {
-            maxRetries: this.config.maxRetries,
-            onRetry: (attempt) => {
-                this.dispatchEvent(new CustomEvent('retry', { detail: { attempt, maxAttempts: this.config.maxRetries } }));
-            },
-            onError: (error) => {
-                this.dispatchEvent(new CustomEvent('error', { detail: { error } }));
-            },
-        });
-    }
-}
-exports.LLM = LLM;
-async function withRetry(fn, settings) {
-    let attempt = 0;
-    let lastError = null;
-    while (attempt <= settings.maxRetries) {
-        if (attempt > 0) {
-            settings.onRetry(attempt);
-            // Exponential backoff: 1s, 2s, 4s, 8s...
-            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 30000);
-            console.log(`[Retry] Attempt ${attempt}/${settings.maxRetries}, waiting ${delay}ms...`);
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-        try {
-            return await fn();
-        }
-        catch (error) {
-            if (error?.rawError?.name === 'AbortError')
-                throw error;
-            settings.onError(error);
-            if (error instanceof errors_1.InvokeError && !error.retryable)
-                throw error;
-            // Rate limit (429): use longer backoff
-            if (error instanceof errors_1.InvokeError && error.type === 'rate_limit') {
-                const rateLimitDelay = Math.min(5000 * attempt + 5000, 60000); // 5s, 10s, 15s...
-                console.log(`[Retry] Rate limit hit, waiting ${rateLimitDelay}ms...`);
-                await new Promise((resolve) => setTimeout(resolve, rateLimitDelay));
-            }
-            lastError = error;
-            attempt++;
-        }
-    }
-    throw lastError;
-}

package/dist/llm/types.d.ts

@@ -1,124 +0,0 @@
-/**
- * Core types for LLM integration
- */
-import type * as z from 'zod/v4';
-/**
- * Content item for multimodal messages
- */
-export type ContentItem = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'image_url';
-    image_url: {
-        url: string;
-        detail?: 'low' | 'high' | 'auto';
-    };
-};
-/**
- * Message format - OpenAI standard
- */
-export interface Message {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content?: string | ContentItem[] | null;
-    tool_calls?: {
-        id: string;
-        type: 'function';
-        function: {
-            name: string;
-            arguments: string;
-        };
-    }[];
-    tool_call_id?: string;
-    name?: string;
-}
-/**
- * Tool definition - uses Zod schema
- * Optional customJsonSchema: If provided, this JSON Schema is sent to the LLM
- * instead of converting inputSchema via zodToOpenAITool.
- * This allows detailed tool parameter descriptions while keeping zod validation loose.
- */
-export interface Tool<TParams = any, TResult = any> {
-    description?: string;
-    inputSchema: z.ZodType<TParams>;
-    execute: (args: TParams) => Promise<TResult>;
-    /** Custom JSON Schema sent to LLM (overrides zodToOpenAITool conversion) */
-    customJsonSchema?: Record<string, any>;
-}
-/**
- * Invoke options for LLM call
- */
-export interface InvokeOptions {
-    /**
-     * Force LLM to call a specific tool by name.
-     * If provided: tool_choice = { type: 'function', function: { name: toolChoiceName } }
-     * If not provided: tool_choice = 'required'
-     */
-    toolChoiceName?: string;
-    /**
-     * Response normalization function.
-     */
-    normalizeResponse?: (response: any) => any;
-}
-/**
- * Invoke result
- */
-export interface InvokeResult<TResult = unknown> {
-    toolCall: {
-        name: string;
-        args: any;
-    };
-    toolResult: TResult;
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-        cachedTokens?: number;
-        reasoningTokens?: number;
-    };
-    rawResponse?: unknown;
-    rawRequest?: unknown;
-}
-/**
- * Chat result — returns the full assistant message without executing tools.
- * Used by the agent loop to get the LLM's response and then process tool_calls separately.
- */
-export interface ChatResult {
-    /** The full assistant message from the LLM response. */
-    message: Message;
-    /** Token usage information. */
-    usage: {
-        promptTokens: number;
-        completionTokens: number;
-        totalTokens: number;
-        cachedTokens?: number;
-        reasoningTokens?: number;
-    };
-    /** The raw API response data. */
-    rawResponse?: unknown;
-}
-/**
- * LLM Client interface
- */
-export interface LLMClient {
-    invoke(messages: Message[], tools: Record<string, Tool>, abortSignal?: AbortSignal, options?: InvokeOptions): Promise<InvokeResult>;
-    /**
-     * Call the LLM and return the full assistant message.
-     * Unlike invoke(), this does NOT execute any tools — it just returns
-     * the raw response. The caller (agent loop) processes tool_calls and
-     * executes tools separately via its own ToolRegistry.
-     */
-    chat(messages: Message[], tools: Record<string, Tool>, abortSignal?: AbortSignal, options?: InvokeOptions): Promise<ChatResult>;
-}
-/**
- * LLM configuration
- */
-export interface LLMConfig {
-    baseURL: string;
-    model: string;
-    apiKey?: string;
-    temperature?: number;
-    maxRetries?: number;
-    disableNamedToolChoice?: boolean;
-    customFetch?: typeof globalThis.fetch;
-}

package/dist/llm/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/llm/utils.d.ts

@@ -1,29 +0,0 @@
-import * as z from 'zod/v4';
-import type { Tool } from './types';
-/**
- * Convert Zod schema to OpenAI tool format
- */
-export declare function zodToOpenAITool(name: string, tool: Tool): {
-    type: "function";
-    function: {
-        name: string;
-        description: string | undefined;
-        parameters: z.core.ZodStandardJSONSchemaPayload<z.ZodType<any, unknown, z.core.$ZodTypeInternals<any, unknown>>>;
-    };
-};
-/**
- * Patch model specific parameters
- */
-export declare function modelPatch(body: Record<string, any>): Record<string, any>;
-/**
- * Parse XML response from LLM and convert to AIDataExtractionResponse
- */
-export declare function parseXMLExtractionResponse<T>(xmlString: string): any;
-export declare function safeParseJson(input: string, modelFamily: any | undefined): any;
-/**
- * Extract content from an XML tag in a string
- * @param xmlString - The XML string to parse
- * @param tagName - The name of the tag to extract (case-insensitive)
- * @returns The trimmed content of the tag, or undefined if not found
- */
-export declare function extractXMLTag(xmlString: string, tagName: string): string | undefined;

package/dist/llm/utils.js

@@ -1,284 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.zodToOpenAITool = zodToOpenAITool;
-exports.modelPatch = modelPatch;
-exports.parseXMLExtractionResponse = parseXMLExtractionResponse;
-exports.safeParseJson = safeParseJson;
-exports.extractXMLTag = extractXMLTag;
-/**
- * Utility functions for LLM integration
- */
-const jsonrepair_1 = require("jsonrepair");
-const z = __importStar(require("zod/v4"));
-/**
- * Convert Zod schema to OpenAI tool format
- */
-function zodToOpenAITool(name, tool) {
-    return {
-        type: 'function',
-        function: {
-            name,
-            description: tool.description,
-            parameters: z.toJSONSchema(tool.inputSchema, { target: 'openapi-3.0' }),
-        },
-    };
-}
-/**
- * Patch model specific parameters
- */
-function modelPatch(body) {
-    const model = body.model || '';
-    if (!model)
-        return body;
-    const modelName = normalizeModelName(model);
-    if (modelName.startsWith('qwen') || modelName.startsWith('app-')) {
-        body.temperature = Math.max(body.temperature || 0, 1.0);
-        body.enable_thinking = false;
-    }
-    if (modelName.startsWith('claude')) {
-        body.thinking = { type: 'disabled' };
-        if (body.tool_choice === 'required') {
-            body.tool_choice = { type: 'any' };
-        }
-        else if (body.tool_choice?.function?.name) {
-            body.tool_choice = { type: 'tool', name: body.tool_choice.function.name };
-        }
-    }
-    if (modelName.startsWith('grok')) {
-        delete body.tool_choice;
-        body.thinking = { type: 'disabled', effort: 'minimal' };
-        body.reasoning = { enabled: false, effort: 'low' };
-    }
-    if (modelName.startsWith('gpt')) {
-        if (modelName.startsWith('gpt-52')) {
-            body.reasoning_effort = 'none';
-        }
-        else if (modelName.startsWith('gpt-51')) {
-            body.reasoning_effort = 'none';
-        }
-        else if (modelName.startsWith('gpt-54')) {
-            delete body.reasoning_effort;
-        }
-        else if (modelName.startsWith('gpt-5-mini')) {
-            body.reasoning_effort = 'low';
-            body.temperature = 1;
-        }
-        else if (modelName.startsWith('gpt-5')) {
-            body.reasoning_effort = 'low';
-        }
-    }
-    if (modelName.startsWith('gemini')) {
-        body.reasoning_effort = 'minimal';
-    }
-    if (modelName.startsWith('minimax')) {
-        body.temperature = Math.max(body.temperature || 0, 0.01);
-        if (body.temperature > 1)
-            body.temperature = 1;
-        delete body.parallel_tool_calls;
-    }
-    return body;
-}
-function normalizeModelName(modelName) {
-    let normalizedName = modelName.toLowerCase();
-    if (normalizedName.includes('/')) {
-        normalizedName = normalizedName.split('/')[1];
-    }
-    normalizedName = normalizedName.replace(/_/g, '');
-    normalizedName = normalizedName.replace(/\./g, '');
-    return normalizedName;
-}
-/**
- * Parse XML response from LLM and convert to AIDataExtractionResponse
- */
-function parseXMLExtractionResponse(xmlString) {
-    const thought = extractXMLTag(xmlString, 'thought');
-    const dataJsonStr = extractXMLTag(xmlString, 'data-json');
-    const errorsStr = extractXMLTag(xmlString, 'errors');
-    let data = '';
-    if (dataJsonStr) {
-        try {
-            data = safeParseJson(dataJsonStr, undefined);
-        }
-        catch (e) {
-            throw new Error(`Failed to parse data-json: ${e}`);
-        }
-    }
-    // Parse errors (optional)
-    let errors;
-    if (errorsStr) {
-        try {
-            const parsedErrors = safeParseJson(errorsStr, undefined);
-            if (Array.isArray(parsedErrors)) {
-                errors = parsedErrors;
-            }
-        }
-        catch (e) {
-            // If errors parsing fails, just ignore it
-        }
-    }
-    return {
-        ...(thought ? { thought } : {}),
-        data: data || xmlString,
-        ...(errors && errors.length > 0 ? { errors } : {}),
-    };
-}
-function safeParseJson(input, modelFamily) {
-    const cleanJsonString = extractJSONFromCodeBlock(input);
-    // match the point
-    if (cleanJsonString?.match(/\((\d+),(\d+)\)/)) {
-        return cleanJsonString
-            .match(/\((\d+),(\d+)\)/)
-            ?.slice(1)
-            .map(Number);
-    }
-    let parsed;
-    let lastError;
-    try {
-        parsed = JSON.parse(cleanJsonString);
-        return normalizeJsonObject(parsed);
-    }
-    catch (error) {
-        lastError = error;
-    }
-    try {
-        parsed = JSON.parse((0, jsonrepair_1.jsonrepair)(cleanJsonString));
-        return normalizeJsonObject(parsed);
-    }
-    catch (error) {
-        lastError = error;
-    }
-    if (modelFamily === 'doubao-vision' || isUITars(modelFamily)) {
-        const jsonString = preprocessDoubaoBboxJson(cleanJsonString);
-        try {
-            parsed = JSON.parse((0, jsonrepair_1.jsonrepair)(jsonString));
-            return normalizeJsonObject(parsed);
-        }
-        catch (error) {
-            lastError = error;
-        }
-    }
-    throw Error(`failed to parse LLM response into JSON. Error - ${String(lastError ?? 'unknown error')}. Response - \n ${input}`);
-}
-/**
- * Extract content from an XML tag in a string
- * @param xmlString - The XML string to parse
- * @param tagName - The name of the tag to extract (case-insensitive)
- * @returns The trimmed content of the tag, or undefined if not found
- */
-function extractXMLTag(xmlString, tagName) {
-    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, 'i');
-    const match = xmlString.match(regex);
-    return match ? match[1].trim() : undefined;
-}
-function extractJSONFromCodeBlock(response) {
-    try {
-        // First, try to match a JSON object directly in the response
-        const jsonMatch = response.match(/^\s*(\{[\s\S]*\})\s*$/);
-        if (jsonMatch) {
-            return jsonMatch[1];
-        }
-        // If no direct JSON object is found, try to extract JSON from a code block
-        const codeBlockMatch = response.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
-        if (codeBlockMatch) {
-            return codeBlockMatch[1];
-        }
-        // If no code block is found, try to find a JSON-like structure in the text
-        const jsonLikeMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonLikeMatch) {
-            return jsonLikeMatch[0];
-        }
-    }
-    catch { }
-    // If no JSON-like structure is found, return the original response
-    return response;
-}
-/**
- * Normalize a parsed JSON object by trimming whitespace from:
- * 1. All object keys (e.g., " prompt " -> "prompt")
- * 2. All string values (e.g., " Tap " -> "Tap")
- * This handles LLM output that may include leading/trailing spaces.
- */
-function normalizeJsonObject(obj) {
-    // Handle null and undefined
-    if (obj === null || obj === undefined) {
-        return obj;
-    }
-    // Handle arrays - recursively normalize each element
-    if (Array.isArray(obj)) {
-        return obj.map((item) => normalizeJsonObject(item));
-    }
-    // Handle objects
-    if (typeof obj === 'object') {
-        const normalized = {};
-        for (const [key, value] of Object.entries(obj)) {
-            // Trim the key to remove leading/trailing spaces
-            const trimmedKey = key.trim();
-            // Recursively normalize the value
-            let normalizedValue = normalizeJsonObject(value);
-            // Trim all string values
-            if (typeof normalizedValue === 'string') {
-                normalizedValue = normalizedValue.trim();
-            }
-            normalized[trimmedKey] = normalizedValue;
-        }
-        return normalized;
-    }
-    // Handle primitive strings
-    if (typeof obj === 'string') {
-        return obj.trim();
-    }
-    // Return other primitives as-is
-    return obj;
-}
-function preprocessDoubaoBboxJson(input) {
-    if (input.includes('bbox')) {
-        // when its values like 940 445 969 490, replace all /\d+\s+\d+/g with /$1,$2/g
-        while (/\d+\s+\d+/.test(input)) {
-            input = input.replace(/(\d+)\s+(\d+)/g, '$1,$2');
-        }
-    }
-    return input;
-}
-/**
- * Check if the modelFamily is a UI-TARS variant
- * @param modelFamily The model family to check
- * @returns true if modelFamily is any UI-TARS variant
- */
-function isUITars(modelFamily) {
-    return (modelFamily === 'vlm-ui-tars' ||
-        modelFamily === 'vlm-ui-tars-doubao' ||
-        modelFamily === 'vlm-ui-tars-doubao-1.5');
-}

package/dist/skill/frontmatter-parser.d.ts

@@ -1,50 +0,0 @@
-/**
- * SKILL.md Frontmatter Parser
- *
- * Reference: gemini-cli skillLoader.ts (skills/skillLoader.ts L34-110)
- * Parses YAML frontmatter from SKILL.md files to extract name, description,
- * and allowed-tools. Uses the 'yaml' npm package for robust YAML parsing,
- * with a fallback simple parser for malformed YAML (e.g. descriptions with colons).
- */
-/**
- * Regex for extracting frontmatter from markdown files.
- * Matches ---\n<yaml content>\n--- at the start of the file.
- */
-export declare const FRONTMATTER_REGEX: RegExp;
-/**
- * Parsed frontmatter result.
- */
-export interface ParsedFrontmatter {
-    name: string;
-    description: string;
-    /** Allowed tools for this skill (from frontmatter 'allowed-tools' field). */
-    allowedTools?: string[];
-    /** Output artifact type for Pipeline routing (e.g. 'code_knowledge', 'case_list'). */
-    outputType?: string;
-    /** The body content after the closing ---. */
-    body: string;
-}
-/**
- * Parse frontmatter from a SKILL.md file string.
- *
- * Returns the name, description, allowedTools from the YAML frontmatter,
- * and the body (content after the frontmatter).
- *
- * @param content The full SKILL.md file content
- * @returns Parsed frontmatter and body, or null if no valid frontmatter found
- */
-export declare function parseSkillFrontmatter(content: string): ParsedFrontmatter | null;
-/**
- * Parse YAML frontmatter content using the yaml library
- * with a fallback to simple key-value parsing.
- *
- * Reference: gemini-cli skillLoader.ts parseFrontmatter (L41-61)
- *
- * Uses YAML.parse() (yaml v2 API) instead of the deprecated YAML.load().
- */
-export declare function parseFrontmatterYaml(yamlContent: string): {
-    name: string;
-    description: string;
-    allowedTools?: string[];
-    outputType?: string;
-} | null;