@eko-ai/eko 1.0.8 → 1.0.10

package/dist/types/src/extension/tools/open_url.d.ts

@@ -0,0 +1,18 @@
+import { OpenUrlParam, OpenUrlResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Open Url
+ */
+export declare class OpenUrl implements Tool<OpenUrlParam, OpenUrlResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Open Url
+     *
+     * @param {*} params { url: 'https://www.google.com', newWindow: true }
+     * @returns > { tabId, windowId, title, success: true }
+     */
+    execute(context: ExecutionContext, params: OpenUrlParam): Promise<OpenUrlResult>;
+}

package/dist/{extension/tools/form_autofill.d.ts → types/src/extension/tools/request_login.d.ts}

@@ -1,11 +1,10 @@
 import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
-/**
- * Form Autofill
- */
-export declare class FormAutofill implements Tool<any, any> {
+export declare class RequestLogin implements Tool<any, any> {
     name: string;
     description: string;
     input_schema: InputSchema;
     constructor();
     execute(context: ExecutionContext, params: any): Promise<any>;
+    awaitLogin(tabId: number, task_id: string): Promise<boolean>;
+    isLoginIn(context: ExecutionContext): Promise<boolean>;
 }

package/dist/types/src/extension/tools/screenshot.d.ts

@@ -0,0 +1,18 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+import { ScreenshotResult } from '../../types/tools.types';
+/**
+ * Current Page Screenshot
+ */
+export declare class Screenshot implements Tool<any, ScreenshotResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Current Page Screenshot
+     *
+     * @param {*} params {}
+     * @returns > { image: { type: 'base64', media_type: 'image/png', data } }
+     */
+    execute(context: ExecutionContext, params: unknown): Promise<ScreenshotResult>;
+}

package/dist/types/src/extension/tools/tab_management.d.ts

@@ -0,0 +1,19 @@
+import { TabManagementParam, TabManagementResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Browser tab management
+ */
+export declare class TabManagement implements Tool<TabManagementParam, TabManagementResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Tab management
+     *
+     * @param {*} params { commond: `new_tab [url]` | 'tab_all' | 'current_tab' | 'go_back' | 'close_tab' | 'switch_tab [tabId]' | `change_url [url]` }
+     * @returns > { result, success: true }
+     */
+    execute(context: ExecutionContext, params: TabManagementParam): Promise<TabManagementResult>;
+    destroy(context: ExecutionContext): void;
+}

package/dist/types/src/extension/tools/web_search.d.ts

@@ -0,0 +1,18 @@
+import { WebSearchParam, WebSearchResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Web Search
+ */
+export declare class WebSearch implements Tool<WebSearchParam, WebSearchResult[]> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * search
+     *
+     * @param {*} params { url: 'https://www.google.com', query: 'ai agent', maxResults: 5 }
+     * @returns > [{ title, url, content }]
+     */
+    execute(context: ExecutionContext, params: WebSearchParam): Promise<WebSearchResult[]>;
+}

package/dist/types/src/extension/utils.d.ts

@@ -0,0 +1,31 @@
+import { ExecutionContext } from '../types/action.types';
+export declare function getWindowId(context: ExecutionContext): Promise<number>;
+export declare function getTabId(context: ExecutionContext): Promise<number>;
+export declare function getCurrentTabId(windowId?: number | undefined): Promise<number | undefined>;
+export declare function open_new_tab(url: string, newWindow: boolean, windowId?: number): Promise<chrome.tabs.Tab>;
+export declare function executeScript(tabId: number, func: any, args: any[]): Promise<any>;
+export declare function waitForTabComplete(tabId: number, timeout?: number): Promise<chrome.tabs.Tab>;
+export declare function doesTabExists(tabId: number): Promise<unknown>;
+export declare function getPageSize(tabId?: number): Promise<[number, number]>;
+export declare function sleep(time: number): Promise<void>;
+export declare function injectScript(tabId: number, filename?: string): Promise<void>;
+export declare class MsgEvent {
+    eventMap: {
+        [key: string]: Function;
+    };
+    constructor();
+    addListener(callback: Function, id: string): string;
+    removeListener(id: string): void;
+    publish(msg: any): Promise<void>;
+}
+/**
+ * Counter (Function: Wait for all asynchronous tasks to complete)
+ */
+export declare class CountDownLatch {
+    resolve?: Function;
+    currentCount: number;
+    constructor(count: number);
+    countDown(): void;
+    await(timeout: number): Promise<void>;
+}
+export declare function isPromise(obj: any): boolean;

