@eko-ai/eko 1.0.1-5.alpha-2

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

@@ -0,0 +1,77 @@
+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;
+                        };
+                    };
+                    output: {
+                        type: string;
+                        properties: {
+                            name: {
+                                type: string;
+                            };
+                            description: {
+                                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/services/llm/claude-provider.d.ts

@@ -0,0 +1,12 @@
+import Anthropic, { 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: Anthropic, defaultModel?: string);
+    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/services/llm/openai-provider.d.ts

@@ -0,0 +1,12 @@
+import OpenAI, { ClientOptions } from 'openai';
+import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } from '../../types/llm.types';
+export declare class OpenaiProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    constructor(client: OpenAI, defaultModel?: string);
+    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/services/parser/workflow-parser.d.ts

@@ -0,0 +1,23 @@
+import { Workflow } from '../../types/workflow.types';
+import { ValidationResult } from '../../types/parser.types';
+import { EkoConfig } from '../../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, ekoConfig: EkoConfig): Workflow;
+    /**
+     * Convert runtime Workflow object to JSON string
+     */
+    static serialize(workflow: Workflow): string;
+    /**
+     * Validate workflow JSON structure against schema
+     */
+    static validate(json: unknown): ValidationResult;
+    private static toRuntime;
+    /**
+     * Convert runtime Workflow object to JSON structure
+     */
+    private static fromRuntime;
+}

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

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

package/dist/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/action.types.d.ts

@@ -0,0 +1,45 @@
+import { Workflow } from "./workflow.types";
+import { LLMProvider } from "./llm.types";
+import { NodeOutput, WorkflowCallback } from "./workflow.types";
+import { NodeInput } from "./workflow.types";
+import { EkoConfig } from "./eko.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;
+    ekoConfig: EkoConfig;
+    variables: Map<string, unknown>;
+    workflow?: Workflow;
+    tools?: Map<string, Tool<any, any>>;
+    callback?: WorkflowCallback;
+    signal?: AbortSignal;
+    [key: string]: any;
+}
+export interface Action {
+    type: 'prompt' | 'script' | 'hybrid';
+    name: string;
+    description: string;
+    execute: (input: NodeInput, output: NodeOutput, context: ExecutionContext) => Promise<unknown>;
+    tools: Array<Tool<any, any>>;
+    llmProvider?: LLMProvider;
+}

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

@@ -0,0 +1,24 @@
+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 LLMConfig = ClaudeApiKey | ClaudeConfig | OpenaiConfig | LLMProvider;
+export interface EkoConfig {
+    workingWindowId?: number;
+}
+export interface EkoInvokeParam {
+    tools?: Array<string> | Array<Tool<any, any>>;
+}

package/dist/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/llm.types.d.ts

@@ -0,0 +1,52 @@
+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 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>;
+}

package/dist/types/parser.types.d.ts

@@ -0,0 +1,9 @@
+export interface ValidationError {
+    type: "schema" | "reference" | "type" | "tool";
+    message: string;
+    path?: string;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}

package/dist/types/tools.types.d.ts

@@ -0,0 +1,131 @@
+export interface ComputerUseParam {
+    action: string;
+    coordinate?: [number, number];
+    text?: string;
+}
+export interface ComputerUseResult {
+    success: boolean;
+    image?: ScreenshotImage;
+    [key: string]: any;
+}
+export interface BrowserUseParam {
+    action: string;
+    index?: number;
+    text?: string;
+}
+export interface BrowserUseResult {
+    success: boolean;
+    image?: ScreenshotImage;
+    text?: string;
+    [key: string]: any;
+}
+export interface ExportFileParam {
+    content: string;
+    fileType: 'txt' | 'csv' | 'md' | 'html' | 'js' | 'xml' | 'json' | 'yml' | 'sql';
+    filename?: string;
+}
+export interface ExtractContentResult {
+    tabId: number;
+    result: {
+        title?: string;
+        url?: string;
+        content: string;
+    };
+}
+export interface OpenUrlParam {
+    url: string;
+    newWindow?: boolean;
+}
+export interface OpenUrlResult {
+    tabId: number;
+    windowId: number;
+    title?: string;
+}
+export interface BrowserTab {
+    id: number;
+    url?: string;
+    title?: string;
+    content: string;
+    description: string;
+}
+export interface ScreenshotResult {
+    image: ScreenshotImage;
+}
+export interface ScreenshotImage {
+    type: 'base64';
+    media_type: 'image/png' | 'image/jpeg';
+    data: string;
+}
+export interface TabManagementParam {
+    command: string;
+}
+export type TabManagementResult = TabInfo | CloseTabInfo | TabInfo[];
+export interface TabInfo {
+    tabId?: number;
+    windowId?: number;
+    title?: string;
+    url?: string;
+    active?: boolean;
+}
+export interface CloseTabInfo {
+    closedTabId: number;
+    newTabId?: number;
+    newTabTitle?: string;
+}
+export interface WebSearchParam {
+    url?: string;
+    query: string;
+    maxResults?: number;
+}
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    content: string;
+}
+export interface TaskPrompt {
+    task_prompt: string;
+}
+export interface ElementRect {
+    left: number;
+    top: number;
+    right?: number;
+    bottom?: number;
+    width?: number;
+    height?: number;
+}
+export interface CancelWorkflowInput {
+    reason: string;
+}
+export interface HumanInputTextInput {
+    question: string;
+}
+export interface HumanInputTextResult {
+    status: string;
+    answer: string;
+}
+export interface HumanInputSingleChoiceInput {
+    question: string;
+    choices: string[];
+}
+export interface HumanInputSingleChoiceResult {
+    status: string;
+    answer: string;
+}
+export interface HumanInputMultipleChoiceInput {
+    question: string;
+    choices: string[];
+}
+export interface HumanInputMultipleChoiceResult {
+    status: string;
+    answer: string[];
+}
+export interface HumanOperateInput {
+    reason: string;
+}
+export interface HumanOperateResult {
+    status: string;
+    userOperation: string;
+}
+export interface SummaryWorkflowInput {
+    summary: string;
+}

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

