@eko-ai/eko 1.0.1

package/dist/models/action.d.ts

@@ -0,0 +1,20 @@
+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;
+    tools: Tool<any, any>[];
+    private llmProvider;
+    private llmConfig?;
+    private readonly maxRounds;
+    private writeContextTool;
+    constructor(type: 'prompt', // Only support prompt type
+    name: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters | undefined, config?: {
+        maxRounds?: number;
+    });
+    private executeSingleRound;
+    execute(input: unknown, context: ExecutionContext, outputSchema?: unknown): Promise<unknown>;
+    private formatSystemPrompt;
+    private formatUserPrompt;
+    static createPromptAction(name: string, tools: Tool<any, any>[], llmProvider: LLMProvider, llmConfig?: LLMParameters): Action;
+}

package/dist/models/workflow.d.ts

@@ -0,0 +1,15 @@
+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;
+    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/nodejs/index.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/dist/nodejs.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var index = /*#__PURE__*/Object.freeze({
+	__proto__: null
+});
+
+exports.tools = index;

package/dist/nodejs.esm.js

@@ -0,0 +1,5 @@
+var index = /*#__PURE__*/Object.freeze({
+	__proto__: null
+});
+
+export { index as tools };

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

@@ -0,0 +1,85 @@
+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;
+                            };
+                            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,10 @@
+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(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,10 @@
+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(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,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/services/workflow/generator.d.ts

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

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

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

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

@@ -0,0 +1,36 @@
+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;
+}
+export interface Action {
+    type: 'prompt' | 'script' | 'hybrid';
+    name: string;
+    execute: (input: unknown, context: ExecutionContext) => Promise<unknown>;
+    tools: Tool<any, any>[];
+}

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

@@ -0,0 +1,11 @@
+import { LLMConfig } from './llm.types';
+import { WorkflowNode, Workflow } from './workflow.types';
+import { ExecutionContext } from './action.types';
+export interface EkoFramework {
+    generateWorkflow(prompt: string, llmConfig: LLMConfig): Promise<Workflow>;
+    addNode(workflow: Workflow, node: WorkflowNode): Workflow;
+    removeNode(workflow: Workflow, nodeId: string): Workflow;
+    updateNode(workflow: Workflow, nodeId: string, updates: Partial<WorkflowNode>): Workflow;
+    modifyWorkflowWithPrompt(workflow: Workflow, prompt: string, llmConfig: LLMConfig): Promise<Workflow>;
+    executeWorkflow(workflow: Workflow, context?: ExecutionContext, llmConfig?: LLMConfig): Promise<void>;
+}

package/dist/types/index.d.ts

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

package/dist/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>;
+}

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,88 @@
+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 ScreenshotResult {
+    image: ScreenshotImage;
+}
+export interface ScreenshotImage {
+    type: 'base64';
+    media_type: 'image/png' | 'image/jpeg';
+    data: string;
+}
+export interface TabManagementParam {
+    commond: 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;
+}

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

@@ -0,0 +1,39 @@
+import { Action, ExecutionContext, Tool } from "./action.types";
+import { LLMProvider } from "./llm.types";
+export interface WorkflowNode {
+    id: string;
+    name: string;
+    description?: string;
+    input: NodeIO;
+    output: NodeIO;
+    action: Action;
+    dependencies: string[];
+}
+export interface NodeIO {
+    type: string;
+    schema: object;
+    value: unknown;
+}
+export interface Workflow {
+    id: string;
+    name: string;
+    description?: string;
+    nodes: WorkflowNode[];
+    variables: Map<string, any>;
+    llmProvider?: LLMProvider;
+    execute(callback?: WorkflowCallback): 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>;
+    };
+}

package/dist/web/index.d.ts

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

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

@@ -0,0 +1 @@
+export {};

package/dist/web.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var index = /*#__PURE__*/Object.freeze({
+	__proto__: null
+});
+
+exports.tools = index;

package/dist/web.esm.js

@@ -0,0 +1,5 @@
+var index = /*#__PURE__*/Object.freeze({
+	__proto__: null
+});
+
+export { index as tools };

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@eko-ai/eko",
+  "version": "1.0.1",
+  "description": "Empowering language to transform human words into action.",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs.js",
+      "import": "./dist/index.esm.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts"
+    },
+    "./extension": {
+      "require": "./dist/extension.cjs.js",
+      "import": "./dist/extension.esm.js",
+      "types": "./dist/extension/index.d.ts"
+    },
+    "./web": {
+      "require": "./dist/web.cjs.js",
+      "import": "./dist/web.esm.js",
+      "types": "./dist/web/index.d.ts"
+    },
+    "./nodejs": {
+      "require": "./dist/nodejs.cjs.js",
+      "import": "./dist/nodejs.esm.js",
+      "types": "./dist/nodejs/index.d.ts"
+    },
+    "./fellou": {
+      "require": "./dist/fellou.cjs.js",
+      "import": "./dist/fellou.esm.js",
+      "types": "./dist/fellou/index.d.ts"
+    }
+  },
+  "directories": {
+    "test": "test",
+    "doc": "docs"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "build:dev": "npm run build && npm link",
+    "dev": "tsc --watch",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build",
+    "docs": "typedoc"
+  },
+  "author": "FellouAI",
+  "license": "MIT",
+  "keywords": [
+    "fellou",
+    "eko"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FellouAI/eko.git"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.33.0",
+    "dotenv": "^16.0.0",
+    "openai": "^4.77.0",
+    "uuid": "^11.0.3",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.2",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/chrome": "0.0.158",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.24",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.28.1",
+    "rollup-plugin-copy": "^3.5.0",
+    "ts-jest": "^29.1.2",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.27.6",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}