package/dist/types/src/fellou/computer.d.ts

@@ -0,0 +1,20 @@
+export declare function can_use_computer(): Promise<boolean>;
+export declare function key(key: string, coordinate?: [number, number]): Promise<boolean>;
+export declare function type(text: string, coordinate?: [number, number]): Promise<boolean>;
+export declare function mouse_move(coordinate: [number, number]): Promise<boolean>;
+export declare function left_click(coordinate?: [number, number]): Promise<boolean>;
+export declare function left_click_drag(coordinate: [number, number]): Promise<boolean>;
+export declare function right_click(coordinate?: [number, number]): Promise<boolean>;
+export declare function double_click(coordinate?: [number, number]): Promise<boolean>;
+export declare function screenshot(windowId?: number): Promise<{
+    image: {
+        type: 'base64';
+        media_type: 'image/png' | 'image/jpeg';
+        data: string;
+    };
+}>;
+export declare function cursor_position(): Promise<{
+    coordinate: [number, number];
+}>;
+export declare function size(): Promise<[number, number]>;
+export declare function scroll(coordinate: [number, number]): Promise<boolean>;

package/dist/types/src/fellou/index.d.ts

@@ -0,0 +1,6 @@
+import * as computer from './computer';
+import { ComputerUse } from './tools/computer_use';
+export { ComputerUse };
+export declare const fellou: {
+    computer: typeof computer;
+};

package/dist/types/src/fellou/tools/computer_use.d.ts