@@ -0,0 +1,54 @@
+import { Action, ExecutionContext, Tool } from "./action.types";
+import { LLMProvider } from "./llm.types";
+import { ExecutionLogger } from "@/utils/execution-logger";
+import { ExportFileParam } from "./tools.types";
+export interface NodeOutput {
+    name: string;
+    description: string;
+    value?: unknown;
+}
+export interface NodeInput {
+    items: NodeOutput[];
+}
+export interface WorkflowNode {
+    id: string;
+    name: string;
+    description?: string;
+    dependencies: string[];
+    action: Action;
+    input: NodeInput;
+    output: NodeOutput;
+}
+export interface Workflow {
+    id: string;
+    name: string;
+    description?: string;
+    nodes: WorkflowNode[];
+    variables: Map<string, any>;
+    llmProvider?: LLMProvider;
+    setLogger(logger: ExecutionLogger): void;
+    execute(callback?: WorkflowCallback): Promise<NodeOutput[]>;
+    cancel(): Promise<void>;
+    addNode(node: WorkflowNode): void;
+    removeNode(nodeId: string): void;
+    getNode(nodeId: string): WorkflowNode;
+    validateDAG(): boolean;
+}
+export interface WorkflowCallback {
+    hooks: {
+        beforeWorkflow?: (workflow: Workflow) => Promise<void>;
+        beforeSubtask?: (subtask: WorkflowNode, context: ExecutionContext) => Promise<void>;
+        beforeToolUse?: (tool: Tool<any, any>, context: ExecutionContext, input: any) => Promise<any>;
+        afterToolUse?: (tool: Tool<any, any>, context: ExecutionContext, result: any) => Promise<any>;
+        afterSubtask?: (subtask: WorkflowNode, context: ExecutionContext, result: any) => Promise<void>;
+        afterWorkflow?: (workflow: Workflow, variables: Map<string, unknown>) => Promise<void>;
+        onTabCreated?: (tabId: number) => Promise<void>;
+        onLlmMessage?: (textContent: string) => Promise<void>;
+        onHumanInputText?: (question: string) => Promise<string>;
+        onHumanInputSingleChoice?: (question: string, choices: string[]) => Promise<string>;
+        onHumanInputMultipleChoice?: (question: string, choices: string[]) => Promise<string[]>;
+        onHumanOperate?: (reason: string) => Promise<string>;
+        onSummaryWorkflow?: (summary: string) => Promise<void>;
+        onExportFile?: (param: ExportFileParam) => Promise<void>;
+    };
+}

package/dist/universal_tools/cancel_workflow.d.ts

@@ -0,0 +1,9 @@
+import { CancelWorkflowInput } from '../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../types/action.types';
+export declare class CancelWorkflow implements Tool<CancelWorkflowInput, void> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: CancelWorkflowInput): Promise<void>;
+}

package/dist/universal_tools/human.d.ts

@@ -0,0 +1,30 @@
+import { HumanInputTextInput, HumanInputTextResult, HumanInputSingleChoiceInput, HumanInputSingleChoiceResult, HumanInputMultipleChoiceInput, HumanInputMultipleChoiceResult, HumanOperateInput, HumanOperateResult } from '../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../types/action.types';
+export declare class HumanInputText implements Tool<HumanInputTextInput, HumanInputTextResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: HumanInputTextInput): Promise<HumanInputTextResult>;
+}
+export declare class HumanInputSingleChoice implements Tool<HumanInputSingleChoiceInput, HumanInputSingleChoiceResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: HumanInputSingleChoiceInput): Promise<HumanInputSingleChoiceResult>;
+}
+export declare class HumanInputMultipleChoice implements Tool<HumanInputMultipleChoiceInput, HumanInputMultipleChoiceResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: HumanInputMultipleChoiceInput): Promise<HumanInputMultipleChoiceResult>;
+}
+export declare class HumanOperate implements Tool<HumanOperateInput, HumanOperateResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: HumanOperateInput): Promise<HumanOperateResult>;
+}

package/dist/universal_tools/index.d.ts

