cognitive-modules 0.6.0

package/dist/providers/anthropic.js

@@ -0,0 +1,70 @@
+/**
+ * Anthropic Provider - Claude API
+ */
+import { BaseProvider } from './base.js';
+export class AnthropicProvider extends BaseProvider {
+    name = 'anthropic';
+    apiKey;
+    model;
+    baseUrl = 'https://api.anthropic.com/v1';
+    constructor(apiKey, model = 'claude-sonnet-4-5-20250929') {
+        super();
+        this.apiKey = apiKey || process.env.ANTHROPIC_API_KEY || '';
+        this.model = model;
+    }
+    isConfigured() {
+        return !!this.apiKey;
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Anthropic API key not configured. Set ANTHROPIC_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/messages`;
+        // Extract system message
+        const systemMessage = params.messages.find(m => m.role === 'system');
+        const otherMessages = params.messages.filter(m => m.role !== 'system');
+        // Add JSON schema instruction if provided
+        let messages = otherMessages;
+        if (params.jsonSchema) {
+            const lastUserIdx = messages.findLastIndex(m => m.role === 'user');
+            if (lastUserIdx >= 0) {
+                messages = [...messages];
+                messages[lastUserIdx] = {
+                    ...messages[lastUserIdx],
+                    content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
+                };
+            }
+        }
+        const body = {
+            model: this.model,
+            messages: messages.map(m => ({ role: m.role, content: m.content })),
+            max_tokens: params.maxTokens ?? 4096,
+        };
+        if (systemMessage) {
+            body.system = systemMessage.content;
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': this.apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.content?.[0]?.text || '';
+        return {
+            content,
+            usage: data.usage ? {
+                promptTokens: data.usage.input_tokens || 0,
+                completionTokens: data.usage.output_tokens || 0,
+                totalTokens: (data.usage.input_tokens || 0) + (data.usage.output_tokens || 0),
+            } : undefined,
+        };
+    }
+}

package/dist/providers/base.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Base Provider - Abstract class for all LLM providers
+ */
+import type { Provider, InvokeParams, InvokeResult } from '../types.js';
+export declare abstract class BaseProvider implements Provider {
+    abstract name: string;
+    abstract invoke(params: InvokeParams): Promise<InvokeResult>;
+    abstract isConfigured(): boolean;
+    protected buildJsonPrompt(schema: object): string;
+    protected parseJsonResponse(content: string): unknown;
+}

package/dist/providers/base.js

@@ -0,0 +1,19 @@
+/**
+ * Base Provider - Abstract class for all LLM providers
+ */
+export class BaseProvider {
+    buildJsonPrompt(schema) {
+        return `\n\nYou MUST respond with valid JSON matching this schema:\n${JSON.stringify(schema, null, 2)}\n\nRespond with ONLY the JSON, no markdown code blocks.`;
+    }
+    parseJsonResponse(content) {
+        // Try to extract JSON from markdown code blocks
+        const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+        const jsonStr = jsonMatch ? jsonMatch[1] : content;
+        try {
+            return JSON.parse(jsonStr.trim());
+        }
+        catch {
+            throw new Error(`Failed to parse JSON response: ${content.substring(0, 200)}`);
+        }
+    }
+}

package/dist/providers/deepseek.d.ts

@@ -0,0 +1,14 @@
+/**
+ * DeepSeek Provider - DeepSeek API
+ */
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class DeepSeekProvider extends BaseProvider {
+    name: string;
+    private apiKey;
+    private model;
+    private baseUrl;
+    constructor(apiKey?: string, model?: string);
+    isConfigured(): boolean;
+    invoke(params: InvokeParams): Promise<InvokeResult>;
+}

package/dist/providers/deepseek.js

@@ -0,0 +1,66 @@
+/**
+ * DeepSeek Provider - DeepSeek API
+ */
+import { BaseProvider } from './base.js';
+export class DeepSeekProvider extends BaseProvider {
+    name = 'deepseek';
+    apiKey;
+    model;
+    baseUrl = 'https://api.deepseek.com/v1';
+    constructor(apiKey, model = 'deepseek-chat') {
+        // deepseek-chat 自动映射到最新的 DeepSeek-V3.2
+        super();
+        this.apiKey = apiKey || process.env.DEEPSEEK_API_KEY || '';
+        this.model = model;
+    }
+    isConfigured() {
+        return !!this.apiKey;
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('DeepSeek API key not configured. Set DEEPSEEK_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/chat/completions`;
+        const body = {
+            model: this.model,
+            messages: params.messages.map(m => ({ role: m.role, content: m.content })),
+            temperature: params.temperature ?? 0.7,
+            max_tokens: params.maxTokens ?? 4096,
+        };
+        // Add JSON mode if schema provided
+        if (params.jsonSchema) {
+            body.response_format = { type: 'json_object' };
+            const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
+            if (lastUserIdx >= 0) {
+                const messages = [...params.messages];
+                messages[lastUserIdx] = {
+                    ...messages[lastUserIdx],
+                    content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
+                };
+                body.messages = messages.map(m => ({ role: m.role, content: m.content }));
+            }
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`DeepSeek API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content || '';
+        return {
+            content,
+            usage: data.usage ? {
+                promptTokens: data.usage.prompt_tokens || 0,
+                completionTokens: data.usage.completion_tokens || 0,
+                totalTokens: data.usage.total_tokens || 0,
+            } : undefined,
+        };
+    }
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Gemini Provider - Google Gemini API
+ */
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class GeminiProvider extends BaseProvider {
+    name: string;
+    private apiKey;
+    private model;
+    private baseUrl;
+    constructor(apiKey?: string, model?: string);
+    isConfigured(): boolean;
+    /**
+     * Clean JSON Schema for Gemini API compatibility
+     * Removes unsupported fields like additionalProperties
+     */
+    private cleanSchemaForGemini;
+    invoke(params: InvokeParams): Promise<InvokeResult>;
+}

package/dist/providers/gemini.js

@@ -0,0 +1,94 @@
+/**
+ * Gemini Provider - Google Gemini API
+ */
+import { BaseProvider } from './base.js';
+export class GeminiProvider extends BaseProvider {
+    name = 'gemini';
+    apiKey;
+    model;
+    baseUrl = 'https://generativelanguage.googleapis.com/v1beta';
+    constructor(apiKey, model = 'gemini-3-flash') {
+        super();
+        this.apiKey = apiKey || process.env.GEMINI_API_KEY || '';
+        this.model = model;
+    }
+    isConfigured() {
+        return !!this.apiKey;
+    }
+    /**
+     * Clean JSON Schema for Gemini API compatibility
+     * Removes unsupported fields like additionalProperties
+     */
+    cleanSchemaForGemini(schema) {
+        const unsupportedFields = ['additionalProperties', '$schema', 'default', 'examples'];
+        const clean = (obj) => {
+            if (Array.isArray(obj)) {
+                return obj.map(clean);
+            }
+            if (obj && typeof obj === 'object') {
+                const result = {};
+                for (const [key, value] of Object.entries(obj)) {
+                    if (!unsupportedFields.includes(key)) {
+                        result[key] = clean(value);
+                    }
+                }
+                return result;
+            }
+            return obj;
+        };
+        return clean(schema);
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Gemini API key not configured. Set GEMINI_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/models/${this.model}:generateContent?key=${this.apiKey}`;
+        // Convert messages to Gemini format
+        const contents = params.messages
+            .filter(m => m.role !== 'system')
+            .map(m => ({
+            role: m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }]
+        }));
+        // Add system instruction if present
+        const systemMessage = params.messages.find(m => m.role === 'system');
+        const body = {
+            contents,
+            generationConfig: {
+                temperature: params.temperature ?? 0.7,
+                maxOutputTokens: params.maxTokens ?? 8192,
+            }
+        };
+        if (systemMessage) {
+            body.systemInstruction = { parts: [{ text: systemMessage.content }] };
+        }
+        // Add JSON schema constraint if provided
+        if (params.jsonSchema) {
+            const cleanedSchema = this.cleanSchemaForGemini(params.jsonSchema);
+            body.generationConfig = {
+                ...body.generationConfig,
+                responseMimeType: 'application/json',
+                responseSchema: cleanedSchema,
+            };
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Gemini API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+        return {
+            content,
+            usage: data.usageMetadata ? {
+                promptTokens: data.usageMetadata.promptTokenCount || 0,
+                completionTokens: data.usageMetadata.candidatesTokenCount || 0,
+                totalTokens: data.usageMetadata.totalTokenCount || 0,
+            } : undefined,
+        };
+    }
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Provider Registry
+ */
+import type { Provider } from '../types.js';
+export { BaseProvider } from './base.js';
+export { GeminiProvider } from './gemini.js';
+export { OpenAIProvider } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';
+export { MiniMaxProvider } from './minimax.js';
+export { DeepSeekProvider } from './deepseek.js';
+export { MoonshotProvider } from './moonshot.js';
+export { QwenProvider } from './qwen.js';
+export { OllamaProvider } from './ollama.js';
+export declare function getProvider(name?: string, model?: string): Provider;
+export declare function listProviders(): Array<{
+    name: string;
+    configured: boolean;
+    model: string;
+}>;

package/dist/providers/index.js

@@ -0,0 +1,74 @@
+/**
+ * Provider Registry
+ */
+import { GeminiProvider } from './gemini.js';
+import { OpenAIProvider } from './openai.js';
+import { AnthropicProvider } from './anthropic.js';
+import { MiniMaxProvider } from './minimax.js';
+import { DeepSeekProvider } from './deepseek.js';
+import { MoonshotProvider } from './moonshot.js';
+import { QwenProvider } from './qwen.js';
+import { OllamaProvider } from './ollama.js';
+export { BaseProvider } from './base.js';
+export { GeminiProvider } from './gemini.js';
+export { OpenAIProvider } from './openai.js';
+export { AnthropicProvider } from './anthropic.js';
+export { MiniMaxProvider } from './minimax.js';
+export { DeepSeekProvider } from './deepseek.js';
+export { MoonshotProvider } from './moonshot.js';
+export { QwenProvider } from './qwen.js';
+export { OllamaProvider } from './ollama.js';
+const providers = {
+    gemini: (model) => new GeminiProvider(undefined, model),
+    openai: (model) => new OpenAIProvider(undefined, model),
+    anthropic: (model) => new AnthropicProvider(undefined, model),
+    minimax: (model) => new MiniMaxProvider(undefined, model),
+    deepseek: (model) => new DeepSeekProvider(undefined, model),
+    moonshot: (model) => new MoonshotProvider(undefined, model),
+    kimi: (model) => new MoonshotProvider(undefined, model), // Alias
+    qwen: (model) => new QwenProvider(undefined, model),
+    tongyi: (model) => new QwenProvider(undefined, model), // Alias
+    dashscope: (model) => new QwenProvider(undefined, model), // Alias
+    ollama: (model) => new OllamaProvider(model),
+    local: (model) => new OllamaProvider(model), // Alias
+};
+export function getProvider(name, model) {
+    // Check for model override from environment
+    const modelOverride = model || process.env.COG_MODEL;
+    // Auto-detect if not specified
+    if (!name) {
+        if (process.env.GEMINI_API_KEY)
+            return new GeminiProvider(undefined, modelOverride);
+        if (process.env.OPENAI_API_KEY)
+            return new OpenAIProvider(undefined, modelOverride);
+        if (process.env.ANTHROPIC_API_KEY)
+            return new AnthropicProvider(undefined, modelOverride);
+        if (process.env.DEEPSEEK_API_KEY)
+            return new DeepSeekProvider(undefined, modelOverride);
+        if (process.env.MINIMAX_API_KEY)
+            return new MiniMaxProvider(undefined, modelOverride);
+        if (process.env.MOONSHOT_API_KEY)
+            return new MoonshotProvider(undefined, modelOverride);
+        if (process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY)
+            return new QwenProvider(undefined, modelOverride);
+        // Ollama is always available as fallback if nothing else is configured
+        return new OllamaProvider(modelOverride);
+    }
+    const factory = providers[name.toLowerCase()];
+    if (!factory) {
+        throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(providers).join(', ')}`);
+    }
+    return factory(modelOverride);
+}
+export function listProviders() {
+    return [
+        { name: 'gemini', configured: !!process.env.GEMINI_API_KEY, model: 'gemini-3-flash' },
+        { name: 'openai', configured: !!process.env.OPENAI_API_KEY, model: 'gpt-5.2' },
+        { name: 'anthropic', configured: !!process.env.ANTHROPIC_API_KEY, model: 'claude-sonnet-4.5' },
+        { name: 'deepseek', configured: !!process.env.DEEPSEEK_API_KEY, model: 'deepseek-v3.2' },
+        { name: 'minimax', configured: !!process.env.MINIMAX_API_KEY, model: 'MiniMax-M2.1' },
+        { name: 'moonshot', configured: !!process.env.MOONSHOT_API_KEY, model: 'kimi-k2.5' },
+        { name: 'qwen', configured: !!(process.env.DASHSCOPE_API_KEY || process.env.QWEN_API_KEY), model: 'qwen3-max' },
+        { name: 'ollama', configured: true, model: 'llama4 (local)' },
+    ];
+}

package/dist/providers/minimax.d.ts

@@ -0,0 +1,14 @@
+/**
+ * MiniMax Provider - MiniMax API
+ */
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class MiniMaxProvider extends BaseProvider {
+    name: string;
+    private apiKey;
+    private model;
+    private baseUrl;
+    constructor(apiKey?: string, model?: string);
+    isConfigured(): boolean;
+    invoke(params: InvokeParams): Promise<InvokeResult>;
+}

package/dist/providers/minimax.js

@@ -0,0 +1,64 @@
+/**
+ * MiniMax Provider - MiniMax API
+ */
+import { BaseProvider } from './base.js';
+export class MiniMaxProvider extends BaseProvider {
+    name = 'minimax';
+    apiKey;
+    model;
+    baseUrl = 'https://api.minimax.chat/v1';
+    constructor(apiKey, model = 'MiniMax-M2.1') {
+        super();
+        this.apiKey = apiKey || process.env.MINIMAX_API_KEY || '';
+        this.model = model;
+    }
+    isConfigured() {
+        return !!this.apiKey;
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('MiniMax API key not configured. Set MINIMAX_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/text/chatcompletion_v2`;
+        const body = {
+            model: this.model,
+            messages: params.messages.map(m => ({ role: m.role, content: m.content })),
+            temperature: params.temperature ?? 0.7,
+            max_tokens: params.maxTokens ?? 4096,
+        };
+        // Add JSON mode if schema provided
+        if (params.jsonSchema) {
+            const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
+            if (lastUserIdx >= 0) {
+                const messages = [...params.messages];
+                messages[lastUserIdx] = {
+                    ...messages[lastUserIdx],
+                    content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
+                };
+                body.messages = messages.map(m => ({ role: m.role, content: m.content }));
+            }
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`MiniMax API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content || '';
+        return {
+            content,
+            usage: data.usage ? {
+                promptTokens: data.usage.prompt_tokens || 0,
+                completionTokens: data.usage.completion_tokens || 0,
+                totalTokens: data.usage.total_tokens || 0,
+            } : undefined,
+        };
+    }
+}

package/dist/providers/moonshot.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Moonshot Provider - Moonshot AI (Kimi) API
+ */
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class MoonshotProvider extends BaseProvider {
+    name: string;
+    private apiKey;
+    private model;
+    private baseUrl;
+    constructor(apiKey?: string, model?: string);
+    isConfigured(): boolean;
+    invoke(params: InvokeParams): Promise<InvokeResult>;
+}

package/dist/providers/moonshot.js

@@ -0,0 +1,65 @@
+/**
+ * Moonshot Provider - Moonshot AI (Kimi) API
+ */
+import { BaseProvider } from './base.js';
+export class MoonshotProvider extends BaseProvider {
+    name = 'moonshot';
+    apiKey;
+    model;
+    baseUrl = 'https://api.moonshot.cn/v1';
+    constructor(apiKey, model = 'kimi-k2.5') {
+        super();
+        this.apiKey = apiKey || process.env.MOONSHOT_API_KEY || '';
+        this.model = model;
+    }
+    isConfigured() {
+        return !!this.apiKey;
+    }
+    async invoke(params) {
+        if (!this.isConfigured()) {
+            throw new Error('Moonshot API key not configured. Set MOONSHOT_API_KEY environment variable.');
+        }
+        const url = `${this.baseUrl}/chat/completions`;
+        const body = {
+            model: this.model,
+            messages: params.messages.map(m => ({ role: m.role, content: m.content })),
+            temperature: params.temperature ?? 0.7,
+            max_tokens: params.maxTokens ?? 4096,
+        };
+        // Add JSON mode if schema provided
+        if (params.jsonSchema) {
+            body.response_format = { type: 'json_object' };
+            const lastUserIdx = params.messages.findLastIndex(m => m.role === 'user');
+            if (lastUserIdx >= 0) {
+                const messages = [...params.messages];
+                messages[lastUserIdx] = {
+                    ...messages[lastUserIdx],
+                    content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
+                };
+                body.messages = messages.map(m => ({ role: m.role, content: m.content }));
+            }
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Moonshot API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.choices?.[0]?.message?.content || '';
+        return {
+            content,
+            usage: data.usage ? {
+                promptTokens: data.usage.prompt_tokens || 0,
+                completionTokens: data.usage.completion_tokens || 0,
+                totalTokens: data.usage.total_tokens || 0,
+            } : undefined,
+        };
+    }
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Ollama Provider - Local LLM via Ollama
+ */
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class OllamaProvider extends BaseProvider {
+    name: string;
+    private model;
+    private baseUrl;
+    constructor(model?: string, baseUrl?: string);
+    isConfigured(): boolean;
+    invoke(params: InvokeParams): Promise<InvokeResult>;
+}

package/dist/providers/ollama.js

@@ -0,0 +1,64 @@
+/**
+ * Ollama Provider - Local LLM via Ollama
+ */
+import { BaseProvider } from './base.js';
+export class OllamaProvider extends BaseProvider {
+    name = 'ollama';
+    model;
+    baseUrl;
+    constructor(model = 'llama4', baseUrl = 'http://localhost:11434') {
+        super();
+        this.model = process.env.OLLAMA_MODEL || model;
+        this.baseUrl = process.env.OLLAMA_HOST || baseUrl;
+    }
+    isConfigured() {
+        return true; // Ollama doesn't need API key
+    }
+    async invoke(params) {
+        const url = `${this.baseUrl}/api/chat`;
+        let messages = params.messages.map(m => ({ role: m.role, content: m.content }));
+        // Add JSON mode if schema provided
+        if (params.jsonSchema) {
+            const lastUserIdx = messages.findLastIndex(m => m.role === 'user');
+            if (lastUserIdx >= 0) {
+                messages = [...messages];
+                messages[lastUserIdx] = {
+                    ...messages[lastUserIdx],
+                    content: messages[lastUserIdx].content + this.buildJsonPrompt(params.jsonSchema),
+                };
+            }
+        }
+        const body = {
+            model: this.model,
+            messages,
+            stream: false,
+            options: {
+                temperature: params.temperature ?? 0.7,
+                num_predict: params.maxTokens ?? 4096,
+            },
+        };
+        // Request JSON format
+        if (params.jsonSchema) {
+            body.format = 'json';
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        const content = data.message?.content || '';
+        return {
+            content,
+            usage: {
+                promptTokens: data.prompt_eval_count || 0,
+                completionTokens: data.eval_count || 0,
+                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+            },
+        };
+    }
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenAI Provider - OpenAI API (and compatible APIs)
+ */
+import { BaseProvider } from './base.js';
+import type { InvokeParams, InvokeResult } from '../types.js';
+export declare class OpenAIProvider extends BaseProvider {
+    name: string;
+    private apiKey;
+    private model;
+    private baseUrl;
+    constructor(apiKey?: string, model?: string, baseUrl?: string);
+    isConfigured(): boolean;
+    invoke(params: InvokeParams): Promise<InvokeResult>;
+}