@@ -0,0 +1,18 @@
+import { ComputerUseParam, ComputerUseResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Computer Use for fellou
+ */
+export declare class ComputerUse implements Tool<ComputerUseParam, ComputerUseResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * computer
+     *
+     * @param {*} params { action: 'mouse_move', coordinate: [100, 200] }
+     * @returns { success: true, coordinate?: [], image?: { type: 'base64', media_type: 'image/jpeg', data: '/9j...' } }
+     */
+    execute(context: ExecutionContext, params: ComputerUseParam): Promise<ComputerUseResult>;
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,8 @@
+import Eko from './core/eko';
+import { ToolRegistry } from './core/tool-registry';
+import { ClaudeProvider } from './services/llm/claude-provider';
+import { OpenaiProvider } from './services/llm/openai-provider';
+import { WorkflowParser } from './services/parser/workflow-parser';
+import { WorkflowGenerator } from "./services/workflow/generator";
+export default Eko;
+export { Eko, WorkflowGenerator, ClaudeProvider, OpenaiProvider, ToolRegistry, WorkflowParser };

package/dist/types/src/models/action.d.ts

@@ -0,0 +1,22 @@
+import { Action, Tool, ExecutionContext } from '../types/action.types';
+import { LLMProvider, LLMParameters } from '../types/llm.types';
+export declare class ActionImpl implements Action {
+    type: 'prompt';
+    name: string;
+    description: string;
+    tools: Tool<any, any>[];
+    private llmProvider;
+    private llmConfig?;
+    private readonly maxRounds;
+    private writeContextTool;
+    constructor(type: 'prompt', // Only support prompt type
+    name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters | undefined, config?: {
+        maxRounds?: number;
+    });
+    private executeSingleRound;
+    private handleHistoryImageMessages;
+    execute(input: unknown, context: ExecutionContext, outputSchema?: unknown): Promise<unknown>;
+    private formatSystemPrompt;
+    private formatUserPrompt;
+    static createPromptAction(name: string, description: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters): Action;
+}

package/dist/types/src/models/workflow.d.ts

@@ -0,0 +1,16 @@
+import { Workflow, WorkflowNode, LLMProvider, WorkflowCallback } from "../types";
+export declare class WorkflowImpl implements Workflow {
+    id: string;
+    name: string;
+    description?: string | undefined;
+    nodes: WorkflowNode[];
+    variables: Map<string, unknown>;
+    llmProvider?: LLMProvider | undefined;
+    abort?: boolean;
+    constructor(id: string, name: string, description?: string | undefined, nodes?: WorkflowNode[], variables?: Map<string, unknown>, llmProvider?: LLMProvider | undefined);
+    execute(callback?: WorkflowCallback): Promise<void>;
+    addNode(node: WorkflowNode): void;
+    removeNode(nodeId: string): void;
+    getNode(nodeId: string): WorkflowNode;
+    validateDAG(): boolean;
+}

package/dist/types/src/nodejs/core.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from '../types';
+export declare function loadTools(): Map<string, Tool<any, any>>;

package/dist/types/src/nodejs/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+import * as tools from './tools';
+export { tools };

package/dist/types/src/nodejs/script/build_dom_tree.d.ts

@@ -0,0 +1 @@
+export function run_build_dom_tree(): void;

package/dist/types/src/nodejs/tools/browser_use.d.ts

@@ -0,0 +1,28 @@
+import { BrowserUseParam, BrowserUseResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Browser Use => `npx playwright install`
+ */
+export declare class BrowserUse implements Tool<BrowserUseParam, BrowserUseResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    private browser;
+    private browser_context;
+    private current_page;
+    constructor();
+    /**
+     * browser
+     *
+     * @param {*} params { action: 'input_text', index: 1, text: 'string' }
+     * @returns > { success: true, image?: { type: 'base64', media_type: 'image/jpeg', data: '/9j...' }, text?: string }
+     */
+    execute(context: ExecutionContext, params: BrowserUseParam): Promise<BrowserUseResult>;
+    private open_url;
+    private injectScript;
+    private get_highlight_element;
+    private extractHtmlContent;
+    private get_dropdown_options;
+    private select_dropdown_option;
+    destroy(context: ExecutionContext): void;
+}

package/dist/types/src/nodejs/tools/command_execute.d.ts

@@ -0,0 +1,12 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+export interface CommandExecuteParams {
+    command: string;
+    cwd?: string;
+}
+export declare class CommandExecute implements Tool<CommandExecuteParams, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    private getUserConfirmation;
+    execute(context: ExecutionContext, params: CommandExecuteParams): Promise<any>;
+}

package/dist/types/src/nodejs/tools/file_read.d.ts

@@ -0,0 +1,11 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+export interface FileReadParams {
+    path: string;
+    encoding?: BufferEncoding;
+}
+export declare class FileRead implements Tool<FileReadParams, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    execute(context: ExecutionContext, params: FileReadParams): Promise<any>;
+}

package/dist/types/src/nodejs/tools/file_write.d.ts

@@ -0,0 +1,15 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+export interface FileWriteParams {
+    path: string;
+    content: string;
+    append?: boolean;
+    encoding?: BufferEncoding;
+}
+export declare class FileWrite implements Tool<FileWriteParams, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    private checkFileExists;
+    private getUserConfirmation;
+    execute(context: ExecutionContext, params: FileWriteParams): Promise<any>;
+}

package/dist/types/src/nodejs/tools/index.d.ts

@@ -0,0 +1,4 @@
+export { CommandExecute } from './command_execute';
+export { FileRead } from './file_read';
+export { FileWrite } from './file_write';
+export { BrowserUse } from './browser_use';

package/dist/types/src/schemas/workflow.schema.d.ts