@@ -0,0 +1,4 @@
+import { CancelWorkflow } from "./cancel_workflow";
+import { HumanInputText, HumanInputSingleChoice, HumanInputMultipleChoice, HumanOperate } from "./human";
+import { SummaryWorkflow } from "./summary_workflow";
+export { CancelWorkflow, HumanInputText, HumanInputSingleChoice, HumanInputMultipleChoice, HumanOperate, SummaryWorkflow, };

package/dist/universal_tools/summary_workflow.d.ts

@@ -0,0 +1,9 @@
+import { SummaryWorkflowInput } from '../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../types/action.types';
+export declare class SummaryWorkflow implements Tool<SummaryWorkflowInput, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: SummaryWorkflowInput): Promise<any>;
+}

package/dist/utils/execution-logger.d.ts

@@ -0,0 +1,69 @@
+import { Message } from '../types/llm.types';
+import { ExecutionContext } from '../types/action.types';
+interface ImageData {
+    type: 'base64';
+    media_type: string;
+    data: string;
+}
+export interface LogOptions {
+    maxHistoryLength?: number;
+    logLevel?: 'debug' | 'info' | 'warn' | 'error';
+    includeTimestamp?: boolean;
+    debugImagePath?: string;
+    imageSaver?: (imageData: ImageData, filename: string) => Promise<string>;
+}
+/**
+ * Manages logging for action execution, providing a cleaner view of the execution
+ * flow while maintaining important context and history.
+ */
+export declare class ExecutionLogger {
+    private history;
+    private readonly maxHistoryLength;
+    private readonly logLevel;
+    private readonly includeTimestamp;
+    private readonly debugImagePath?;
+    private readonly imageSaver?;
+    private readonly isNode;
+    constructor(options?: LogOptions);
+    /**
+     * Logs a message with execution context
+     */
+    log(level: string, message: string, context?: ExecutionContext): void;
+    /**
+     * Updates conversation history while maintaining size limit
+     */
+    updateHistory(messages: Message[]): void;
+    /**
+     * Gets current conversation history
+     */
+    getHistory(): Message[];
+    /**
+     * Summarizes the execution context for logging
+     */
+    private summarizeContext;
+    /**
+     * Checks if message should be logged based on log level
+     */
+    private shouldLog;
+    /**
+     * Logs the start of an action execution
+     */
+    logActionStart(actionName: string, input: unknown, context?: ExecutionContext): void;
+    /**
+     * Logs the completion of an action execution
+     */
+    logActionComplete(actionName: string, result: unknown, context?: ExecutionContext): void;
+    /**
+     * Logs a tool execution
+     */
+    logToolExecution(toolName: string, input: unknown, context?: ExecutionContext): void;
+    /**
+     * Logs an error that occurred during execution
+     */
+    logError(error: Error, context?: ExecutionContext): void;
+    private extractFromDataUrl;
+    private saveDebugImage;
+    private formatToolResult;
+    logToolResult(toolName: string, result: unknown, context?: ExecutionContext): Promise<void>;
+}
+export {};

package/dist/web/core.d.ts

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

package/dist/web/index.d.ts

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

package/dist/web/script/build_dom_tree.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get clickable elements on the page
+ *
+ * @param {*} doHighlightElements Is highlighted
+ * @param {*} includeAttributes [attr_names...]
+ * @returns { element_str, selector_map }
+ */
+export function get_clickable_elements(doHighlightElements: any | undefined, includeAttributes: any): string;
+export function get_highlight_element(highlightIndex: any): any;
+export function remove_highlight(): void;

package/dist/web/tools/browser.d.ts

@@ -0,0 +1,21 @@
+import { ScreenshotResult } from '../../types/tools.types';
+export declare function type(text: string, xpath?: string, highlightIndex?: number): boolean;
+export declare function clear_input(xpath?: string, highlightIndex?: number): boolean;
+export declare function left_click(xpath?: string, highlightIndex?: number): boolean;
+export declare function right_click(xpath?: string, highlightIndex?: number): boolean;
+export declare function double_click(xpath?: string, highlightIndex?: number): boolean;
+export declare function screenshot(compress?: boolean): Promise<ScreenshotResult>;
+export declare function compress_image(dataUrl: string, scale?: number, quality?: number): Promise<string>;
+export declare function scroll_to(xpath?: string, highlightIndex?: number): boolean;
+export declare function get_dropdown_options(xpath?: string, highlightIndex?: number): {
+    options: Array<{
+        index: number;
+        text: string;
+        value?: string;
+    }>;
+    id?: string;
+    name?: string;
+} | null;
+export declare function select_dropdown_option(text: string, xpath?: string, highlightIndex?: number): any;
+export declare function extractHtmlContent(): string;
+export declare function size(): [number, number];

package/dist/web/tools/browser_use.d.ts

@@ -0,0 +1,19 @@
+import { BrowserUseParam, BrowserUseResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Browser Use for general
+ */
+export declare class BrowserUse implements Tool<BrowserUseParam, BrowserUseResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    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>;
+    destroy(context: ExecutionContext): void;
+}