@@ -0,0 +1,88 @@
+export declare const workflowSchema: {
+    type: string;
+    required: string[];
+    properties: {
+        id: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        description: {
+            type: string;
+        };
+        nodes: {
+            type: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    id: {
+                        type: string;
+                    };
+                    type: {
+                        type: string;
+                        enum: string[];
+                    };
+                    dependencies: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    input: {
+                        type: string;
+                        properties: {
+                            type: {
+                                type: string;
+                            };
+                            schema: {
+                                type: string;
+                            };
+                        };
+                    };
+                    output: {
+                        type: string;
+                        properties: {
+                            type: {
+                                type: string;
+                            };
+                            schema: {
+                                type: string;
+                            };
+                        };
+                    };
+                    action: {
+                        type: string;
+                        required: string[];
+                        properties: {
+                            type: {
+                                type: string;
+                                enum: string[];
+                            };
+                            name: {
+                                type: string;
+                            };
+                            description: {
+                                type: string;
+                            };
+                            params: {
+                                type: string;
+                            };
+                            tools: {
+                                type: string;
+                                items: {
+                                    type: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        variables: {
+            type: string;
+            additionalProperties: boolean;
+        };
+    };
+};

package/dist/types/src/services/llm/claude-provider.d.ts

@@ -0,0 +1,11 @@
+import { ClientOptions } from '@anthropic-ai/sdk';
+import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
+export declare class ClaudeProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
+    constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
+    private processResponse;
+    generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;
+    generateStream(messages: Message[], params: LLMParameters, handler: LLMStreamHandler): Promise<void>;
+}

package/dist/types/src/services/llm/deepseek-provider.d.ts

@@ -0,0 +1,15 @@
+import { ClientOptions } from 'openai';
+import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
+export declare class DeepseekProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
+    constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
+    private buildTools;
+    private buildToolChoice;
+    private buildMessages;
+    private buildParams;
+    foo(messages: Message[]): void;
+    generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;
+    generateStream(messages: Message[], params: LLMParameters, handler: LLMStreamHandler): Promise<void>;
+}

package/dist/types/src/services/llm/glm-provider.d.ts

@@ -0,0 +1,11 @@
+import { ClientOptions } from 'openai';
+import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
+export declare class OpenaiProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
+    constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
+    private buildParams;
+    generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;
+    generateStream(messages: Message[], params: LLMParameters, handler: LLMStreamHandler): Promise<void>;
+}

package/dist/types/src/services/llm/openai-provider copy.d.ts

@@ -0,0 +1,11 @@
+import { ClientOptions } from 'openai';
+import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
+export declare class OpenaiProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
+    constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
+    private buildParams;
+    generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;
+    generateStream(messages: Message[], params: LLMParameters, handler: LLMStreamHandler): Promise<void>;
+}

package/dist/types/src/services/llm/openai-provider.d.ts

@@ -0,0 +1,11 @@
+import { ClientOptions } from 'openai';
+import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
+export declare class OpenaiProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
+    constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
+    private buildParams;
+    generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;
+    generateStream(messages: Message[], params: LLMParameters, handler: LLMStreamHandler): Promise<void>;
+}

package/dist/types/src/services/parser/workflow-parser.d.ts

@@ -0,0 +1,29 @@
+import { Workflow } from '../../types/workflow.types';
+import { ValidationResult } from '../../types/parser.types';
+export declare class WorkflowParser {
+    /**
+     * Parse JSON string into runtime Workflow object
+     * @throws {Error} if JSON is invalid or schema validation fails
+     */
+    static parse(json: string): Workflow;
+    /**
+     * Convert runtime Workflow object to JSON string
+     */
+    static serialize(workflow: Workflow): string;
+    /**
+     * Validate workflow JSON structure against schema
+     */
+    static validate(json: unknown): ValidationResult;
+    /**
+     * Convert parsed JSON to runtime Workflow object
+     */
+    private static toRuntime;
+    /**
+     * Convert runtime Workflow object to JSON structure
+     */
+    private static fromRuntime;
+    /**
+     * Helper to convert IO definitions
+     */
+    private static convertIO;
+}

package/dist/types/src/services/workflow/generator.d.ts

@@ -0,0 +1,13 @@
+import { LLMProvider, Message } from '../../types/llm.types';
+import { Workflow } from '../../types/workflow.types';
+import { ToolRegistry } from '../../core/tool-registry';
+export declare class WorkflowGenerator {
+    private llmProvider;
+    private toolRegistry;
+    message_history: Message[];
+    constructor(llmProvider: LLMProvider, toolRegistry: ToolRegistry);
+    generateWorkflow(prompt: string): Promise<Workflow>;
+    modifyWorkflow(prompt: string): Promise<Workflow>;
+    private doGenerateWorkflow;
+    private createWorkflowFromData;
+}

package/dist/types/src/services/workflow/templates.d.ts

@@ -0,0 +1,8 @@
+import { ToolDefinition } from '../../types/llm.types';
+import { ToolRegistry } from '../../core/tool-registry';
+export declare function createWorkflowPrompts(tools: ToolDefinition[]): {
+    formatSystemPrompt: () => string;
+    formatUserPrompt: (requirement: string) => string;
+    modifyUserPrompt: (prompt: string) => string;
+};
+export declare function createWorkflowGenerationTool(registry: ToolRegistry): ToolDefinition;

package/dist/types/src/types/action.types.d.ts

@@ -0,0 +1,38 @@
+import { LLMProvider } from "./llm.types";
+import { WorkflowCallback } from "./workflow.types";
+export interface Tool<T, R> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    execute: (context: ExecutionContext, params: T) => Promise<R>;
+    destroy?: (context: ExecutionContext) => void;
+}
+export interface InputSchema {
+    type: 'object';
+    properties?: Properties;
+    required?: Array<string>;
+}
+export interface Properties {
+    [key: string]: Property;
+}
+export interface Property {
+    type: 'string' | 'integer' | 'boolean' | 'array' | 'object';
+    description?: string;
+    items?: InputSchema;
+    enum?: Array<string | number>;
+    properties?: Properties;
+}
+export interface ExecutionContext {
+    llmProvider: LLMProvider;
+    variables: Map<string, unknown>;
+    tools?: Map<string, Tool<any, any>>;
+    callback?: WorkflowCallback;
+    [key: string]: any;
+}
+export interface Action {
+    type: 'prompt' | 'script' | 'hybrid';
+    name: string;
+    description: string;
+    execute: (input: unknown, context: ExecutionContext) => Promise<unknown>;
+    tools: Tool<any, any>[];
+}

package/dist/types/src/types/eko.types.d.ts

@@ -0,0 +1,21 @@
+import { ClientOptions as OpenAiClientOptions } from 'openai';
+import { ClientOptions as ClaudeClientOption } from '@anthropic-ai/sdk';
+import { LLMProvider } from './llm.types';
+import { Tool } from './action.types';
+export interface ClaudeConfig {
+    llm: 'claude';
+    apiKey: string;
+    modelName?: string;
+    options?: ClaudeClientOption;
+}
+export interface OpenaiConfig {
+    llm: 'openai';
+    apiKey: string;
+    modelName?: string;
+    options?: OpenAiClientOptions;
+}
+export type ClaudeApiKey = string;
+export type EkoConfig = ClaudeApiKey | ClaudeConfig | OpenaiConfig | LLMProvider;
+export interface EkoInvokeParam {
+    tools?: Array<string> | Array<Tool<any, any>>;
+}

package/dist/types/src/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './action.types';
+export * from './workflow.types';
+export * from './eko.types';
+export * from './llm.types';
+export * from './tools.types';

package/dist/types/src/types/llm.types.d.ts

@@ -0,0 +1,54 @@
+export interface Message {
+    role: 'user' | 'assistant' | 'system';
+    content: string | unknown[];
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+export interface LLMConfig {
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+}
+export interface ToolResult {
+    tool_use_id: string;
+    content: string | Array<{
+        type: string;
+        text: string;
+    }>;
+}
+export interface LLMParameters {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: ToolDefinition[];
+    toolChoice?: {
+        type: 'auto' | 'tool' | 'any';
+        name?: string;
+    };
+}
+export interface LLMResponse {
+    textContent: string | null;
+    content: string | unknown[];
+    toolCalls: ToolCall[];
+    stop_reason: string | null;
+}
+export interface LLMStreamHandler {
+    onStart?: () => void;
+    onContent?: (content: string) => void;
+    onToolUse?: (toolCall: ToolCall) => void;
+    onComplete?: (response: LLMResponse) => void;
+    onError?: (error: Error) => void;
+}
+export interface LLMProvider {
+    generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;
+    generateStream(messages: Message[], params: LLMParameters, handler: LLMStreamHandler): Promise<void>;
+}