@eko-ai/eko 1.0.8 → 1.0.10

package/dist/index.cjs.js

@@ -2,936 +2,258 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-class WorkflowImpl {
-    constructor(id, name, description, nodes = [], variables = new Map(), llmProvider) {
-        this.id = id;
-        this.name = name;
-        this.description = description;
-        this.nodes = nodes;
-        this.variables = variables;
-        this.llmProvider = llmProvider;
+const VERSION$1 = '0.33.1'; // x-release-please-version
+
+let auto$1 = false;
+let kind$1 = undefined;
+let fetch$2 = undefined;
+let File$2 = undefined;
+let ReadableStream$2 = undefined;
+let getDefaultAgent$1 = undefined;
+let fileFromPath$1 = undefined;
+function setShims$1(shims, options = { auto: false }) {
+    if (auto$1) {
+        throw new Error(`you must \`import '@anthropic-ai/sdk/shims/${shims.kind}'\` before importing anything else from @anthropic-ai/sdk`);
     }
-    async execute(callback) {
-        var _a, _b, _c, _d;
-        if (!this.validateDAG()) {
-            throw new Error("Invalid workflow: Contains circular dependencies");
-        }
-        this.abort = false;
-        callback && await ((_b = (_a = callback.hooks).beforeWorkflow) === null || _b === void 0 ? void 0 : _b.call(_a, this));
-        const executed = new Set();
-        const executing = new Set();
-        const executeNode = async (nodeId) => {
-            var _a, _b, _c, _d, _e;
-            if (this.abort) {
-                throw new Error("Abort");
-            }
-            if (executed.has(nodeId)) {
-                return;
-            }
-            if (executing.has(nodeId)) {
-                throw new Error(`Circular dependency detected at node: ${nodeId}`);
-            }
-            const node = this.getNode(nodeId);
-            // Execute the node's action
-            const context = {
-                __skip: false,
-                __abort: false,
-                variables: this.variables,
-                llmProvider: this.llmProvider,
-                tools: new Map(node.action.tools.map(tool => [tool.name, tool])),
-                callback,
-                next: () => context.__skip = true,
-                abortAll: () => this.abort = context.__abort = true,
-            };
-            callback && await ((_b = (_a = callback.hooks).beforeSubtask) === null || _b === void 0 ? void 0 : _b.call(_a, node, context));
-            if (context.__abort) {
-                throw new Error("Abort");
-            }
-            else if (context.__skip) {
-                return;
-            }
-            executing.add(nodeId);
-            // Execute dependencies first
-            for (const depId of node.dependencies) {
-                await executeNode(depId);
-            }
-            // Prepare input by gathering outputs from dependencies
-            const input = {};
-            for (const depId of node.dependencies) {
-                const depNode = this.getNode(depId);
-                input[depId] = depNode.output.value;
-            }
-            node.input.value = input;
-            node.output.value = await node.action.execute(node.input.value, context);
-            executing.delete(nodeId);
-            executed.add(nodeId);
-            callback && await ((_d = (_c = callback.hooks).afterSubtask) === null || _d === void 0 ? void 0 : _d.call(_c, node, context, (_e = node.output) === null || _e === void 0 ? void 0 : _e.value));
-        };
-        // Execute all terminal nodes (nodes with no dependents)
-        const terminalNodes = this.nodes.filter(node => !this.nodes.some(n => n.dependencies.includes(node.id)));
-        await Promise.all(terminalNodes.map(node => executeNode(node.id)));
-        callback && await ((_d = (_c = callback.hooks).afterWorkflow) === null || _d === void 0 ? void 0 : _d.call(_c, this, this.variables));
+    if (kind$1) {
+        throw new Error(`can't \`import '@anthropic-ai/sdk/shims/${shims.kind}'\` after \`import '@anthropic-ai/sdk/shims/${kind$1}'\``);
     }
-    addNode(node) {
-        if (this.nodes.some(n => n.id === node.id)) {
-            throw new Error(`Node with id ${node.id} already exists`);
-        }
-        this.nodes.push(node);
+    auto$1 = options.auto;
+    kind$1 = shims.kind;
+    fetch$2 = shims.fetch;
+    File$2 = shims.File;
+    ReadableStream$2 = shims.ReadableStream;
+    getDefaultAgent$1 = shims.getDefaultAgent;
+    fileFromPath$1 = shims.fileFromPath;
+}
+
+/**
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
+ */
+let MultipartBody$1 = class MultipartBody {
+    constructor(body) {
+        this.body = body;
     }
-    removeNode(nodeId) {
-        const index = this.nodes.findIndex(n => n.id === nodeId);
-        if (index === -1) {
-            throw new Error(`Node with id ${nodeId} not found`);
-        }
-        // Check if any nodes depend on this one
-        const dependentNodes = this.nodes.filter(n => n.dependencies.includes(nodeId));
-        if (dependentNodes.length > 0) {
-            throw new Error(`Cannot remove node ${nodeId}: Nodes ${dependentNodes.map(n => n.id).join(", ")} depend on it`);
-        }
-        this.nodes.splice(index, 1);
+    get [Symbol.toStringTag]() {
+        return 'MultipartBody';
     }
-    getNode(nodeId) {
-        const node = this.nodes.find(n => n.id === nodeId);
-        if (!node) {
-            throw new Error(`Node with id ${nodeId} not found`);
-        }
-        return node;
+};
+
+function getRuntime$1({ manuallyImported } = {}) {
+    const recommendation = manuallyImported ?
+        `You may need to use polyfills`
+        : `Add one of these imports before your first \`import … from '@anthropic-ai/sdk'\`:
+- \`import '@anthropic-ai/sdk/shims/node'\` (if you're running on Node)
+- \`import '@anthropic-ai/sdk/shims/web'\` (otherwise)
+`;
+    let _fetch, _Request, _Response, _Headers;
+    try {
+        // @ts-ignore
+        _fetch = fetch;
+        // @ts-ignore
+        _Request = Request;
+        // @ts-ignore
+        _Response = Response;
+        // @ts-ignore
+        _Headers = Headers;
     }
-    validateDAG() {
-        const visited = new Set();
-        const recursionStack = new Set();
-        const hasCycle = (nodeId) => {
-            if (recursionStack.has(nodeId)) {
-                return true;
+    catch (error) {
+        throw new Error(`this environment is missing the following Web Fetch API type: ${error.message}. ${recommendation}`);
+    }
+    return {
+        kind: 'web',
+        fetch: _fetch,
+        Request: _Request,
+        Response: _Response,
+        Headers: _Headers,
+        FormData: 
+        // @ts-ignore
+        typeof FormData !== 'undefined' ? FormData : (class FormData {
+            // @ts-ignore
+            constructor() {
+                throw new Error(`file uploads aren't supported in this environment yet as 'FormData' is undefined. ${recommendation}`);
             }
-            if (visited.has(nodeId)) {
-                return false;
+        }),
+        Blob: typeof Blob !== 'undefined' ? Blob : (class Blob {
+            constructor() {
+                throw new Error(`file uploads aren't supported in this environment yet as 'Blob' is undefined. ${recommendation}`);
             }
-            visited.add(nodeId);
-            recursionStack.add(nodeId);
-            const node = this.getNode(nodeId);
-            for (const depId of node.dependencies) {
-                if (hasCycle(depId)) {
-                    return true;
-                }
+        }),
+        File: 
+        // @ts-ignore
+        typeof File !== 'undefined' ? File : (class File {
+            // @ts-ignore
+            constructor() {
+                throw new Error(`file uploads aren't supported in this environment yet as 'File' is undefined. ${recommendation}`);
             }
-            recursionStack.delete(nodeId);
-            return false;
-        };
-        return !this.nodes.some(node => hasCycle(node.id));
-    }
+        }),
+        ReadableStream: 
+        // @ts-ignore
+        typeof ReadableStream !== 'undefined' ? ReadableStream : (class ReadableStream {
+            // @ts-ignore
+            constructor() {
+                throw new Error(`streaming isn't supported in this environment yet as 'ReadableStream' is undefined. ${recommendation}`);
+            }
+        }),
+        getMultipartRequestOptions: async (
+        // @ts-ignore
+        form, opts) => ({
+            ...opts,
+            body: new MultipartBody$1(form),
+        }),
+        getDefaultAgent: (url) => undefined,
+        fileFromPath: () => {
+            throw new Error('The `fileFromPath` function is only supported in Node. See the README for more details: https://www.github.com/anthropics/anthropic-sdk-typescript#file-uploads');
+        },
+        isFsReadStream: (value) => false,
+    };
 }
 
-// src/models/action.ts
 /**
- * Special tool that allows LLM to write values to context
+ * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
  */
-class WriteContextTool {
-    constructor() {
-        this.name = 'write_context';
-        this.description = 'Write a value to the workflow context. Use this to store intermediate results or outputs.';
-        this.input_schema = {
-            type: 'object',
-            properties: {
-                key: {
-                    type: 'string',
-                    description: 'The key to store the value under',
-                },
-                value: {
-                    type: 'string',
-                    description: 'The value to store (must be JSON stringified if object/array)',
-                },
-            },
-            required: ['key', 'value'],
-        };
+if (!kind$1) setShims$1(getRuntime$1(), { auto: true });
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class AnthropicError extends Error {
+}
+let APIError$1 = class APIError extends AnthropicError {
+    constructor(status, error, message, headers) {
+        super(`${APIError.makeMessage(status, error, message)}`);
+        this.status = status;
+        this.headers = headers;
+        this.request_id = headers?.['request-id'];
+        this.error = error;
     }
-    async execute(context, params) {
-        const { key, value } = params;
-        try {
-            // Try to parse the value as JSON
-            const parsedValue = JSON.parse(value);
-            context.variables.set(key, parsedValue);
+    static makeMessage(status, error, message) {
+        const msg = error?.message ?
+            typeof error.message === 'string' ?
+                error.message
+                : JSON.stringify(error.message)
+            : error ? JSON.stringify(error)
+                : message;
+        if (status && msg) {
+            return `${status} ${msg}`;
         }
-        catch (_a) {
-            // If parsing fails, store as string
-            context.variables.set(key, value);
+        if (status) {
+            return `${status} status code (no body)`;
         }
-        return { success: true, key, value };
+        if (msg) {
+            return msg;
+        }
+        return '(no status code or body)';
     }
-}
-function createReturnTool(outputSchema) {
-    return {
-        name: 'return_output',
-        description: 'Return the final output of this action. Use this to return a value matching the required output schema.',
-        input_schema: {
-            type: 'object',
-            properties: {
-                value: outputSchema || {
-                    // Default to accepting any JSON value
-                    type: ['string', 'number', 'boolean', 'object', 'null'],
-                    description: 'The output value',
-                },
-            },
-            required: ['value'],
-        },
-        async execute(context, params) {
-            const { value } = params;
-            context.variables.set('__action_output', value);
-            return { returned: value };
-        },
-    };
-}
-class ActionImpl {
-    constructor(type, // Only support prompt type
-    name, description, tools, llmProvider, llmConfig, config) {
-        this.type = type;
-        this.name = name;
-        this.description = description;
-        this.tools = tools;
-        this.llmProvider = llmProvider;
-        this.llmConfig = llmConfig;
-        this.maxRounds = 10; // Default max rounds
-        this.writeContextTool = new WriteContextTool();
-        this.tools = [...tools, this.writeContextTool];
-        if (config === null || config === void 0 ? void 0 : config.maxRounds) {
-            this.maxRounds = config.maxRounds;
+    static generate(status, errorResponse, message, headers) {
+        if (!status || !headers) {
+            return new APIConnectionError$1({ message, cause: castToError$1(errorResponse) });
         }
-    }
-    async executeSingleRound(messages, params, toolMap, context) {
-        const roundMessages = [];
-        let hasToolUse = false;
-        let response = null;
-        // Buffer to collect into roundMessages
-        let assistantTextMessage = '';
-        let toolUseMessage = null;
-        let toolResultMessage = null;
-        // Track tool execution promise
-        let toolExecutionPromise = null;
-        const handler = {
-            onContent: (content) => {
-                if (content.trim()) {
-                    assistantTextMessage += content;
-                }
-            },
-            onToolUse: async (toolCall) => {
-                console.log('Tool Call:', toolCall.name, toolCall.input);
-                hasToolUse = true;
-                const tool = toolMap.get(toolCall.name);
-                if (!tool) {
-                    throw new Error(`Tool not found: ${toolCall.name}`);
-                }
-                toolUseMessage = {
-                    role: 'assistant',
-                    content: [
-                        {
-                            type: 'tool_use',
-                            id: toolCall.id,
-                            name: tool.name,
-                            input: toolCall.input,
-                        },
-                    ],
-                };
-                // Store the promise of tool execution
-                toolExecutionPromise = (async () => {
-                    try {
-                        // beforeToolUse
-                        context.__skip = false;
-                        if (context.callback && context.callback.hooks.beforeToolUse) {
-                            let modified_input = await context.callback.hooks.beforeToolUse(tool, context, toolCall.input);
-                            if (modified_input) {
-                                toolCall.input = modified_input;
-                            }
-                        }
-                        if (context.__skip || context.__abort) {
-                            toolResultMessage = {
-                                role: 'user',
-                                content: [
-                                    {
-                                        type: 'tool_result',
-                                        tool_use_id: toolCall.id,
-                                        content: 'skip',
-                                    },
-                                ],
-                            };
-                            return;
-                        }
-                        // Execute the tool
-                        let result = await tool.execute(context, toolCall.input);
-                        // afterToolUse
-                        if (context.callback && context.callback.hooks.afterToolUse) {
-                            let modified_result = await context.callback.hooks.afterToolUse(tool, context, result);
-                            if (modified_result) {
-                                result = modified_result;
-                            }
-                        }
-                        const resultMessage = {
-                            role: 'user',
-                            content: [
-                                result.image && result.image.type
-                                    ? {
-                                        type: 'tool_result',
-                                        tool_use_id: toolCall.id,
-                                        content: result.text
-                                            ? [
-                                                { type: 'image', source: result.image },
-                                                { type: 'text', text: result.text },
-                                            ]
-                                            : [{ type: 'image', source: result.image }],
-                                    }
-                                    : {
-                                        type: 'tool_result',
-                                        tool_use_id: toolCall.id,
-                                        content: [{ type: 'text', text: JSON.stringify(result) }],
-                                    },
-                            ],
-                        };
-                        toolResultMessage = resultMessage;
-                        console.log('Tool Result:', result);
-                    }
-                    catch (err) {
-                        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
-                        const errorResult = {
-                            role: 'user',
-                            content: [
-                                {
-                                    type: 'tool_result',
-                                    tool_use_id: toolCall.id,
-                                    content: [{ type: 'text', text: `Error: ${errorMessage}` }],
-                                    is_error: true,
-                                },
-                            ],
-                        };
-                        toolResultMessage = errorResult;
-                        console.error('Tool Error:', err);
-                    }
-                })();
-            },
-            onComplete: (llmResponse) => {
-                response = llmResponse;
-            },
-            onError: (error) => {
-                console.error('Stream Error:', error);
-            },
-        };
-        this.handleHistoryImageMessages(messages);
-        // Wait for stream to complete
-        await this.llmProvider.generateStream(messages, params, handler);
-        // Wait for tool execution to complete if it was started
-        if (toolExecutionPromise) {
-            await toolExecutionPromise;
+        const error = errorResponse;
+        if (status === 400) {
+            return new BadRequestError$1(status, error, message, headers);
         }
-        if (context.__abort) {
-            throw new Error('Abort');
+        if (status === 401) {
+            return new AuthenticationError$1(status, error, message, headers);
         }
-        // Add messages in the correct order after everything is complete
-        if (assistantTextMessage) {
-            roundMessages.push({ role: 'assistant', content: assistantTextMessage });
+        if (status === 403) {
+            return new PermissionDeniedError$1(status, error, message, headers);
         }
-        if (toolUseMessage) {
-            roundMessages.push(toolUseMessage);
+        if (status === 404) {
+            return new NotFoundError$1(status, error, message, headers);
         }
-        if (toolResultMessage) {
-            roundMessages.push(toolResultMessage);
+        if (status === 409) {
+            return new ConflictError$1(status, error, message, headers);
         }
-        return { response, hasToolUse, roundMessages };
-    }
-    handleHistoryImageMessages(messages) {
-        // Remove all images of the historical tool call results, except for the last one.
-        let last_user = true;
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const message = messages[i];
-            if (message.role === 'user') {
-                if (last_user) {
-                    last_user = false;
-                    continue;
-                }
-                if (message.content instanceof Array) {
-                    let content = message.content;
-                    for (let j = 0; j < content.length; j++) {
-                        if (content[j].type === 'tool_result' && content[j].content instanceof Array) {
-                            let tool_content = content[j].content;
-                            if (tool_content.length > 0) {
-                                for (let k = tool_content.length - 1; k >= 0; k--) {
-                                    if (tool_content[k].type === 'image') {
-                                        tool_content.splice(k, 1);
-                                    }
-                                }
-                            }
-                            else if (tool_content[0].type === 'image') {
-                                tool_content = [{ type: 'text', text: 'ok' }];
-                            }
-                        }
-                    }
-                }
-            }
+        if (status === 422) {
+            return new UnprocessableEntityError$1(status, error, message, headers);
         }
-    }
-    async execute(input, context, outputSchema) {
-        var _a;
-        // Create return tool with output schema
-        const returnTool = createReturnTool(outputSchema);
-        // Create tool map combining context tools, action tools, and return tool
-        const toolMap = new Map();
-        this.tools.forEach((tool) => toolMap.set(tool.name, tool));
-        (_a = context.tools) === null || _a === void 0 ? void 0 : _a.forEach((tool) => toolMap.set(tool.name, tool));
-        toolMap.set(returnTool.name, returnTool);
-        // Prepare initial messages
-        const messages = [
-            { role: 'system', content: this.formatSystemPrompt() },
-            { role: 'user', content: this.formatUserPrompt(context, input) },
-        ];
-        console.log('Starting LLM conversation...');
-        console.log('Initial messages:', messages);
-        console.log('Output schema:', outputSchema);
-        // Configure tool parameters
-        const params = {
-            ...this.llmConfig,
-            tools: Array.from(toolMap.values()).map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                input_schema: tool.input_schema,
-            })),
-        };
-        let roundCount = 0;
-        while (roundCount < this.maxRounds) {
-            roundCount++;
-            console.log(`Starting round ${roundCount} of ${this.maxRounds}`);
-            console.log('Current conversation status:', JSON.stringify(messages, null, 2));
-            const { response, hasToolUse, roundMessages } = await this.executeSingleRound(messages, params, toolMap, context);
-            // Add round messages to conversation history
-            messages.push(...roundMessages);
-            // Check termination conditions
-            if (!hasToolUse && response) {
-                // LLM sent a message without using tools - request explicit return
-                console.log('No tool use detected, requesting explicit return');
-                console.log('Response:', response);
-                const returnOnlyParams = {
-                    ...params,
-                    tools: [
-                        {
-                            name: returnTool.name,
-                            description: returnTool.description,
-                            input_schema: returnTool.input_schema,
-                        },
-                    ],
-                };
-                messages.push({
-                    role: 'user',
-                    content: 'Please process the above information and return a final result using the return_output tool.',
-                });
-                const { roundMessages: finalRoundMessages } = await this.executeSingleRound(messages, returnOnlyParams, new Map([[returnTool.name, returnTool]]), context);
-                messages.push(...finalRoundMessages);
-                break;
-            }
-            if (response === null || response === void 0 ? void 0 : response.toolCalls.some((call) => call.name === 'return_output')) {
-                console.log('Task completed with return_output tool');
-                break;
-            }
-            // If this is the last round, force an explicit return
-            if (roundCount === this.maxRounds) {
-                console.log('Max rounds reached, requesting explicit return');
-                const returnOnlyParams = {
-                    ...params,
-                    tools: [
-                        {
-                            name: returnTool.name,
-                            description: returnTool.description,
-                            input_schema: returnTool.input_schema,
-                        },
-                    ],
-                };
-                messages.push({
-                    role: 'user',
-                    content: 'Maximum number of steps reached. Please return the best result possible with the return_output tool.',
-                });
-                const { roundMessages: finalRoundMessages } = await this.executeSingleRound(messages, returnOnlyParams, new Map([[returnTool.name, returnTool]]), context);
-                messages.push(...finalRoundMessages);
-            }
+        if (status === 429) {
+            return new RateLimitError$1(status, error, message, headers);
         }
-        // Get and clean up output value
-        const output = context.variables.get('__action_output');
-        context.variables.delete('__action_output');
-        if (output === undefined) {
-            console.warn('Action completed without returning a value');
-            return {};
+        if (status >= 500) {
+            return new InternalServerError$1(status, error, message, headers);
         }
-        return output;
-    }
-    formatSystemPrompt() {
-        return `You are a task executor. You need to complete the task specified by the user, using the tools provided. When you need to store results or outputs, use the write_context tool. When you are ready to return the final output, use the return_output tool.
-
-    Remember to:
-    1. Use tools when needed to accomplish the task
-    2. Store important results using write_context, including intermediate and final results
-    3. Think step by step about what needs to be done`;
+        return new APIError(status, error, message, headers);
     }
-    formatUserPrompt(context, input) {
-        // Create a description of the current context
-        const contextDescription = Array.from(context.variables.entries())
-            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-            .join('\n');
-        return `You are executing the action "${this.name}". The specific instructions are: "${this.description}". You have access to the following context:
-
-    ${contextDescription || 'No context variables set'}
-
-    You have been provided with the following input:
-    ${(typeof input === 'string' ? input : JSON.stringify(input, null, 2)) || 'No additional input provided'}
-    `;
-    }
-    // Static factory method
-    static createPromptAction(name, description, tools, llmProvider, llmConfig) {
-        return new ActionImpl('prompt', name, description, tools, llmProvider, llmConfig);
+};
+let APIUserAbortError$1 = class APIUserAbortError extends APIError$1 {
+    constructor({ message } = {}) {
+        super(undefined, undefined, message || 'Request was aborted.', undefined);
     }
-}
-
-// src/services/workflow/templates.ts
-function createWorkflowPrompts(tools) {
-    return {
-        formatSystemPrompt: () => {
-            const toolDescriptions = tools
-                .map((tool) => `
-Tool: ${tool.name}
-Description: ${tool.description}
-Input Schema: ${JSON.stringify(tool.input_schema, null, 2)}
-        `)
-                .join('\n');
-            return `You are a workflow generation assistant that creates Eko framework workflows.
-The following tools are available:
-
-${toolDescriptions}
-
-Generate a complete workflow that:
-1. Only uses the tools listed above
-2. Properly sequences tool usage based on dependencies
-3. Ensures each action has appropriate input/output schemas, and that the "tools" field in each action is populated with the sufficient subset of all available tools needed to complete the action
-4. Creates a clear, logical flow to accomplish the user's goal
-5. Includes detailed descriptions for each action, ensuring that the actions, when combined, is a complete solution to the user's problem`;
-        },
-        formatUserPrompt: (requirement) => `Create a workflow for the following requirement: ${requirement}`,
-        modifyUserPrompt: (prompt) => `Modify workflow: ${prompt}`,
-    };
-}
-function createWorkflowGenerationTool(registry) {
-    return {
-        name: 'generate_workflow',
-        description: `Generate a workflow following the Eko framework DSL schema.
-The workflow must only use the available tools and ensure proper dependencies between nodes.`,
-        input_schema: {
-            type: 'object',
-            properties: {
-                workflow: registry.getWorkflowSchema(),
-            },
-            required: ['workflow'],
-        },
-    };
-}
-
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-    byteToHex.push((i + 0x100).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-    return (byteToHex[arr[offset + 0]] +
-        byteToHex[arr[offset + 1]] +
-        byteToHex[arr[offset + 2]] +
-        byteToHex[arr[offset + 3]] +
-        '-' +
-        byteToHex[arr[offset + 4]] +
-        byteToHex[arr[offset + 5]] +
-        '-' +
-        byteToHex[arr[offset + 6]] +
-        byteToHex[arr[offset + 7]] +
-        '-' +
-        byteToHex[arr[offset + 8]] +
-        byteToHex[arr[offset + 9]] +
-        '-' +
-        byteToHex[arr[offset + 10]] +
-        byteToHex[arr[offset + 11]] +
-        byteToHex[arr[offset + 12]] +
-        byteToHex[arr[offset + 13]] +
-        byteToHex[arr[offset + 14]] +
-        byteToHex[arr[offset + 15]]).toLowerCase();
-}
-
-let getRandomValues;
-const rnds8 = new Uint8Array(16);
-function rng() {
-    if (!getRandomValues) {
-        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
-            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
-        }
-        getRandomValues = crypto.getRandomValues.bind(crypto);
+};
+let APIConnectionError$1 = class APIConnectionError extends APIError$1 {
+    constructor({ message, cause }) {
+        super(undefined, undefined, message || 'Connection error.', undefined);
+        // in some environments the 'cause' property is already declared
+        // @ts-ignore
+        if (cause)
+            this.cause = cause;
     }
-    return getRandomValues(rnds8);
-}
-
-const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-var native = { randomUUID };
-
-function v4(options, buf, offset) {
-    if (native.randomUUID && !buf && !options) {
-        return native.randomUUID();
+};
+let APIConnectionTimeoutError$1 = class APIConnectionTimeoutError extends APIConnectionError$1 {
+    constructor({ message } = {}) {
+        super({ message: message ?? 'Request timed out.' });
     }
-    options = options || {};
-    const rnds = options.random || (options.rng || rng)();
-    rnds[6] = (rnds[6] & 0x0f) | 0x40;
-    rnds[8] = (rnds[8] & 0x3f) | 0x80;
-    return unsafeStringify(rnds);
-}
+};
+let BadRequestError$1 = class BadRequestError extends APIError$1 {
+};
+let AuthenticationError$1 = class AuthenticationError extends APIError$1 {
+};
+let PermissionDeniedError$1 = class PermissionDeniedError extends APIError$1 {
+};
+let NotFoundError$1 = class NotFoundError extends APIError$1 {
+};
+let ConflictError$1 = class ConflictError extends APIError$1 {
+};
+let UnprocessableEntityError$1 = class UnprocessableEntityError extends APIError$1 {
+};
+let RateLimitError$1 = class RateLimitError extends APIError$1 {
+};
+let InternalServerError$1 = class InternalServerError extends APIError$1 {
+};
 
-class WorkflowGenerator {
-    constructor(llmProvider, toolRegistry) {
-        this.llmProvider = llmProvider;
-        this.toolRegistry = toolRegistry;
-        this.message_history = [];
-    }
-    async generateWorkflow(prompt) {
-        return this.doGenerateWorkflow(prompt, false);
-    }
-    async modifyWorkflow(prompt) {
-        return this.doGenerateWorkflow(prompt, true);
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+let LineDecoder$1 = class LineDecoder {
+    constructor() {
+        this.buffer = [];
+        this.trailingCR = false;
     }
-    async doGenerateWorkflow(prompt, modify) {
-        // Create prompts with current set of tools
-        const prompts = createWorkflowPrompts(this.toolRegistry.getToolDefinitions());
-        let messages = [];
-        if (modify) {
-            messages = this.message_history;
-            messages.push({
-                role: 'user',
-                content: prompts.modifyUserPrompt(prompt),
-            });
+    decode(chunk) {
+        let text = this.decodeText(chunk);
+        if (this.trailingCR) {
+            text = '\r' + text;
+            this.trailingCR = false;
         }
-        else {
-            messages = this.message_history = [
-                {
-                    role: 'system',
-                    content: prompts.formatSystemPrompt(),
-                },
-                {
-                    role: 'user',
-                    content: prompts.formatUserPrompt(prompt),
-                },
-            ];
+        if (text.endsWith('\r')) {
+            this.trailingCR = true;
+            text = text.slice(0, -1);
         }
-        const params = {
-            temperature: 0.7,
-            maxTokens: 8192,
-            tools: [createWorkflowGenerationTool(this.toolRegistry)],
-            toolChoice: { type: 'tool', name: 'generate_workflow' },
-        };
-        const response = await this.llmProvider.generateText(messages, params);
-        if (!response.toolCalls.length || !response.toolCalls[0].input.workflow) {
-            messages.pop();
-            throw new Error('Failed to generate workflow: Invalid response from LLM');
+        if (!text) {
+            return [];
         }
-        messages.push({
-            role: 'assistant',
-            content: [
-                {
-                    type: 'tool_use',
-                    id: response.toolCalls[0].id,
-                    name: response.toolCalls[0].name,
-                    input: response.toolCalls[0].input,
-                },
-            ],
-        }, {
-            role: 'user',
-            content: [
-                {
-                    type: 'tool_result',
-                    tool_use_id: response.toolCalls[0].id,
-                    content: 'ok',
-                },
-            ],
-        });
-        const workflowData = response.toolCalls[0].input.workflow;
-        // Validate all tools exist
-        for (const node of workflowData.nodes) {
-            if (!this.toolRegistry.hasTools(node.action.tools)) {
-                throw new Error(`Workflow contains undefined tools: ${node.action.tools}`);
-            }
+        const trailingNewline = LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || '');
+        let lines = text.split(LineDecoder.NEWLINE_REGEXP);
+        // if there is a trailing new line then the last entry will be an empty
+        // string which we don't care about
+        if (trailingNewline) {
+            lines.pop();
         }
-        // Generate a new UUID if not provided
-        if (!workflowData.id) {
-            workflowData.id = v4();
+        if (lines.length === 1 && !trailingNewline) {
+            this.buffer.push(lines[0]);
+            return [];
         }
-        return this.createWorkflowFromData(workflowData);
-    }
-    createWorkflowFromData(data) {
-        const workflow = new WorkflowImpl(data.id, data.name, data.description || '', [], new Map(Object.entries(data.variables || {})), this.llmProvider);
-        // Add nodes to workflow
-        if (Array.isArray(data.nodes)) {
-            data.nodes.forEach((nodeData) => {
-                const tools = nodeData.action.tools.map((toolName) => this.toolRegistry.getTool(toolName));
-                const action = ActionImpl.createPromptAction(nodeData.action.name, nodeData.action.description, tools, this.llmProvider, { maxTokens: 1000 });
-                const node = {
-                    id: nodeData.id,
-                    name: nodeData.name || nodeData.id,
-                    input: nodeData.input || { type: 'any', schema: {}, value: undefined },
-                    output: nodeData.output || { type: 'any', schema: {}, value: undefined },
-                    action: action,
-                    dependencies: nodeData.dependencies || [],
-                };
-                workflow.addNode(node);
-            });
+        if (this.buffer.length > 0) {
+            lines = [this.buffer.join('') + lines[0], ...lines.slice(1)];
+            this.buffer = [];
         }
-        return workflow;
-    }
-}
-
-const VERSION$1 = '0.33.1'; // x-release-please-version
-
-let auto$1 = false;
-let kind$1 = undefined;
-let fetch$2 = undefined;
-let File$2 = undefined;
-let ReadableStream$2 = undefined;
-let getDefaultAgent$1 = undefined;
-let fileFromPath$1 = undefined;
-function setShims$1(shims, options = { auto: false }) {
-    if (auto$1) {
-        throw new Error(`you must \`import '@anthropic-ai/sdk/shims/${shims.kind}'\` before importing anything else from @anthropic-ai/sdk`);
-    }
-    if (kind$1) {
-        throw new Error(`can't \`import '@anthropic-ai/sdk/shims/${shims.kind}'\` after \`import '@anthropic-ai/sdk/shims/${kind$1}'\``);
-    }
-    auto$1 = options.auto;
-    kind$1 = shims.kind;
-    fetch$2 = shims.fetch;
-    File$2 = shims.File;
-    ReadableStream$2 = shims.ReadableStream;
-    getDefaultAgent$1 = shims.getDefaultAgent;
-    fileFromPath$1 = shims.fileFromPath;
-}
-
-/**
- * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
- */
-let MultipartBody$1 = class MultipartBody {
-    constructor(body) {
-        this.body = body;
-    }
-    get [Symbol.toStringTag]() {
-        return 'MultipartBody';
-    }
-};
-
-function getRuntime$1({ manuallyImported } = {}) {
-    const recommendation = manuallyImported ?
-        `You may need to use polyfills`
-        : `Add one of these imports before your first \`import … from '@anthropic-ai/sdk'\`:
-- \`import '@anthropic-ai/sdk/shims/node'\` (if you're running on Node)
-- \`import '@anthropic-ai/sdk/shims/web'\` (otherwise)
-`;
-    let _fetch, _Request, _Response, _Headers;
-    try {
-        // @ts-ignore
-        _fetch = fetch;
-        // @ts-ignore
-        _Request = Request;
-        // @ts-ignore
-        _Response = Response;
-        // @ts-ignore
-        _Headers = Headers;
-    }
-    catch (error) {
-        throw new Error(`this environment is missing the following Web Fetch API type: ${error.message}. ${recommendation}`);
-    }
-    return {
-        kind: 'web',
-        fetch: _fetch,
-        Request: _Request,
-        Response: _Response,
-        Headers: _Headers,
-        FormData: 
-        // @ts-ignore
-        typeof FormData !== 'undefined' ? FormData : (class FormData {
-            // @ts-ignore
-            constructor() {
-                throw new Error(`file uploads aren't supported in this environment yet as 'FormData' is undefined. ${recommendation}`);
-            }
-        }),
-        Blob: typeof Blob !== 'undefined' ? Blob : (class Blob {
-            constructor() {
-                throw new Error(`file uploads aren't supported in this environment yet as 'Blob' is undefined. ${recommendation}`);
-            }
-        }),
-        File: 
-        // @ts-ignore
-        typeof File !== 'undefined' ? File : (class File {
-            // @ts-ignore
-            constructor() {
-                throw new Error(`file uploads aren't supported in this environment yet as 'File' is undefined. ${recommendation}`);
-            }
-        }),
-        ReadableStream: 
-        // @ts-ignore
-        typeof ReadableStream !== 'undefined' ? ReadableStream : (class ReadableStream {
-            // @ts-ignore
-            constructor() {
-                throw new Error(`streaming isn't supported in this environment yet as 'ReadableStream' is undefined. ${recommendation}`);
-            }
-        }),
-        getMultipartRequestOptions: async (
-        // @ts-ignore
-        form, opts) => ({
-            ...opts,
-            body: new MultipartBody$1(form),
-        }),
-        getDefaultAgent: (url) => undefined,
-        fileFromPath: () => {
-            throw new Error('The `fileFromPath` function is only supported in Node. See the README for more details: https://www.github.com/anthropics/anthropic-sdk-typescript#file-uploads');
-        },
-        isFsReadStream: (value) => false,
-    };
-}
-
-/**
- * Disclaimer: modules in _shims aren't intended to be imported by SDK users.
- */
-if (!kind$1) setShims$1(getRuntime$1(), { auto: true });
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class AnthropicError extends Error {
-}
-let APIError$1 = class APIError extends AnthropicError {
-    constructor(status, error, message, headers) {
-        super(`${APIError.makeMessage(status, error, message)}`);
-        this.status = status;
-        this.headers = headers;
-        this.request_id = headers?.['request-id'];
-        this.error = error;
-    }
-    static makeMessage(status, error, message) {
-        const msg = error?.message ?
-            typeof error.message === 'string' ?
-                error.message
-                : JSON.stringify(error.message)
-            : error ? JSON.stringify(error)
-                : message;
-        if (status && msg) {
-            return `${status} ${msg}`;
-        }
-        if (status) {
-            return `${status} status code (no body)`;
-        }
-        if (msg) {
-            return msg;
-        }
-        return '(no status code or body)';
-    }
-    static generate(status, errorResponse, message, headers) {
-        if (!status || !headers) {
-            return new APIConnectionError$1({ message, cause: castToError$1(errorResponse) });
-        }
-        const error = errorResponse;
-        if (status === 400) {
-            return new BadRequestError$1(status, error, message, headers);
-        }
-        if (status === 401) {
-            return new AuthenticationError$1(status, error, message, headers);
-        }
-        if (status === 403) {
-            return new PermissionDeniedError$1(status, error, message, headers);
-        }
-        if (status === 404) {
-            return new NotFoundError$1(status, error, message, headers);
-        }
-        if (status === 409) {
-            return new ConflictError$1(status, error, message, headers);
-        }
-        if (status === 422) {
-            return new UnprocessableEntityError$1(status, error, message, headers);
-        }
-        if (status === 429) {
-            return new RateLimitError$1(status, error, message, headers);
-        }
-        if (status >= 500) {
-            return new InternalServerError$1(status, error, message, headers);
-        }
-        return new APIError(status, error, message, headers);
-    }
-};
-let APIUserAbortError$1 = class APIUserAbortError extends APIError$1 {
-    constructor({ message } = {}) {
-        super(undefined, undefined, message || 'Request was aborted.', undefined);
-    }
-};
-let APIConnectionError$1 = class APIConnectionError extends APIError$1 {
-    constructor({ message, cause }) {
-        super(undefined, undefined, message || 'Connection error.', undefined);
-        // in some environments the 'cause' property is already declared
-        // @ts-ignore
-        if (cause)
-            this.cause = cause;
-    }
-};
-let APIConnectionTimeoutError$1 = class APIConnectionTimeoutError extends APIConnectionError$1 {
-    constructor({ message } = {}) {
-        super({ message: message ?? 'Request timed out.' });
-    }
-};
-let BadRequestError$1 = class BadRequestError extends APIError$1 {
-};
-let AuthenticationError$1 = class AuthenticationError extends APIError$1 {
-};
-let PermissionDeniedError$1 = class PermissionDeniedError extends APIError$1 {
-};
-let NotFoundError$1 = class NotFoundError extends APIError$1 {
-};
-let ConflictError$1 = class ConflictError extends APIError$1 {
-};
-let UnprocessableEntityError$1 = class UnprocessableEntityError extends APIError$1 {
-};
-let RateLimitError$1 = class RateLimitError extends APIError$1 {
-};
-let InternalServerError$1 = class InternalServerError extends APIError$1 {
-};
-
-/**
- * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
- * reading lines from text.
- *
- * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
- */
-let LineDecoder$1 = class LineDecoder {
-    constructor() {
-        this.buffer = [];
-        this.trailingCR = false;
-    }
-    decode(chunk) {
-        let text = this.decodeText(chunk);
-        if (this.trailingCR) {
-            text = '\r' + text;
-            this.trailingCR = false;
-        }
-        if (text.endsWith('\r')) {
-            this.trailingCR = true;
-            text = text.slice(0, -1);
-        }
-        if (!text) {
-            return [];
-        }
-        const trailingNewline = LineDecoder.NEWLINE_CHARS.has(text[text.length - 1] || '');
-        let lines = text.split(LineDecoder.NEWLINE_REGEXP);
-        // if there is a trailing new line then the last entry will be an empty
-        // string which we don't care about
-        if (trailingNewline) {
-            lines.pop();
-        }
-        if (lines.length === 1 && !trailingNewline) {
-            this.buffer.push(lines[0]);
-            return [];
-        }
-        if (this.buffer.length > 0) {
-            lines = [this.buffer.join('') + lines[0], ...lines.slice(1)];
-            this.buffer = [];
-        }
-        if (!trailingNewline) {
-            this.buffer = [lines.pop() || ''];
-        }
-        return lines;
+        if (!trailingNewline) {
+            this.buffer = [lines.pop() || ''];
+        }
+        return lines;
     }
     decodeText(bytes) {
         if (bytes == null)
@@ -1043,7 +365,7 @@ let Stream$1 = class Stream {
         let consumed = false;
         async function* iterLines() {
             const lineDecoder = new LineDecoder$1();
-            const iter = readableStreamAsyncIterable$1(readableStream);
+            const iter = readableStreamAsyncIterable(readableStream);
             for await (const chunk of iter) {
                 for (const line of lineDecoder.decode(chunk)) {
                     yield line;
@@ -1148,7 +470,7 @@ async function* _iterSSEMessages$1(response, controller) {
     }
     const sseDecoder = new SSEDecoder$1();
     const lineDecoder = new LineDecoder$1();
-    const iter = readableStreamAsyncIterable$1(response.body);
+    const iter = readableStreamAsyncIterable(response.body);
     for await (const sseChunk of iterSSEChunks$1(iter)) {
         for (const line of lineDecoder.decode(sseChunk)) {
             const sse = sseDecoder.decode(line);
@@ -1269,7 +591,7 @@ function partition$1(str, delimiter) {
  *
  * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
  */
-function readableStreamAsyncIterable$1(stream) {
+function readableStreamAsyncIterable(stream) {
     if (stream[Symbol.asyncIterator])
         return stream;
     const reader = stream.getReader();
@@ -1832,7 +1154,7 @@ let APIClient$1 = class APIClient {
 };
 let AbstractPage$1 = class AbstractPage {
     constructor(client, response, body, options) {
-        _AbstractPage_client$1.set(this, void 0);
+        _AbstractPage_client$1.set(this, undefined);
         __classPrivateFieldSet$5(this, _AbstractPage_client$1, client, "f");
         this.options = options;
         this.response = response;
@@ -2311,7 +1633,7 @@ class JSONLDecoder {
             controller.abort();
             throw new AnthropicError(`Attempted to iterate over a response with no body`);
         }
-        return new JSONLDecoder(readableStreamAsyncIterable$1(response.body), controller);
+        return new JSONLDecoder(readableStreamAsyncIterable(response.body), controller);
     }
 }
 
@@ -2763,12 +2085,12 @@ class MessageStream {
         _MessageStream_instances.add(this);
         this.messages = [];
         this.receivedMessages = [];
-        _MessageStream_currentMessageSnapshot.set(this, void 0);
+        _MessageStream_currentMessageSnapshot.set(this, undefined);
         this.controller = new AbortController();
-        _MessageStream_connectedPromise.set(this, void 0);
+        _MessageStream_connectedPromise.set(this, undefined);
         _MessageStream_resolveConnectedPromise.set(this, () => { });
         _MessageStream_rejectConnectedPromise.set(this, () => { });
-        _MessageStream_endPromise.set(this, void 0);
+        _MessageStream_endPromise.set(this, undefined);
         _MessageStream_resolveEndPromise.set(this, () => { });
         _MessageStream_rejectEndPromise.set(this, () => { });
         _MessageStream_listeners.set(this, {});
@@ -3391,14 +2713,14 @@ class ClaudeProvider {
         if (typeof window !== 'undefined' &&
             typeof document !== 'undefined' &&
             (typeof param == 'string' || param.apiKey)) {
-            console.warn(`
-        ⚠️ Security Warning:
-        DO NOT use API Keys in browser/frontend code!
-        This will expose your credentials and may lead to unauthorized usage.
-        
-        Best Practices: Configure backend API proxy request through baseURL and request headers.
-
-        Please refer to the link: https://eko.fellou.ai/docs/getting-started/configuration#web-environment
+            console.warn(`
+        ⚠️ Security Warning:
+        DO NOT use API Keys in browser/frontend code!
+        This will expose your credentials and may lead to unauthorized usage.
+        
+        Best Practices: Configure backend API proxy request through baseURL and request headers.
+
+        Please refer to the link: https://eko.fellou.ai/docs/getting-started/configuration#web-environment
       `);
         }
         if (typeof param == 'string') {
@@ -3408,8 +2730,13 @@ class ClaudeProvider {
                 ...options,
             });
         }
+        else if (param.messages && param.completions) {
+            this.client = param;
+        }
         else {
-            this.client = new Anthropic(param);
+            let options = param;
+            options.dangerouslyAllowBrowser = true;
+            this.client = new Anthropic(options);
         }
     }
     processResponse(response) {
@@ -3445,7 +2772,7 @@ class ClaudeProvider {
         const response = await this.client.messages.create({
             system,
             model: params.model || this.defaultModel,
-            max_tokens: params.maxTokens || 1024,
+            max_tokens: params.maxTokens || 8192,
             temperature: params.temperature,
             messages: messages.filter((s) => s.role != 'system'),
             tools: params.tools,
@@ -3468,13 +2795,13 @@ class ClaudeProvider {
         const stream = await this.client.messages.stream({
             system,
             model: params.model || this.defaultModel,
-            max_tokens: params.maxTokens || 4096,
+            max_tokens: params.maxTokens || 8192,
             temperature: params.temperature,
             messages: messages.filter((s) => s.role != 'system'),
             tools: params.tools,
             tool_choice: params.toolChoice,
         });
-        (_a = handler.onStart) === null || _a === void 0 ? void 0 : _a.call(handler);
+        (_a = handler.onStart) === null || _a === undefined ? undefined : _a.call(handler);
         let currentToolUse = null;
         try {
             for await (const event of stream) {
@@ -3516,7 +2843,7 @@ class ClaudeProvider {
             (_e = handler.onComplete) === null || _e === void 0 ? void 0 : _e.call(handler, this.processResponse(message));
         }
         catch (error) {
-            (_f = handler.onError) === null || _f === void 0 ? void 0 : _f.call(handler, error);
+            (_f = handler.onError) === null || _f === undefined ? undefined : _f.call(handler, error);
         }
     }
 }
@@ -3669,7 +2996,7 @@ function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, al
     let tmp_sc = sideChannel;
     let step = 0;
     let find_flag = false;
-    while ((tmp_sc = tmp_sc.get(sentinel)) !== void undefined && !find_flag) {
+    while ((tmp_sc = tmp_sc.get(sentinel)) !== undefined && !find_flag) {
         // Where object last appeared in the ref tree
         const pos = tmp_sc.get(object);
         step += 1;
@@ -3733,7 +3060,7 @@ function inner_stringify(object, prefix, generateArrayPrefix, commaRoundTrip, al
             // @ts-expect-error values only
             obj = maybe_map(obj, encoder);
         }
-        obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : void undefined }];
+        obj_keys = [{ value: obj.length > 0 ? obj.join(',') || null : undefined }];
     }
     else if (is_array(filter)) {
         obj_keys = filter;
@@ -3889,7 +3216,7 @@ function stringify(object, opts = {}) {
     return joined.length > 0 ? prefix + joined : '';
 }
 
-const VERSION = '4.77.0'; // x-release-please-version
+const VERSION = '4.79.4'; // x-release-please-version
 
 let auto = false;
 let kind = undefined;
@@ -4201,13 +3528,48 @@ class LineDecoder {
 LineDecoder.NEWLINE_CHARS = new Set(['\n', '\r']);
 LineDecoder.NEWLINE_REGEXP = /\r\n|[\n\r]/g;
 
-class Stream {
-    constructor(iterator, controller) {
-        this.iterator = iterator;
-        this.controller = controller;
-    }
-    static fromSSEResponse(response, controller) {
-        let consumed = false;
+/**
+ * Most browsers don't yet have async iterable support for ReadableStream,
+ * and Node has a very different way of reading bytes from its "ReadableStream".
+ *
+ * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
+ */
+function ReadableStreamToAsyncIterable(stream) {
+    if (stream[Symbol.asyncIterator])
+        return stream;
+    const reader = stream.getReader();
+    return {
+        async next() {
+            try {
+                const result = await reader.read();
+                if (result?.done)
+                    reader.releaseLock(); // release lock when stream becomes closed
+                return result;
+            }
+            catch (e) {
+                reader.releaseLock(); // release lock when stream becomes errored
+                throw e;
+            }
+        },
+        async return() {
+            const cancelPromise = reader.cancel();
+            reader.releaseLock();
+            await cancelPromise;
+            return { done: true, value: undefined };
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+
+class Stream {
+    constructor(iterator, controller) {
+        this.iterator = iterator;
+        this.controller = controller;
+    }
+    static fromSSEResponse(response, controller) {
+        let consumed = false;
         async function* iterator() {
             if (consumed) {
                 throw new Error('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
@@ -4278,7 +3640,7 @@ class Stream {
         let consumed = false;
         async function* iterLines() {
             const lineDecoder = new LineDecoder();
-            const iter = readableStreamAsyncIterable(readableStream);
+            const iter = ReadableStreamToAsyncIterable(readableStream);
             for await (const chunk of iter) {
                 for (const line of lineDecoder.decode(chunk)) {
                     yield line;
@@ -4383,7 +3745,7 @@ async function* _iterSSEMessages(response, controller) {
     }
     const sseDecoder = new SSEDecoder();
     const lineDecoder = new LineDecoder();
-    const iter = readableStreamAsyncIterable(response.body);
+    const iter = ReadableStreamToAsyncIterable(response.body);
     for await (const sseChunk of iterSSEChunks(iter)) {
         for (const line of lineDecoder.decode(sseChunk)) {
             const sse = sseDecoder.decode(line);
@@ -4498,40 +3860,6 @@ function partition(str, delimiter) {
     }
     return [str, '', ''];
 }
-/**
- * Most browsers don't yet have async iterable support for ReadableStream,
- * and Node has a very different way of reading bytes from its "ReadableStream".
- *
- * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
- */
-function readableStreamAsyncIterable(stream) {
-    if (stream[Symbol.asyncIterator])
-        return stream;
-    const reader = stream.getReader();
-    return {
-        async next() {
-            try {
-                const result = await reader.read();
-                if (result?.done)
-                    reader.releaseLock(); // release lock when stream becomes closed
-                return result;
-            }
-            catch (e) {
-                reader.releaseLock(); // release lock when stream becomes errored
-                throw e;
-            }
-        },
-        async return() {
-            const cancelPromise = reader.cancel();
-            reader.releaseLock();
-            await cancelPromise;
-            return { done: true, value: undefined };
-        },
-        [Symbol.asyncIterator]() {
-            return this;
-        },
-    };
-}
 
 const isResponseLike = (value) => value != null &&
     typeof value === 'object' &&
@@ -5030,9 +4358,18 @@ class APIClient {
         if (signal)
             signal.addEventListener('abort', () => controller.abort());
         const timeout = setTimeout(() => controller.abort(), ms);
+        const fetchOptions = {
+            signal: controller.signal,
+            ...options,
+        };
+        if (fetchOptions.method) {
+            // Custom methods like 'patch' need to be uppercased
+            // See https://github.com/nodejs/undici/issues/2294
+            fetchOptions.method = fetchOptions.method.toUpperCase();
+        }
         return (
         // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
-        this.fetch.call(undefined, url, { signal: controller.signal, ...options }).finally(() => {
+        this.fetch.call(undefined, url, fetchOptions).finally(() => {
             clearTimeout(timeout);
         }));
     }
@@ -5104,7 +4441,7 @@ class APIClient {
 }
 class AbstractPage {
     constructor(client, response, body, options) {
-        _AbstractPage_client.set(this, void 0);
+        _AbstractPage_client.set(this, undefined);
         __classPrivateFieldSet$3(this, _AbstractPage_client, client, "f");
         this.options = options;
         this.response = response;
@@ -5427,9 +4764,36 @@ function applyHeadersMut(targetHeaders, newHeaders) {
         }
     }
 }
+const SENSITIVE_HEADERS = new Set(['authorization', 'api-key']);
 function debug(action, ...args) {
     if (typeof process !== 'undefined' && process?.env?.['DEBUG'] === 'true') {
-        console.log(`OpenAI:DEBUG:${action}`, ...args);
+        const modifiedArgs = args.map((arg) => {
+            if (!arg) {
+                return arg;
+            }
+            // Check for sensitive headers in request body 'headers' object
+            if (arg['headers']) {
+                // clone so we don't mutate
+                const modifiedArg = { ...arg, headers: { ...arg['headers'] } };
+                for (const header in arg['headers']) {
+                    if (SENSITIVE_HEADERS.has(header.toLowerCase())) {
+                        modifiedArg['headers'][header] = 'REDACTED';
+                    }
+                }
+                return modifiedArg;
+            }
+            let modifiedArg = null;
+            // Check for sensitive headers in headers object
+            for (const header in arg) {
+                if (SENSITIVE_HEADERS.has(header.toLowerCase())) {
+                    // avoid making a copy until we need to
+                    modifiedArg ?? (modifiedArg = { ...arg });
+                    modifiedArg[header] = 'REDACTED';
+                }
+            }
+            return modifiedArg ?? arg;
+        });
+        console.log(`OpenAI:DEBUG:${action}`, ...modifiedArgs);
     }
 }
 /**
@@ -5571,7 +4935,12 @@ class Speech extends APIResource {
      * Generates audio from the input text.
      */
     create(body, options) {
-        return this._client.post('/audio/speech', { body, ...options, __binaryResponse: true });
+        return this._client.post('/audio/speech', {
+            body,
+            ...options,
+            headers: { Accept: 'application/octet-stream', ...options?.headers },
+            __binaryResponse: true,
+        });
     }
 }
 
@@ -5720,10 +5089,10 @@ class EventStream {
     constructor() {
         _EventStream_instances.add(this);
         this.controller = new AbortController();
-        _EventStream_connectedPromise.set(this, void 0);
+        _EventStream_connectedPromise.set(this, undefined);
         _EventStream_resolveConnectedPromise.set(this, () => { });
         _EventStream_rejectConnectedPromise.set(this, () => { });
-        _EventStream_endPromise.set(this, void 0);
+        _EventStream_endPromise.set(this, undefined);
         _EventStream_resolveEndPromise.set(this, () => { });
         _EventStream_rejectEndPromise.set(this, () => { });
         _EventStream_listeners.set(this, {});
@@ -6634,9 +6003,9 @@ class ChatCompletionStream extends AbstractChatCompletionRunner {
     constructor(params) {
         super();
         _ChatCompletionStream_instances.add(this);
-        _ChatCompletionStream_params.set(this, void 0);
-        _ChatCompletionStream_choiceEventStates.set(this, void 0);
-        _ChatCompletionStream_currentChatCompletionSnapshot.set(this, void 0);
+        _ChatCompletionStream_params.set(this, undefined);
+        _ChatCompletionStream_choiceEventStates.set(this, undefined);
+        _ChatCompletionStream_currentChatCompletionSnapshot.set(this, undefined);
         __classPrivateFieldSet$1(this, _ChatCompletionStream_params, params, "f");
         __classPrivateFieldSet$1(this, _ChatCompletionStream_choiceEventStates, [], "f");
     }
@@ -7174,7 +6543,36 @@ class Chat extends APIResource {
 }
 (function (Chat) {
     Chat.Completions = Completions$1;
-})(Chat || (Chat = {}));
+})(Chat);
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Sessions extends APIResource {
+    /**
+     * Create an ephemeral API token for use in client-side applications with the
+     * Realtime API. Can be configured with the same session parameters as the
+     * `session.update` client event.
+     *
+     * It responds with a session object, plus a `client_secret` key which contains a
+     * usable ephemeral API token that can be used to authenticate browser clients for
+     * the Realtime API.
+     */
+    create(body, options) {
+        return this._client.post('/realtime/sessions', {
+            body,
+            ...options,
+            headers: { 'OpenAI-Beta': 'assistants=v2', ...options?.headers },
+        });
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Realtime extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.sessions = new Sessions(this._client);
+    }
+}
+Realtime.Sessions = Sessions;
 
 var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
@@ -7198,16 +6596,16 @@ class AssistantStream extends EventStream {
         //We are accumulating many types so the value here is not strict
         _AssistantStream_runStepSnapshots.set(this, {});
         _AssistantStream_messageSnapshots.set(this, {});
-        _AssistantStream_messageSnapshot.set(this, void 0);
-        _AssistantStream_finalRun.set(this, void 0);
-        _AssistantStream_currentContentIndex.set(this, void 0);
-        _AssistantStream_currentContent.set(this, void 0);
-        _AssistantStream_currentToolCallIndex.set(this, void 0);
-        _AssistantStream_currentToolCall.set(this, void 0);
+        _AssistantStream_messageSnapshot.set(this, undefined);
+        _AssistantStream_finalRun.set(this, undefined);
+        _AssistantStream_currentContentIndex.set(this, undefined);
+        _AssistantStream_currentContent.set(this, undefined);
+        _AssistantStream_currentToolCallIndex.set(this, undefined);
+        _AssistantStream_currentToolCall.set(this, undefined);
         //For current snapshot methods
-        _AssistantStream_currentEvent.set(this, void 0);
-        _AssistantStream_currentRunSnapshot.set(this, void 0);
-        _AssistantStream_currentRunStepSnapshot.set(this, void 0);
+        _AssistantStream_currentEvent.set(this, undefined);
+        _AssistantStream_currentRunSnapshot.set(this, undefined);
+        _AssistantStream_currentRunStepSnapshot.set(this, undefined);
     }
     [(_AssistantStream_events = new WeakMap(), _AssistantStream_runStepSnapshots = new WeakMap(), _AssistantStream_messageSnapshots = new WeakMap(), _AssistantStream_messageSnapshot = new WeakMap(), _AssistantStream_finalRun = new WeakMap(), _AssistantStream_currentContentIndex = new WeakMap(), _AssistantStream_currentContent = new WeakMap(), _AssistantStream_currentToolCallIndex = new WeakMap(), _AssistantStream_currentToolCall = new WeakMap(), _AssistantStream_currentEvent = new WeakMap(), _AssistantStream_currentRunSnapshot = new WeakMap(), _AssistantStream_currentRunStepSnapshot = new WeakMap(), _AssistantStream_instances = new WeakSet(), Symbol.asyncIterator)]() {
         const pushQueue = [];
@@ -8353,12 +7751,14 @@ VectorStores.FileBatches = FileBatches;
 class Beta extends APIResource {
     constructor() {
         super(...arguments);
+        this.realtime = new Realtime(this._client);
         this.vectorStores = new VectorStores(this._client);
         this.chat = new Chat(this._client);
         this.assistants = new Assistants(this._client);
         this.threads = new Threads(this._client);
     }
 }
+Beta.Realtime = Realtime;
 Beta.VectorStores = VectorStores;
 Beta.VectorStoresPage = VectorStoresPage;
 Beta.Assistants = Assistants;
@@ -8432,7 +7832,11 @@ class Files extends APIResource {
      * Returns the contents of the specified file.
      */
     content(fileId, options) {
-        return this._client.get(`/files/${fileId}/content`, { ...options, __binaryResponse: true });
+        return this._client.get(`/files/${fileId}/content`, {
+            ...options,
+            headers: { Accept: 'application/binary', ...options?.headers },
+            __binaryResponse: true,
+        });
     }
     /**
      * Returns the contents of the specified file.
@@ -8440,10 +7844,7 @@ class Files extends APIResource {
      * @deprecated The `.content()` method should be used instead
      */
     retrieveContent(fileId, options) {
-        return this._client.get(`/files/${fileId}/content`, {
-            ...options,
-            headers: { Accept: 'application/json', ...options?.headers },
-        });
+        return this._client.get(`/files/${fileId}/content`, options);
     }
     /**
      * Waits for the given file to be processed, default timeout is 30 mins.
@@ -8461,660 +7862,1698 @@ class Files extends APIResource {
                 });
             }
         }
-        return file;
+        return file;
+    }
+}
+class FileObjectsPage extends CursorPage {
+}
+Files.FileObjectsPage = FileObjectsPage;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Checkpoints extends APIResource {
+    list(fineTuningJobId, query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list(fineTuningJobId, {}, query);
+        }
+        return this._client.getAPIList(`/fine_tuning/jobs/${fineTuningJobId}/checkpoints`, FineTuningJobCheckpointsPage, { query, ...options });
+    }
+}
+class FineTuningJobCheckpointsPage extends CursorPage {
+}
+Checkpoints.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Jobs extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.checkpoints = new Checkpoints(this._client);
+    }
+    /**
+     * Creates a fine-tuning job which begins the process of creating a new model from
+     * a given dataset.
+     *
+     * Response includes details of the enqueued job including job status and the name
+     * of the fine-tuned models once complete.
+     *
+     * [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+     */
+    create(body, options) {
+        return this._client.post('/fine_tuning/jobs', { body, ...options });
+    }
+    /**
+     * Get info about a fine-tuning job.
+     *
+     * [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
+     */
+    retrieve(fineTuningJobId, options) {
+        return this._client.get(`/fine_tuning/jobs/${fineTuningJobId}`, options);
+    }
+    list(query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.list({}, query);
+        }
+        return this._client.getAPIList('/fine_tuning/jobs', FineTuningJobsPage, { query, ...options });
+    }
+    /**
+     * Immediately cancel a fine-tune job.
+     */
+    cancel(fineTuningJobId, options) {
+        return this._client.post(`/fine_tuning/jobs/${fineTuningJobId}/cancel`, options);
+    }
+    listEvents(fineTuningJobId, query = {}, options) {
+        if (isRequestOptions(query)) {
+            return this.listEvents(fineTuningJobId, {}, query);
+        }
+        return this._client.getAPIList(`/fine_tuning/jobs/${fineTuningJobId}/events`, FineTuningJobEventsPage, {
+            query,
+            ...options,
+        });
+    }
+}
+class FineTuningJobsPage extends CursorPage {
+}
+class FineTuningJobEventsPage extends CursorPage {
+}
+Jobs.FineTuningJobsPage = FineTuningJobsPage;
+Jobs.FineTuningJobEventsPage = FineTuningJobEventsPage;
+Jobs.Checkpoints = Checkpoints;
+Jobs.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class FineTuning extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.jobs = new Jobs(this._client);
+    }
+}
+FineTuning.Jobs = Jobs;
+FineTuning.FineTuningJobsPage = FineTuningJobsPage;
+FineTuning.FineTuningJobEventsPage = FineTuningJobEventsPage;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Images extends APIResource {
+    /**
+     * Creates a variation of a given image.
+     */
+    createVariation(body, options) {
+        return this._client.post('/images/variations', multipartFormRequestOptions({ body, ...options }));
+    }
+    /**
+     * Creates an edited or extended image given an original image and a prompt.
+     */
+    edit(body, options) {
+        return this._client.post('/images/edits', multipartFormRequestOptions({ body, ...options }));
+    }
+    /**
+     * Creates an image given a prompt.
+     */
+    generate(body, options) {
+        return this._client.post('/images/generations', { body, ...options });
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Models extends APIResource {
+    /**
+     * Retrieves a model instance, providing basic information about the model such as
+     * the owner and permissioning.
+     */
+    retrieve(model, options) {
+        return this._client.get(`/models/${model}`, options);
+    }
+    /**
+     * Lists the currently available models, and provides basic information about each
+     * one such as the owner and availability.
+     */
+    list(options) {
+        return this._client.getAPIList('/models', ModelsPage, options);
+    }
+    /**
+     * Delete a fine-tuned model. You must have the Owner role in your organization to
+     * delete a model.
+     */
+    del(model, options) {
+        return this._client.delete(`/models/${model}`, options);
+    }
+}
+/**
+ * Note: no pagination actually occurs yet, this is for forwards-compatibility.
+ */
+class ModelsPage extends Page {
+}
+Models.ModelsPage = ModelsPage;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Moderations extends APIResource {
+    /**
+     * Classifies if text and/or image inputs are potentially harmful. Learn more in
+     * the [moderation guide](https://platform.openai.com/docs/guides/moderation).
+     */
+    create(body, options) {
+        return this._client.post('/moderations', { body, ...options });
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Parts extends APIResource {
+    /**
+     * Adds a
+     * [Part](https://platform.openai.com/docs/api-reference/uploads/part-object) to an
+     * [Upload](https://platform.openai.com/docs/api-reference/uploads/object) object.
+     * A Part represents a chunk of bytes from the file you are trying to upload.
+     *
+     * Each Part can be at most 64 MB, and you can add Parts until you hit the Upload
+     * maximum of 8 GB.
+     *
+     * It is possible to add multiple Parts in parallel. You can decide the intended
+     * order of the Parts when you
+     * [complete the Upload](https://platform.openai.com/docs/api-reference/uploads/complete).
+     */
+    create(uploadId, body, options) {
+        return this._client.post(`/uploads/${uploadId}/parts`, multipartFormRequestOptions({ body, ...options }));
+    }
+}
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class Uploads extends APIResource {
+    constructor() {
+        super(...arguments);
+        this.parts = new Parts(this._client);
+    }
+    /**
+     * Creates an intermediate
+     * [Upload](https://platform.openai.com/docs/api-reference/uploads/object) object
+     * that you can add
+     * [Parts](https://platform.openai.com/docs/api-reference/uploads/part-object) to.
+     * Currently, an Upload can accept at most 8 GB in total and expires after an hour
+     * after you create it.
+     *
+     * Once you complete the Upload, we will create a
+     * [File](https://platform.openai.com/docs/api-reference/files/object) object that
+     * contains all the parts you uploaded. This File is usable in the rest of our
+     * platform as a regular File object.
+     *
+     * For certain `purpose`s, the correct `mime_type` must be specified. Please refer
+     * to documentation for the supported MIME types for your use case:
+     *
+     * - [Assistants](https://platform.openai.com/docs/assistants/tools/file-search#supported-files)
+     *
+     * For guidance on the proper filename extensions for each purpose, please follow
+     * the documentation on
+     * [creating a File](https://platform.openai.com/docs/api-reference/files/create).
+     */
+    create(body, options) {
+        return this._client.post('/uploads', { body, ...options });
+    }
+    /**
+     * Cancels the Upload. No Parts may be added after an Upload is cancelled.
+     */
+    cancel(uploadId, options) {
+        return this._client.post(`/uploads/${uploadId}/cancel`, options);
+    }
+    /**
+     * Completes the
+     * [Upload](https://platform.openai.com/docs/api-reference/uploads/object).
+     *
+     * Within the returned Upload object, there is a nested
+     * [File](https://platform.openai.com/docs/api-reference/files/object) object that
+     * is ready to use in the rest of the platform.
+     *
+     * You can specify the order of the Parts by passing in an ordered list of the Part
+     * IDs.
+     *
+     * The number of bytes uploaded upon completion must match the number of bytes
+     * initially specified when creating the Upload object. No Parts may be added after
+     * an Upload is completed.
+     */
+    complete(uploadId, body, options) {
+        return this._client.post(`/uploads/${uploadId}/complete`, { body, ...options });
+    }
+}
+Uploads.Parts = Parts;
+
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+var _a;
+/**
+ * API Client for interfacing with the OpenAI API.
+ */
+class OpenAI extends APIClient {
+    /**
+     * API Client for interfacing with the OpenAI API.
+     *
+     * @param {string | undefined} [opts.apiKey=process.env['OPENAI_API_KEY'] ?? undefined]
+     * @param {string | null | undefined} [opts.organization=process.env['OPENAI_ORG_ID'] ?? null]
+     * @param {string | null | undefined} [opts.project=process.env['OPENAI_PROJECT_ID'] ?? null]
+     * @param {string} [opts.baseURL=process.env['OPENAI_BASE_URL'] ?? https://api.openai.com/v1] - Override the default base URL for the API.
+     * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+     * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
+     * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+     * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
+     * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
+     */
+    constructor({ baseURL = readEnv('OPENAI_BASE_URL'), apiKey = readEnv('OPENAI_API_KEY'), organization = readEnv('OPENAI_ORG_ID') ?? null, project = readEnv('OPENAI_PROJECT_ID') ?? null, ...opts } = {}) {
+        if (apiKey === undefined) {
+            throw new OpenAIError("The OPENAI_API_KEY environment variable is missing or empty; either provide it, or instantiate the OpenAI client with an apiKey option, like new OpenAI({ apiKey: 'My API Key' }).");
+        }
+        const options = {
+            apiKey,
+            organization,
+            project,
+            ...opts,
+            baseURL: baseURL || `https://api.openai.com/v1`,
+        };
+        if (!options.dangerouslyAllowBrowser && isRunningInBrowser()) {
+            throw new OpenAIError("It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew OpenAI({ apiKey, dangerouslyAllowBrowser: true });\n\nhttps://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n");
+        }
+        super({
+            baseURL: options.baseURL,
+            timeout: options.timeout ?? 600000 /* 10 minutes */,
+            httpAgent: options.httpAgent,
+            maxRetries: options.maxRetries,
+            fetch: options.fetch,
+        });
+        this.completions = new Completions(this);
+        this.chat = new Chat$1(this);
+        this.embeddings = new Embeddings(this);
+        this.files = new Files(this);
+        this.images = new Images(this);
+        this.audio = new Audio(this);
+        this.moderations = new Moderations(this);
+        this.models = new Models(this);
+        this.fineTuning = new FineTuning(this);
+        this.beta = new Beta(this);
+        this.batches = new Batches(this);
+        this.uploads = new Uploads(this);
+        this._options = options;
+        this.apiKey = apiKey;
+        this.organization = organization;
+        this.project = project;
+    }
+    defaultQuery() {
+        return this._options.defaultQuery;
+    }
+    defaultHeaders(opts) {
+        return {
+            ...super.defaultHeaders(opts),
+            'OpenAI-Organization': this.organization,
+            'OpenAI-Project': this.project,
+            ...this._options.defaultHeaders,
+        };
+    }
+    authHeaders(opts) {
+        return { Authorization: `Bearer ${this.apiKey}` };
+    }
+    stringifyQuery(query) {
+        return stringify(query, { arrayFormat: 'brackets' });
+    }
+}
+_a = OpenAI;
+OpenAI.OpenAI = _a;
+OpenAI.DEFAULT_TIMEOUT = 600000; // 10 minutes
+OpenAI.OpenAIError = OpenAIError;
+OpenAI.APIError = APIError;
+OpenAI.APIConnectionError = APIConnectionError;
+OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
+OpenAI.APIUserAbortError = APIUserAbortError;
+OpenAI.NotFoundError = NotFoundError;
+OpenAI.ConflictError = ConflictError;
+OpenAI.RateLimitError = RateLimitError;
+OpenAI.BadRequestError = BadRequestError;
+OpenAI.AuthenticationError = AuthenticationError;
+OpenAI.InternalServerError = InternalServerError;
+OpenAI.PermissionDeniedError = PermissionDeniedError;
+OpenAI.UnprocessableEntityError = UnprocessableEntityError;
+OpenAI.toFile = toFile;
+OpenAI.fileFromPath = fileFromPath;
+OpenAI.Completions = Completions;
+OpenAI.Chat = Chat$1;
+OpenAI.Embeddings = Embeddings;
+OpenAI.Files = Files;
+OpenAI.FileObjectsPage = FileObjectsPage;
+OpenAI.Images = Images;
+OpenAI.Audio = Audio;
+OpenAI.Moderations = Moderations;
+OpenAI.Models = Models;
+OpenAI.ModelsPage = ModelsPage;
+OpenAI.FineTuning = FineTuning;
+OpenAI.Beta = Beta;
+OpenAI.Batches = Batches;
+OpenAI.BatchesPage = BatchesPage;
+OpenAI.Uploads = Uploads;
+
+class OpenaiProvider {
+    constructor(param, defaultModel, options) {
+        this.defaultModel = 'gpt-4o';
+        if (defaultModel) {
+            this.defaultModel = defaultModel;
+        }
+        if (typeof window !== 'undefined' &&
+            typeof document !== 'undefined' &&
+            (typeof param == 'string' || param.apiKey)) {
+            console.warn(`
+        ⚠️ Security Warning:
+        DO NOT use API Keys in browser/frontend code!
+        This will expose your credentials and may lead to unauthorized usage.
+        
+        Best Practices: Configure backend API proxy request through baseURL and request headers.
+
+        Please refer to the link: https://eko.fellou.ai/docs/getting-started/configuration#web-environment
+      `);
+        }
+        if (typeof param == 'string') {
+            this.client = new OpenAI({
+                apiKey: param,
+                dangerouslyAllowBrowser: true,
+                ...options,
+            });
+        }
+        else if (param.chat && param.chat.completions) {
+            this.client = param;
+        }
+        else {
+            let options = param;
+            options.dangerouslyAllowBrowser = true;
+            this.client = new OpenAI(options);
+        }
+    }
+    buildParams(messages, params, stream) {
+        let tools = undefined;
+        if (params.tools && params.tools.length > 0) {
+            tools = [];
+            for (let i = 0; i < params.tools.length; i++) {
+                let tool = params.tools[i];
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name: tool.name,
+                        description: tool.description,
+                        parameters: tool.input_schema,
+                    },
+                });
+            }
+        }
+        let tool_choice = undefined;
+        if (params.toolChoice) {
+            if (params.toolChoice.type == 'auto') {
+                tool_choice = 'auto';
+            }
+            else if (params.toolChoice.type == 'tool') {
+                if (params.toolChoice.name) {
+                    tool_choice = {
+                        type: 'function',
+                        function: { name: params.toolChoice.name },
+                    };
+                }
+                else {
+                    tool_choice = 'required';
+                }
+            }
+        }
+        let _messages = [];
+        for (let i = 0; i < messages.length; i++) {
+            let message = messages[i];
+            if (message.role == 'assistant' && typeof message.content !== 'string') {
+                let _content = undefined;
+                let _tool_calls = undefined;
+                for (let j = 0; j < message.content.length; j++) {
+                    let content = message.content[j];
+                    if (content.type == 'text') {
+                        if (!_content) {
+                            _content = [];
+                        }
+                        _content.push(content);
+                    }
+                    else if (content.type == 'tool_use') {
+                        if (!_tool_calls) {
+                            _tool_calls = [];
+                        }
+                        _tool_calls.push({
+                            id: content.id,
+                            type: 'function',
+                            function: {
+                                name: content.name,
+                                arguments: typeof content.input == 'string' ? content.input : JSON.stringify(content.input),
+                            },
+                        });
+                    }
+                }
+                _messages.push({
+                    role: 'assistant',
+                    content: _content,
+                    tool_calls: _tool_calls,
+                });
+            }
+            else if (message.role == 'user' && typeof message.content !== 'string') {
+                for (let j = 0; j < message.content.length; j++) {
+                    let content = message.content[j];
+                    if (content.type == 'text') {
+                        _messages.push({
+                            role: 'user',
+                            content: content.text,
+                        });
+                    }
+                    else if (content.type == 'image') {
+                        _messages.push({
+                            role: 'user',
+                            content: [
+                                {
+                                    type: 'image_url',
+                                    image_url: {
+                                        url: `data:${content.source.media_type};base64,${content.source.data}`,
+                                    },
+                                },
+                            ],
+                        });
+                    }
+                    else if (content.type == 'tool_result') {
+                        let _content = [];
+                        if (content.content == 'string') {
+                            _content.push({ type: 'text', text: content.content });
+                        }
+                        else {
+                            for (let k = 0; k < content.content.length; k++) {
+                                let item = content.content[k];
+                                if (item.type == 'text') {
+                                    _content.push({ ...item });
+                                }
+                                else if (item.type == 'image') {
+                                    _content.push({
+                                        type: 'image_url',
+                                        image_url: {
+                                            url: `data:${item.source.media_type};base64,${item.source.data}`,
+                                        },
+                                    });
+                                }
+                            }
+                        }
+                        let hasImage = _content.filter((s) => s.type == 'image_url').length > 0;
+                        if (hasImage) {
+                            // OpenAI does not support images returned by the tool.
+                            _messages.push({
+                                role: 'tool',
+                                content: 'ok',
+                                tool_call_id: content.tool_call_id || content.tool_use_id,
+                            });
+                            _messages.push({
+                                role: 'user',
+                                content: _content,
+                            });
+                        }
+                        else {
+                            _messages.push({
+                                role: 'tool',
+                                content: _content,
+                                tool_call_id: content.tool_call_id || content.tool_use_id,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                _messages.push(message);
+            }
+        }
+        return {
+            stream: stream,
+            model: params.model || this.defaultModel,
+            max_tokens: params.maxTokens || 8192,
+            temperature: params.temperature,
+            messages: _messages,
+            tools: tools,
+            tool_choice: tool_choice,
+        };
+    }
+    async generateText(messages, params) {
+        const response = await this.client.chat.completions.create(this.buildParams(messages, params, false));
+        let textContent = null;
+        let toolCalls = [];
+        let stop_reason = null;
+        for (let i = 0; i < response.choices.length; i++) {
+            let choice = response.choices[i];
+            let message = choice.message;
+            if (message.content) {
+                if (textContent == null) {
+                    textContent = '';
+                }
+                textContent += message.content;
+            }
+            if (message.tool_calls) {
+                for (let j = 0; j < message.tool_calls.length; j++) {
+                    let tool_call = message.tool_calls[j];
+                    toolCalls.push({
+                        id: tool_call.id,
+                        name: tool_call.function.name,
+                        input: JSON.parse(tool_call.function.arguments),
+                    });
+                }
+            }
+            if (choice.finish_reason) {
+                stop_reason = choice.finish_reason;
+            }
+        }
+        let content = [];
+        if (textContent) {
+            content.push({
+                type: 'text',
+                text: textContent,
+            });
+        }
+        if (toolCalls.length > 0) {
+            for (let i = 0; i < toolCalls.length; i++) {
+                let toolCall = toolCalls[i];
+                content.push({
+                    type: 'tool_use',
+                    id: toolCall.id,
+                    name: toolCall.name,
+                    input: toolCall.input,
+                });
+            }
+        }
+        return {
+            textContent,
+            content,
+            toolCalls,
+            stop_reason,
+        };
     }
-}
-class FileObjectsPage extends CursorPage {
-}
-Files.FileObjectsPage = FileObjectsPage;
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Checkpoints extends APIResource {
-    list(fineTuningJobId, query = {}, options) {
-        if (isRequestOptions(query)) {
-            return this.list(fineTuningJobId, {}, query);
+    async generateStream(messages, params, handler) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const stream = await this.client.chat.completions.create(this.buildParams(messages, params, true));
+        (_a = handler.onStart) === null || _a === undefined ? undefined : _a.call(handler);
+        let textContent = null;
+        let toolCalls = [];
+        let stop_reason = null;
+        let currentToolUse = null;
+        try {
+            for await (const chunk of stream) {
+                for (let i = 0; i < chunk.choices.length; i++) {
+                    let choice = chunk.choices[i];
+                    if (choice.delta) {
+                        if (choice.delta.content) {
+                            if (textContent == null) {
+                                textContent = '';
+                            }
+                            textContent += choice.delta.content;
+                            (_b = handler.onContent) === null || _b === void 0 ? void 0 : _b.call(handler, choice.delta.content);
+                        }
+                        else if (choice.delta.tool_calls && choice.delta.tool_calls.length > 0) {
+                            let tool_calls = choice.delta.tool_calls[0];
+                            if (!currentToolUse) {
+                                currentToolUse = {
+                                    id: tool_calls.id || '',
+                                    name: ((_c = tool_calls.function) === null || _c === void 0 ? void 0 : _c.name) || '',
+                                    accumulatedJson: ((_d = tool_calls.function) === null || _d === void 0 ? void 0 : _d.arguments) || '',
+                                };
+                            }
+                            else {
+                                if (tool_calls.id) {
+                                    currentToolUse.id = tool_calls.id;
+                                }
+                                if ((_e = tool_calls.function) === null || _e === void 0 ? void 0 : _e.name) {
+                                    currentToolUse.name = (_f = tool_calls.function) === null || _f === void 0 ? void 0 : _f.name;
+                                }
+                                currentToolUse.accumulatedJson += ((_g = tool_calls.function) === null || _g === void 0 ? void 0 : _g.arguments) || '';
+                            }
+                        }
+                    }
+                    if (choice.finish_reason) {
+                        stop_reason = choice.finish_reason;
+                        if (currentToolUse) {
+                            const toolCall = {
+                                id: currentToolUse.id,
+                                name: currentToolUse.name,
+                                input: JSON.parse(currentToolUse.accumulatedJson),
+                            };
+                            toolCalls.push(toolCall);
+                            (_h = handler.onToolUse) === null || _h === void 0 ? void 0 : _h.call(handler, toolCall);
+                            currentToolUse = null;
+                        }
+                    }
+                }
+            }
+            let content = [];
+            if (textContent) {
+                content.push({
+                    type: 'text',
+                    text: textContent,
+                });
+            }
+            if (toolCalls && toolCalls.length > 0) {
+                for (let i = 0; i < toolCalls.length; i++) {
+                    let toolCall = toolCalls[i];
+                    content.push({
+                        type: 'tool_use',
+                        id: toolCall.id,
+                        name: toolCall.name,
+                        input: toolCall.input,
+                    });
+                }
+            }
+            (_j = handler.onComplete) === null || _j === void 0 ? void 0 : _j.call(handler, {
+                textContent: textContent,
+                content: content,
+                toolCalls: toolCalls,
+                stop_reason: stop_reason,
+            });
+        }
+        catch (error) {
+            (_k = handler.onError) === null || _k === undefined ? undefined : _k.call(handler, error);
         }
-        return this._client.getAPIList(`/fine_tuning/jobs/${fineTuningJobId}/checkpoints`, FineTuningJobCheckpointsPage, { query, ...options });
     }
 }
-class FineTuningJobCheckpointsPage extends CursorPage {
-}
-Checkpoints.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage;
 
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Jobs extends APIResource {
-    constructor() {
-        super(...arguments);
-        this.checkpoints = new Checkpoints(this._client);
-    }
-    /**
-     * Creates a fine-tuning job which begins the process of creating a new model from
-     * a given dataset.
-     *
-     * Response includes details of the enqueued job including job status and the name
-     * of the fine-tuned models once complete.
-     *
-     * [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
-     */
-    create(body, options) {
-        return this._client.post('/fine_tuning/jobs', { body, ...options });
-    }
-    /**
-     * Get info about a fine-tuning job.
-     *
-     * [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
-     */
-    retrieve(fineTuningJobId, options) {
-        return this._client.get(`/fine_tuning/jobs/${fineTuningJobId}`, options);
-    }
-    list(query = {}, options) {
-        if (isRequestOptions(query)) {
-            return this.list({}, query);
+class LLMProviderFactory {
+    static buildLLMProvider(config) {
+        let llmProvider;
+        if (typeof config == 'string') {
+            llmProvider = new ClaudeProvider(config);
         }
-        return this._client.getAPIList('/fine_tuning/jobs', FineTuningJobsPage, { query, ...options });
-    }
-    /**
-     * Immediately cancel a fine-tune job.
-     */
-    cancel(fineTuningJobId, options) {
-        return this._client.post(`/fine_tuning/jobs/${fineTuningJobId}/cancel`, options);
-    }
-    listEvents(fineTuningJobId, query = {}, options) {
-        if (isRequestOptions(query)) {
-            return this.listEvents(fineTuningJobId, {}, query);
+        else if ('llm' in config) {
+            if (config.llm == 'claude') {
+                let claudeConfig = config;
+                llmProvider = new ClaudeProvider(claudeConfig.apiKey, claudeConfig.modelName, claudeConfig.options);
+            }
+            else if (config.llm == 'openai') {
+                let openaiConfig = config;
+                llmProvider = new OpenaiProvider(openaiConfig.apiKey, openaiConfig.modelName, openaiConfig.options);
+            }
+            else {
+                throw new Error('Unknown parameter: llm > ' + config['llm']);
+            }
         }
-        return this._client.getAPIList(`/fine_tuning/jobs/${fineTuningJobId}/events`, FineTuningJobEventsPage, {
-            query,
-            ...options,
-        });
-    }
-}
-class FineTuningJobsPage extends CursorPage {
-}
-class FineTuningJobEventsPage extends CursorPage {
-}
-Jobs.FineTuningJobsPage = FineTuningJobsPage;
-Jobs.FineTuningJobEventsPage = FineTuningJobEventsPage;
-Jobs.Checkpoints = Checkpoints;
-Jobs.FineTuningJobCheckpointsPage = FineTuningJobCheckpointsPage;
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class FineTuning extends APIResource {
-    constructor() {
-        super(...arguments);
-        this.jobs = new Jobs(this._client);
-    }
-}
-FineTuning.Jobs = Jobs;
-FineTuning.FineTuningJobsPage = FineTuningJobsPage;
-FineTuning.FineTuningJobEventsPage = FineTuningJobEventsPage;
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Images extends APIResource {
-    /**
-     * Creates a variation of a given image.
-     */
-    createVariation(body, options) {
-        return this._client.post('/images/variations', multipartFormRequestOptions({ body, ...options }));
-    }
-    /**
-     * Creates an edited or extended image given an original image and a prompt.
-     */
-    edit(body, options) {
-        return this._client.post('/images/edits', multipartFormRequestOptions({ body, ...options }));
-    }
-    /**
-     * Creates an image given a prompt.
-     */
-    generate(body, options) {
-        return this._client.post('/images/generations', { body, ...options });
+        else {
+            llmProvider = config;
+        }
+        return llmProvider;
     }
 }
 
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Models extends APIResource {
-    /**
-     * Retrieves a model instance, providing basic information about the model such as
-     * the owner and permissioning.
-     */
-    retrieve(model, options) {
-        return this._client.get(`/models/${model}`, options);
+/**
+ * Manages logging for action execution, providing a cleaner view of the execution
+ * flow while maintaining important context and history.
+ */
+class ExecutionLogger {
+    constructor(options = {}) {
+        var _a;
+        this.history = [];
+        this.maxHistoryLength = options.maxHistoryLength || 10;
+        this.logLevel = options.logLevel || 'info';
+        this.includeTimestamp = (_a = options.includeTimestamp) !== null && _a !== undefined ? _a : true;
+        this.debugImagePath = options.debugImagePath;
+        this.imageSaver = options.imageSaver;
+        // Check if running in Node.js environment
+        this.isNode =
+            typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
     }
     /**
-     * Lists the currently available models, and provides basic information about each
-     * one such as the owner and availability.
+     * Logs a message with execution context
      */
-    list(options) {
-        return this._client.getAPIList('/models', ModelsPage, options);
+    log(level, message, context) {
+        if (this.shouldLog(level)) {
+            const timestamp = this.includeTimestamp ? new Date().toISOString() : '';
+            const contextSummary = this.summarizeContext(context);
+            console.log(`${timestamp} [${level.toUpperCase()}] ${message}${contextSummary}`);
+        }
     }
     /**
-     * Delete a fine-tuned model. You must have the Owner role in your organization to
-     * delete a model.
+     * Updates conversation history while maintaining size limit
      */
-    del(model, options) {
-        return this._client.delete(`/models/${model}`, options);
+    updateHistory(messages) {
+        // Keep system messages and last N messages
+        const systemMessages = messages.filter((m) => m.role === 'system');
+        const nonSystemMessages = messages.filter((m) => m.role !== 'system');
+        const recentMessages = nonSystemMessages.slice(-this.maxHistoryLength);
+        this.history = [...systemMessages, ...recentMessages];
     }
-}
-/**
- * Note: no pagination actually occurs yet, this is for forwards-compatibility.
- */
-class ModelsPage extends Page {
-}
-Models.ModelsPage = ModelsPage;
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Moderations extends APIResource {
     /**
-     * Classifies if text and/or image inputs are potentially harmful. Learn more in
-     * the [moderation guide](https://platform.openai.com/docs/guides/moderation).
+     * Gets current conversation history
      */
-    create(body, options) {
-        return this._client.post('/moderations', { body, ...options });
+    getHistory() {
+        return this.history;
     }
-}
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Parts extends APIResource {
-    /**
-     * Adds a
-     * [Part](https://platform.openai.com/docs/api-reference/uploads/part-object) to an
-     * [Upload](https://platform.openai.com/docs/api-reference/uploads/object) object.
-     * A Part represents a chunk of bytes from the file you are trying to upload.
-     *
-     * Each Part can be at most 64 MB, and you can add Parts until you hit the Upload
-     * maximum of 8 GB.
-     *
-     * It is possible to add multiple Parts in parallel. You can decide the intended
-     * order of the Parts when you
-     * [complete the Upload](https://platform.openai.com/docs/api-reference/uploads/complete).
+    /**
+     * Summarizes the execution context for logging
      */
-    create(uploadId, body, options) {
-        return this._client.post(`/uploads/${uploadId}/parts`, multipartFormRequestOptions({ body, ...options }));
+    summarizeContext(context) {
+        if (!context)
+            return '';
+        const summary = {
+            variables: Object.fromEntries(context.variables),
+            tools: context.tools ? Array.from(context.tools.keys()) : [],
+        };
+        return `\nContext: ${JSON.stringify(summary, null, 2)}`;
     }
-}
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-class Uploads extends APIResource {
-    constructor() {
-        super(...arguments);
-        this.parts = new Parts(this._client);
+    /**
+     * Checks if message should be logged based on log level
+     */
+    shouldLog(level) {
+        const levels = {
+            error: 0,
+            warn: 1,
+            info: 2,
+            debug: 3,
+        };
+        return levels[level] <= levels[this.logLevel];
     }
     /**
-     * Creates an intermediate
-     * [Upload](https://platform.openai.com/docs/api-reference/uploads/object) object
-     * that you can add
-     * [Parts](https://platform.openai.com/docs/api-reference/uploads/part-object) to.
-     * Currently, an Upload can accept at most 8 GB in total and expires after an hour
-     * after you create it.
-     *
-     * Once you complete the Upload, we will create a
-     * [File](https://platform.openai.com/docs/api-reference/files/object) object that
-     * contains all the parts you uploaded. This File is usable in the rest of our
-     * platform as a regular File object.
-     *
-     * For certain `purpose`s, the correct `mime_type` must be specified. Please refer
-     * to documentation for the supported MIME types for your use case:
-     *
-     * - [Assistants](https://platform.openai.com/docs/assistants/tools/file-search#supported-files)
-     *
-     * For guidance on the proper filename extensions for each purpose, please follow
-     * the documentation on
-     * [creating a File](https://platform.openai.com/docs/api-reference/files/create).
+     * Logs the start of an action execution
      */
-    create(body, options) {
-        return this._client.post('/uploads', { body, ...options });
+    logActionStart(actionName, input, context) {
+        this.log('info', `Starting action: ${actionName}`, context);
+        this.log('info', `Input: ${JSON.stringify(input, null, 2)}`);
     }
     /**
-     * Cancels the Upload. No Parts may be added after an Upload is cancelled.
+     * Logs the completion of an action execution
      */
-    cancel(uploadId, options) {
-        return this._client.post(`/uploads/${uploadId}/cancel`, options);
+    logActionComplete(actionName, result, context) {
+        this.log('info', `Completed action: ${actionName}`, context);
+        this.log('info', `Result: ${JSON.stringify(result, null, 2)}`);
     }
     /**
-     * Completes the
-     * [Upload](https://platform.openai.com/docs/api-reference/uploads/object).
-     *
-     * Within the returned Upload object, there is a nested
-     * [File](https://platform.openai.com/docs/api-reference/files/object) object that
-     * is ready to use in the rest of the platform.
-     *
-     * You can specify the order of the Parts by passing in an ordered list of the Part
-     * IDs.
-     *
-     * The number of bytes uploaded upon completion must match the number of bytes
-     * initially specified when creating the Upload object. No Parts may be added after
-     * an Upload is completed.
+     * Logs a tool execution
      */
-    complete(uploadId, body, options) {
-        return this._client.post(`/uploads/${uploadId}/complete`, { body, ...options });
+    logToolExecution(toolName, input, context) {
+        this.log('info', `Executing tool: ${toolName}`);
+        this.log('info', `Tool input: ${JSON.stringify(input, null, 2)}`);
     }
-}
-Uploads.Parts = Parts;
-
-// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
-var _a;
-/**
- * API Client for interfacing with the OpenAI API.
- */
-class OpenAI extends APIClient {
     /**
-     * API Client for interfacing with the OpenAI API.
-     *
-     * @param {string | undefined} [opts.apiKey=process.env['OPENAI_API_KEY'] ?? undefined]
-     * @param {string | null | undefined} [opts.organization=process.env['OPENAI_ORG_ID'] ?? null]
-     * @param {string | null | undefined} [opts.project=process.env['OPENAI_PROJECT_ID'] ?? null]
-     * @param {string} [opts.baseURL=process.env['OPENAI_BASE_URL'] ?? https://api.openai.com/v1] - Override the default base URL for the API.
-     * @param {number} [opts.timeout=10 minutes] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
-     * @param {number} [opts.httpAgent] - An HTTP agent used to manage HTTP(s) connections.
-     * @param {Core.Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
-     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
-     * @param {Core.Headers} opts.defaultHeaders - Default headers to include with every request to the API.
-     * @param {Core.DefaultQuery} opts.defaultQuery - Default query parameters to include with every request to the API.
-     * @param {boolean} [opts.dangerouslyAllowBrowser=false] - By default, client-side use of this library is not allowed, as it risks exposing your secret API credentials to attackers.
+     * Logs an error that occurred during execution
      */
-    constructor({ baseURL = readEnv('OPENAI_BASE_URL'), apiKey = readEnv('OPENAI_API_KEY'), organization = readEnv('OPENAI_ORG_ID') ?? null, project = readEnv('OPENAI_PROJECT_ID') ?? null, ...opts } = {}) {
-        if (apiKey === undefined) {
-            throw new OpenAIError("The OPENAI_API_KEY environment variable is missing or empty; either provide it, or instantiate the OpenAI client with an apiKey option, like new OpenAI({ apiKey: 'My API Key' }).");
+    logError(error, context) {
+        console.error(error);
+        try {
+            this.log('error', `Error occurred: ${error.message}`, context);
+            if (error.stack) {
+                this.log('debug', `Stack trace: ${error.stack}`);
+            }
         }
-        const options = {
-            apiKey,
-            organization,
-            project,
-            ...opts,
-            baseURL: baseURL || `https://api.openai.com/v1`,
-        };
-        if (!options.dangerouslyAllowBrowser && isRunningInBrowser()) {
-            throw new OpenAIError("It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew OpenAI({ apiKey, dangerouslyAllowBrowser: true });\n\nhttps://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n");
+        catch (error) {
+            console.error("An error occurs when trying to log another error:");
+            console.error(error);
         }
-        super({
-            baseURL: options.baseURL,
-            timeout: options.timeout ?? 600000 /* 10 minutes */,
-            httpAgent: options.httpAgent,
-            maxRetries: options.maxRetries,
-            fetch: options.fetch,
-        });
-        this.completions = new Completions(this);
-        this.chat = new Chat$1(this);
-        this.embeddings = new Embeddings(this);
-        this.files = new Files(this);
-        this.images = new Images(this);
-        this.audio = new Audio(this);
-        this.moderations = new Moderations(this);
-        this.models = new Models(this);
-        this.fineTuning = new FineTuning(this);
-        this.beta = new Beta(this);
-        this.batches = new Batches(this);
-        this.uploads = new Uploads(this);
-        this._options = options;
-        this.apiKey = apiKey;
-        this.organization = organization;
-        this.project = project;
-    }
-    defaultQuery() {
-        return this._options.defaultQuery;
     }
-    defaultHeaders(opts) {
+    extractFromDataUrl(dataUrl) {
+        const matches = dataUrl.match(/^data:image\/([a-zA-Z0-9]+);base64,(.+)$/);
+        if (!matches) {
+            throw new Error('Invalid data URL format');
+        }
         return {
-            ...super.defaultHeaders(opts),
-            'OpenAI-Organization': this.organization,
-            'OpenAI-Project': this.project,
-            ...this._options.defaultHeaders,
+            extension: matches[1],
+            base64Data: matches[2],
         };
     }
-    authHeaders(opts) {
-        return { Authorization: `Bearer ${this.apiKey}` };
+    async saveDebugImage(imageData, toolName) {
+        try {
+            let extension;
+            let base64Data;
+            // Handle both data URL strings and ImageData objects
+            if (typeof imageData === 'string' && imageData.startsWith('data:')) {
+                const extracted = this.extractFromDataUrl(imageData);
+                extension = extracted.extension;
+                base64Data = extracted.base64Data;
+            }
+            else if (typeof imageData === 'object' && 'type' in imageData) {
+                extension = imageData.media_type.split('/')[1] || 'png';
+                base64Data = imageData.data;
+            }
+            else {
+                return '[image]';
+            }
+            // If custom image saver is provided, use it
+            if (this.imageSaver) {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const filename = `${toolName}_${timestamp}.${extension}`;
+                return await this.imageSaver({ type: 'base64', media_type: `image/${extension}`, data: base64Data }, filename);
+            }
+            // If in Node.js environment and debugImagePath is set
+            if (this.isNode && this.debugImagePath) {
+                // Dynamically import Node.js modules only when needed
+                const { promises: fs } = await import('fs');
+                const { join } = await import('path');
+                await fs.mkdir(this.debugImagePath, { recursive: true });
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const filename = `${toolName}_${timestamp}.${extension}`;
+                const filepath = join(this.debugImagePath, filename);
+                const buffer = Buffer.from(base64Data, 'base64');
+                await fs.writeFile(filepath, buffer);
+                return `[image saved to: ${filepath}]`;
+            }
+            // Default case - just return placeholder
+            return '[image]';
+        }
+        catch (error) {
+            console.warn('Failed to save debug image:', error);
+            return '[image]';
+        }
+    }
+    async formatToolResult(result) {
+        // Handle null/undefined
+        if (result == null) {
+            return 'null';
+        }
+        // Handle direct image result
+        if (result.image) {
+            const imagePlaceholder = await this.saveDebugImage(result.image, 'tool');
+            const modifiedResult = { ...result, image: imagePlaceholder };
+            return JSON.stringify(modifiedResult);
+        }
+        // Handle nested images in result object
+        if (typeof result === 'object') {
+            const formatted = { ...result };
+            for (const [key, value] of Object.entries(formatted)) {
+                if (value && typeof value === 'string' && value.startsWith('data:image/')) {
+                    formatted[key] = await this.saveDebugImage(value, key);
+                }
+                else if (value &&
+                    typeof value === 'object' &&
+                    'type' in value &&
+                    value.type === 'base64') {
+                    formatted[key] = await this.saveDebugImage(value, key);
+                }
+            }
+            return JSON.stringify(formatted);
+        }
+        // Handle primitive values
+        return String(result);
     }
-    stringifyQuery(query) {
-        return stringify(query, { arrayFormat: 'brackets' });
+    async logToolResult(toolName, result, context) {
+        if (this.shouldLog('info')) {
+            const timestamp = this.includeTimestamp ? new Date().toISOString() : '';
+            const contextSummary = this.summarizeContext(context);
+            const formattedResult = await this.formatToolResult(result);
+            console.log(`${timestamp} [INFO] Tool executed: ${toolName}\n` +
+                `${timestamp} [INFO] Tool result: ${formattedResult}${contextSummary}`);
+        }
     }
 }
-_a = OpenAI;
-OpenAI.OpenAI = _a;
-OpenAI.DEFAULT_TIMEOUT = 600000; // 10 minutes
-OpenAI.OpenAIError = OpenAIError;
-OpenAI.APIError = APIError;
-OpenAI.APIConnectionError = APIConnectionError;
-OpenAI.APIConnectionTimeoutError = APIConnectionTimeoutError;
-OpenAI.APIUserAbortError = APIUserAbortError;
-OpenAI.NotFoundError = NotFoundError;
-OpenAI.ConflictError = ConflictError;
-OpenAI.RateLimitError = RateLimitError;
-OpenAI.BadRequestError = BadRequestError;
-OpenAI.AuthenticationError = AuthenticationError;
-OpenAI.InternalServerError = InternalServerError;
-OpenAI.PermissionDeniedError = PermissionDeniedError;
-OpenAI.UnprocessableEntityError = UnprocessableEntityError;
-OpenAI.toFile = toFile;
-OpenAI.fileFromPath = fileFromPath;
-OpenAI.Completions = Completions;
-OpenAI.Chat = Chat$1;
-OpenAI.Embeddings = Embeddings;
-OpenAI.Files = Files;
-OpenAI.FileObjectsPage = FileObjectsPage;
-OpenAI.Images = Images;
-OpenAI.Audio = Audio;
-OpenAI.Moderations = Moderations;
-OpenAI.Models = Models;
-OpenAI.ModelsPage = ModelsPage;
-OpenAI.FineTuning = FineTuning;
-OpenAI.Beta = Beta;
-OpenAI.Batches = Batches;
-OpenAI.BatchesPage = BatchesPage;
-OpenAI.Uploads = Uploads;
 
-class OpenaiProvider {
-    constructor(param, defaultModel, options) {
-        this.defaultModel = 'gpt-4o';
-        if (defaultModel) {
-            this.defaultModel = defaultModel;
+class WorkflowImpl {
+    constructor(id, name, description, nodes = [], variables = new Map(), llmProvider, loggerOptions) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.nodes = nodes;
+        this.variables = variables;
+        this.llmProvider = llmProvider;
+        this.abortControllers = new Map();
+        if (loggerOptions) {
+            this.logger = new ExecutionLogger(loggerOptions);
         }
-        if (typeof window !== 'undefined' &&
-            typeof document !== 'undefined' &&
-            (typeof param == 'string' || param.apiKey)) {
-            console.warn(`
-        ⚠️ Security Warning:
-        DO NOT use API Keys in browser/frontend code!
-        This will expose your credentials and may lead to unauthorized usage.
-        
-        Best Practices: Configure backend API proxy request through baseURL and request headers.
-
-        Please refer to the link: https://eko.fellou.ai/docs/getting-started/configuration#web-environment
-      `);
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    async cancel() {
+        this.abort = true;
+        for (const controller of this.abortControllers.values()) {
+            controller.abort("Workflow cancelled");
+        }
+    }
+    async execute(callback) {
+        var _a, _b, _c, _d;
+        if (!this.validateDAG()) {
+            throw new Error("Invalid workflow: Contains circular dependencies");
+        }
+        this.abort = false;
+        callback && await ((_b = (_a = callback.hooks).beforeWorkflow) === null || _b === undefined ? undefined : _b.call(_a, this));
+        const executed = new Set();
+        const executing = new Set();
+        const executeNode = async (nodeId) => {
+            var _a, _b, _c, _d, _e;
+            if (this.abort) {
+                throw new Error("Abort");
+            }
+            if (executed.has(nodeId)) {
+                return;
+            }
+            if (executing.has(nodeId)) {
+                throw new Error(`Circular dependency detected at node: ${nodeId}`);
+            }
+            const node = this.getNode(nodeId);
+            const abortController = new AbortController();
+            this.abortControllers.set(nodeId, abortController);
+            // Execute the node's action
+            const context = {
+                __skip: false,
+                __abort: false,
+                workflow: this,
+                variables: this.variables,
+                llmProvider: this.llmProvider,
+                tools: new Map(node.action.tools.map(tool => [tool.name, tool])),
+                callback,
+                logger: this.logger,
+                next: () => context.__skip = true,
+                abortAll: () => {
+                    this.abort = context.__abort = true;
+                    // Abort all running tasks
+                    for (const controller of this.abortControllers.values()) {
+                        controller.abort("Workflow cancelled");
+                    }
+                },
+                signal: abortController.signal
+            };
+            executing.add(nodeId);
+            // Execute dependencies first
+            for (const depId of node.dependencies) {
+                await executeNode(depId);
+            }
+            // Prepare input by gathering outputs from dependencies
+            const input = { items: [] };
+            for (const depId of node.dependencies) {
+                const depNode = this.getNode(depId);
+                input.items.push(depNode.output);
+            }
+            node.input = input;
+            // Run pre-execution hooks and execute action
+            callback && await ((_b = (_a = callback.hooks).beforeSubtask) === null || _b === undefined ? undefined : _b.call(_a, node, context));
+            if (context.__abort) {
+                throw new Error("Abort");
+            }
+            else if (context.__skip) {
+                return;
+            }
+            node.output.value = await node.action.execute(node.input, node.output, context);
+            executing.delete(nodeId);
+            executed.add(nodeId);
+            callback && await ((_d = (_c = callback.hooks).afterSubtask) === null || _d === undefined ? undefined : _d.call(_c, node, context, (_e = node.output) === null || _e === undefined ? undefined : _e.value));
+        };
+        // Execute all terminal nodes (nodes with no dependents)
+        const terminalNodes = this.nodes.filter(node => !this.nodes.some(n => n.dependencies.includes(node.id)));
+        await Promise.all(terminalNodes.map(node => executeNode(node.id)));
+        callback && await ((_d = (_c = callback.hooks).afterWorkflow) === null || _d === undefined ? undefined : _d.call(_c, this, this.variables));
+        return terminalNodes.map(node => node.output);
+    }
+    addNode(node) {
+        if (this.nodes.some(n => n.id === node.id)) {
+            throw new Error(`Node with id ${node.id} already exists`);
+        }
+        this.nodes.push(node);
+    }
+    removeNode(nodeId) {
+        const index = this.nodes.findIndex(n => n.id === nodeId);
+        if (index === -1) {
+            throw new Error(`Node with id ${nodeId} not found`);
         }
-        if (typeof param == 'string') {
-            this.client = new OpenAI({
-                apiKey: param,
-                dangerouslyAllowBrowser: true,
-                ...options,
-            });
+        // Check if any nodes depend on this one
+        const dependentNodes = this.nodes.filter(n => n.dependencies.includes(nodeId));
+        if (dependentNodes.length > 0) {
+            throw new Error(`Cannot remove node ${nodeId}: Nodes ${dependentNodes.map(n => n.id).join(", ")} depend on it`);
         }
-        else {
-            this.client = new OpenAI(param);
+        this.nodes.splice(index, 1);
+    }
+    getNode(nodeId) {
+        const node = this.nodes.find(n => n.id === nodeId);
+        if (!node) {
+            throw new Error(`Node with id ${nodeId} not found`);
         }
+        return node;
     }
-    buildParams(messages, params, stream) {
-        let tools = undefined;
-        if (params.tools && params.tools.length > 0) {
-            tools = [];
-            for (let i = 0; i < params.tools.length; i++) {
-                let tool = params.tools[i];
-                tools.push({
-                    type: 'function',
-                    function: {
-                        name: tool.name,
-                        description: tool.description,
-                        parameters: tool.input_schema,
-                    },
-                });
+    validateDAG() {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycle = (nodeId) => {
+            if (recursionStack.has(nodeId)) {
+                return true;
             }
-        }
-        let tool_choice = undefined;
-        if (params.toolChoice) {
-            if (params.toolChoice.type == 'auto') {
-                tool_choice = 'auto';
+            if (visited.has(nodeId)) {
+                return false;
             }
-            else if (params.toolChoice.type == 'tool') {
-                if (params.toolChoice.name) {
-                    tool_choice = {
-                        type: 'function',
-                        function: { name: params.toolChoice.name },
-                    };
-                }
-                else {
-                    tool_choice = 'required';
+            visited.add(nodeId);
+            recursionStack.add(nodeId);
+            const node = this.getNode(nodeId);
+            for (const depId of node.dependencies) {
+                if (hasCycle(depId)) {
+                    return true;
                 }
             }
+            recursionStack.delete(nodeId);
+            return false;
+        };
+        return !this.nodes.some(node => hasCycle(node.id));
+    }
+}
+
+// src/models/action.ts
+/**
+ * Special tool that allows LLM to write values to context
+ */
+class WriteContextTool {
+    constructor() {
+        this.name = 'write_context';
+        this.description = 'Write a value to the global workflow context. Use this to store important intermediate results, but only when a piece of information is essential for future reference but missing from the final output specification of the current action.';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                key: {
+                    type: 'string',
+                    description: 'The key to store the value under',
+                },
+                value: {
+                    type: 'string',
+                    description: 'The value to store (must be JSON stringified if object/array)',
+                },
+            },
+            required: ['key', 'value'],
+        };
+    }
+    async execute(context, params) {
+        const { key, value } = params;
+        try {
+            // Try to parse the value as JSON
+            const parsedValue = JSON.parse(value);
+            context.variables.set(key, parsedValue);
         }
-        let _messages = [];
-        for (let i = 0; i < messages.length; i++) {
-            let message = messages[i];
-            if (message.role == 'assistant' && typeof message.content !== 'string') {
-                let _content = undefined;
-                let _tool_calls = undefined;
-                for (let j = 0; j < message.content.length; j++) {
-                    let content = message.content[j];
-                    if (content.type == 'text') {
-                        if (!_content) {
-                            _content = [];
-                        }
-                        _content.push(content);
-                    }
-                    else if (content.type == 'tool_use') {
-                        if (!_tool_calls) {
-                            _tool_calls = [];
-                        }
-                        _tool_calls.push({
-                            id: content.id,
-                            type: 'function',
-                            function: {
-                                name: content.name,
-                                arguments: typeof content.input == 'string' ? content.input : JSON.stringify(content.input),
-                            },
-                        });
-                    }
+        catch (_a) {
+            // If parsing fails, store as string
+            context.variables.set(key, value);
+        }
+        return { success: true, key, value };
+    }
+}
+function createReturnTool(actionName, outputDescription, outputSchema) {
+    return {
+        name: 'return_output',
+        description: `Return the final output of this action. Use this to return a value matching the required output schema (if specified) and the following description:
+      ${outputDescription}
+
+      You can either set 'use_tool_result=true' to return the result of a previous tool call, or explicitly specify 'value' with 'use_tool_result=false' to return a value according to your own understanding. Whenever possible, reuse tool results to avoid redundancy.
+      `,
+        input_schema: {
+            type: 'object',
+            properties: {
+                use_tool_result: {
+                    type: ['boolean'],
+                    description: `Whether to use the latest tool result as output. When set to true, the 'value' parameter is ignored.`,
+                },
+                value: outputSchema || {
+                    // Default to accepting any JSON value
+                    type: ['string', 'number', 'boolean', 'object', 'null'],
+                    description: 'The output value. Only provide a value if the previous tool result is not suitable for the output description. Otherwise, leave this as null.',
+                },
+            },
+            required: ['use_tool_result', 'value'],
+        },
+        async execute(context, params) {
+            context.variables.set(`__action_${actionName}_output`, params);
+            return { success: true };
+        },
+    };
+}
+class ActionImpl {
+    constructor(type, // Only support prompt type
+    name, description, tools, llmProvider, llmConfig, config) {
+        this.type = type;
+        this.name = name;
+        this.description = description;
+        this.tools = tools;
+        this.llmProvider = llmProvider;
+        this.llmConfig = llmConfig;
+        this.maxRounds = 10; // Default max rounds
+        this.toolResults = new Map();
+        this.logger = new ExecutionLogger();
+        this.writeContextTool = new WriteContextTool();
+        this.tools = [...tools, this.writeContextTool];
+        if (config === null || config === undefined ? undefined : config.maxRounds) {
+            this.maxRounds = config.maxRounds;
+        }
+    }
+    async executeSingleRound(messages, params, toolMap, context) {
+        this.logger = context.logger;
+        const roundMessages = [];
+        let hasToolUse = false;
+        let response = null;
+        // Buffer to collect into roundMessages
+        let assistantTextMessage = '';
+        let toolUseMessage = null;
+        let toolResultMessage = null;
+        // Track tool execution promise
+        let toolExecutionPromise = null;
+        // Listen for abort signal
+        if (context.signal) {
+            context.signal.addEventListener('abort', () => {
+                context.__abort = true;
+            });
+        }
+        const handler = {
+            onContent: (content) => {
+                if (content.trim()) {
+                    assistantTextMessage += content;
                 }
-                _messages.push({
+            },
+            onToolUse: async (toolCall) => {
+                this.logger.log('info', `Assistant: ${assistantTextMessage}`);
+                this.logger.logToolExecution(toolCall.name, toolCall.input, context);
+                hasToolUse = true;
+                const tool = toolMap.get(toolCall.name);
+                if (!tool) {
+                    throw new Error(`Tool not found: ${toolCall.name}`);
+                }
+                toolUseMessage = {
                     role: 'assistant',
-                    content: _content,
-                    tool_calls: _tool_calls,
-                });
-            }
-            else if (message.role == 'user' && typeof message.content !== 'string') {
-                for (let j = 0; j < message.content.length; j++) {
-                    let content = message.content[j];
-                    if (content.type == 'text') {
-                        _messages.push({
+                    content: [
+                        {
+                            type: 'tool_use',
+                            id: toolCall.id,
+                            name: tool.name,
+                            input: toolCall.input,
+                        },
+                    ],
+                };
+                // Store the promise of tool execution
+                toolExecutionPromise = (async () => {
+                    var _a;
+                    try {
+                        // beforeToolUse
+                        context.__skip = false;
+                        if (context.callback && context.callback.hooks.beforeToolUse) {
+                            let modified_input = await context.callback.hooks.beforeToolUse(tool, context, toolCall.input);
+                            if (modified_input) {
+                                toolCall.input = modified_input;
+                            }
+                        }
+                        if (context.__skip || context.__abort || ((_a = context.signal) === null || _a === void 0 ? void 0 : _a.aborted)) {
+                            toolResultMessage = {
+                                role: 'user',
+                                content: [
+                                    {
+                                        type: 'tool_result',
+                                        tool_use_id: toolCall.id,
+                                        content: 'skip',
+                                    },
+                                ],
+                            };
+                            return;
+                        }
+                        // Execute the tool
+                        let result = await tool.execute(context, toolCall.input);
+                        // afterToolUse
+                        if (context.callback && context.callback.hooks.afterToolUse) {
+                            let modified_result = await context.callback.hooks.afterToolUse(tool, context, result);
+                            if (modified_result) {
+                                result = modified_result;
+                            }
+                        }
+                        const result_has_image = result && "image" in result;
+                        const resultContent = result_has_image
+                            ? {
+                                type: 'tool_result',
+                                tool_use_id: toolCall.id,
+                                content: result.text
+                                    ? [
+                                        { type: 'image', source: result.image },
+                                        { type: 'text', text: result.text },
+                                    ]
+                                    : [{ type: 'image', source: result.image }],
+                            }
+                            : {
+                                type: 'tool_result',
+                                tool_use_id: toolCall.id,
+                                content: [{ type: 'text', text: JSON.stringify(result) }],
+                            };
+                        const resultContentText = result_has_image
+                            ? result.text
+                                ? result.text + ' [Image]'
+                                : '[Image]'
+                            : JSON.stringify(result);
+                        const resultMessage = {
                             role: 'user',
-                            content: content.text,
-                        });
+                            content: [resultContent],
+                        };
+                        toolResultMessage = resultMessage;
+                        this.logger.logToolResult(tool.name, result, context);
+                        // Store tool results except for the return_output tool
+                        if (tool.name !== 'return_output') {
+                            this.toolResults.set(toolCall.id, resultContentText);
+                        }
                     }
-                    else if (content.type == 'image') {
-                        _messages.push({
+                    catch (err) {
+                        console.log("An error occurred when calling tool:");
+                        console.log(err);
+                        const errorMessage = err instanceof Error ? err.message : 'Unknown error occurred';
+                        const errorResult = {
                             role: 'user',
                             content: [
                                 {
-                                    type: 'image_url',
-                                    image_url: {
-                                        url: `data:${content.source.media_type};base64,${content.source.data}`,
-                                    },
+                                    type: 'tool_result',
+                                    tool_use_id: toolCall.id,
+                                    content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+                                    is_error: true,
                                 },
                             ],
-                        });
+                        };
+                        toolResultMessage = errorResult;
+                        this.logger.logError(err, context);
                     }
-                    else if (content.type == 'tool_result') {
-                        let _content = [];
-                        if (content.content == 'string') {
-                            _content.push({ type: 'text', text: content.content });
-                        }
-                        else {
-                            for (let k = 0; k < content.content.length; k++) {
-                                let item = content.content[k];
-                                if (item.type == 'text') {
-                                    _content.push({ ...item });
-                                }
-                                else if (item.type == 'image') {
-                                    _content.push({
-                                        type: 'image_url',
-                                        image_url: {
-                                            url: `data:${item.source.media_type};base64,${item.source.data}`,
-                                        },
-                                    });
+                })();
+            },
+            onComplete: (llmResponse) => {
+                response = llmResponse;
+            },
+            onError: (error) => {
+                console.error('Stream Error:', error);
+                console.log('Last message array sent to LLM:', JSON.stringify(messages, null, 2));
+            },
+        };
+        this.handleHistoryImageMessages(messages);
+        // Wait for stream to complete
+        if (!this.llmProvider) {
+            throw new Error('LLM provider not set');
+        }
+        await this.llmProvider.generateStream(messages, params, handler);
+        // Wait for tool execution to complete if it was started
+        if (toolExecutionPromise) {
+            await toolExecutionPromise;
+        }
+        if (context.__abort) {
+            throw new Error('Abort');
+        }
+        // Add messages in the correct order after everything is complete
+        if (assistantTextMessage) {
+            roundMessages.push({ role: 'assistant', content: assistantTextMessage });
+        }
+        if (toolUseMessage) {
+            roundMessages.push(toolUseMessage);
+        }
+        if (toolResultMessage) {
+            roundMessages.push(toolResultMessage);
+        }
+        return { response, hasToolUse, roundMessages };
+    }
+    handleHistoryImageMessages(messages) {
+        // Remove all images from historical tool results except the most recent user message
+        const initialImageCount = this.countImages(messages);
+        let foundFirstUser = false;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const message = messages[i];
+            if (message.role === 'user') {
+                if (!foundFirstUser) {
+                    foundFirstUser = true;
+                    continue;
+                }
+                if (Array.isArray(message.content)) {
+                    // Directly modify the message content array
+                    message.content = message.content.map((item) => {
+                        if (item.type === 'tool_result' && Array.isArray(item.content)) {
+                            // Create a new content array without images
+                            if (item.content.length > 0) {
+                                item.content = item.content.filter((c) => c.type !== 'image');
+                                // If all content was images and got filtered out, replace with ok message
+                                if (item.content.length === 0) {
+                                    item.content = [{ type: 'text', text: 'ok' }];
                                 }
                             }
                         }
-                        let hasImage = _content.filter((s) => s.type == 'image_url').length > 0;
-                        if (hasImage) {
-                            // OpenAI does not support images returned by the tool.
-                            _messages.push({
-                                role: 'tool',
-                                content: 'ok',
-                                tool_call_id: content.tool_call_id || content.tool_use_id,
-                            });
-                            _messages.push({
-                                role: 'user',
-                                content: _content,
-                            });
-                        }
-                        else {
-                            _messages.push({
-                                role: 'tool',
-                                content: _content,
-                                tool_call_id: content.tool_call_id || content.tool_use_id,
-                            });
-                        }
-                    }
+                        return item;
+                    });
                 }
             }
-            else {
-                _messages.push(message);
-            }
         }
-        return {
-            stream: stream,
-            model: params.model || this.defaultModel,
-            max_tokens: params.maxTokens || 4096,
-            temperature: params.temperature,
-            messages: _messages,
-            tools: tools,
-            tool_choice: tool_choice,
-        };
+        const finalImageCount = this.countImages(messages);
+        if (initialImageCount !== finalImageCount) {
+            this.logger.log("info", `Removed ${initialImageCount - finalImageCount} images from history`);
+        }
     }
-    async generateText(messages, params) {
-        const response = await this.client.chat.completions.create(this.buildParams(messages, params, false));
-        let textContent = null;
-        let toolCalls = [];
-        let stop_reason = null;
-        for (let i = 0; i < response.choices.length; i++) {
-            let choice = response.choices[i];
-            let message = choice.message;
-            if (message.content) {
-                if (textContent == null) {
-                    textContent = '';
-                }
-                textContent += message.content;
+    countImages(messages) {
+        let count = 0;
+        messages.forEach(msg => {
+            if (Array.isArray(msg.content)) {
+                msg.content.forEach((item) => {
+                    if (item.type === 'tool_result' && Array.isArray(item.content)) {
+                        count += item.content.filter((c) => c.type === 'image').length;
+                    }
+                });
             }
-            if (message.tool_calls) {
-                for (let j = 0; j < message.tool_calls.length; j++) {
-                    let tool_call = message.tool_calls[j];
-                    toolCalls.push({
-                        id: tool_call.id,
-                        name: tool_call.function.name,
-                        input: JSON.parse(tool_call.function.arguments),
-                    });
-                }
+        });
+        return count;
+    }
+    async execute(input, output, context, outputSchema) {
+        var _a, _b, _c, _d, _e;
+        this.logger = context.logger;
+        console.log(`Executing action started: ${this.name}`);
+        // Create return tool with output schema
+        const returnTool = createReturnTool(this.name, output.description, outputSchema);
+        // Create tool map combining context tools, action tools, and return tool
+        const toolMap = new Map();
+        this.tools.forEach((tool) => toolMap.set(tool.name, tool));
+        (_a = context.tools) === null || _a === undefined ? undefined : _a.forEach((tool) => toolMap.set(tool.name, tool));
+        toolMap.set(returnTool.name, returnTool);
+        // Prepare initial messages
+        const messages = [
+            { role: 'system', content: this.formatSystemPrompt() },
+            { role: 'user', content: this.formatUserPrompt(context, input) },
+        ];
+        this.logger.logActionStart(this.name, input, context);
+        // Configure tool parameters
+        const params = {
+            ...this.llmConfig,
+            tools: Array.from(toolMap.values()).map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                input_schema: tool.input_schema,
+            })),
+        };
+        let roundCount = 0;
+        while (roundCount < this.maxRounds) {
+            // Check for abort signal
+            if ((_b = context.signal) === null || _b === undefined ? undefined : _b.aborted) {
+                throw new Error('Workflow cancelled');
             }
-            if (choice.finish_reason) {
-                stop_reason = choice.finish_reason;
+            roundCount++;
+            this.logger.log('info', `Starting round ${roundCount} of ${this.maxRounds}`, context);
+            console.log(messages);
+            const { response, hasToolUse, roundMessages } = await this.executeSingleRound(messages, params, toolMap, context);
+            console.log(response);
+            console.log(hasToolUse);
+            console.log(roundMessages);
+            if (response === null || response === undefined ? undefined : response.textContent) {
+                (_e = (_d = (_c = context.callback) === null || _c === undefined ? undefined : _c.hooks) === null || _d === undefined ? undefined : _d.onLlmMessage) === null || _e === undefined ? undefined : _e.call(_d, response.textContent);
+            }
+            // Add round messages to conversation history
+            messages.push(...roundMessages);
+            this.logger.log('debug', `Round ${roundCount} messages: ${JSON.stringify(roundMessages)}`, context);
+            // Check termination conditions
+            if (!hasToolUse && response) {
+                // LLM sent a message without using tools - request explicit return
+                this.logger.log('info', `Assistant: ${response.textContent}`);
+                this.logger.log('warn', 'LLM sent a message without using tools; requesting explicit return');
+                const returnOnlyParams = {
+                    ...params,
+                    tools: [
+                        {
+                            name: returnTool.name,
+                            description: returnTool.description,
+                            input_schema: returnTool.input_schema,
+                        },
+                    ],
+                };
+                messages.push({
+                    role: 'user',
+                    content: 'Please process the above information and return a final result using the return_output tool.',
+                });
+                const { roundMessages: finalRoundMessages } = await this.executeSingleRound(messages, returnOnlyParams, new Map([[returnTool.name, returnTool]]), context);
+                messages.push(...finalRoundMessages);
+                break;
+            }
+            if (response === null || response === undefined ? undefined : response.toolCalls.some((call) => call.name === 'return_output')) {
+                break;
+            }
+            // If this is the last round, force an explicit return
+            if (roundCount === this.maxRounds) {
+                this.logger.log('warn', 'Max rounds reached, requesting explicit return');
+                const returnOnlyParams = {
+                    ...params,
+                    tools: [
+                        {
+                            name: returnTool.name,
+                            description: returnTool.description,
+                            input_schema: returnTool.input_schema,
+                        },
+                    ],
+                };
+                messages.push({
+                    role: 'user',
+                    content: 'Maximum number of steps reached. Please return the best result possible with the return_output tool.',
+                });
+                const { roundMessages: finalRoundMessages } = await this.executeSingleRound(messages, returnOnlyParams, new Map([[returnTool.name, returnTool]]), context);
+                messages.push(...finalRoundMessages);
             }
         }
-        let content = [];
-        if (textContent) {
-            content.push({
-                type: 'text',
-                text: textContent,
+        // Get and clean up output value
+        const outputKey = `__action_${this.name}_output`;
+        const outputParams = context.variables.get(outputKey);
+        context.variables.delete(outputKey);
+        // Get output value, first checking for use_tool_result
+        const outputParams_has_use_tool_result = outputParams && "use_tool_result" in outputParams;
+        const outputValue = outputParams_has_use_tool_result
+            ? Array.from(this.toolResults.values()).pop()
+            : outputParams === null || outputParams === undefined ? undefined : outputParams.value;
+        if (outputValue === undefined) {
+            console.warn('Action completed without returning a value');
+            return {};
+        }
+        return outputValue;
+    }
+    formatSystemPrompt() {
+        return `You are a subtask executor. You need to complete the subtask specified by the user, which is a consisting part of the overall task. Help the user by calling the tools provided.
+
+    Remember to:
+    1. Use tools when needed to accomplish the task
+    2. Think step by step about what needs to be done
+    3. Return the output of the subtask using the 'return_output' tool when you are done; prefer using the 'tool_use_id' parameter to refer to the output of a tool call over providing a long text as the value
+    4. Use the context to store important information for later reference, but use it sparingly: most of the time, the output of the subtask should be sufficient for the next steps
+    5. If there are any unclear points during the task execution, please use the human-related tool to inquire with the user
+    6. If user intervention is required during the task execution, please use the human-related tool to transfer the operation rights to the user
+    `;
+    }
+    formatUserPrompt(context, input) {
+        var _a;
+        const workflowDescription = ((_a = context.workflow) === null || _a === undefined ? undefined : _a.description) || null;
+        const actionDescription = `${this.name} -- ${this.description}`;
+        const inputDescription = JSON.stringify(input, null, 2) || null;
+        const contextVariables = Array.from(context.variables.entries())
+            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+            .join('\n');
+        return `You are executing a subtask in the workflow. The workflow description is as follows:
+    ${workflowDescription}
+
+    The subtask description is as follows:
+    ${actionDescription}
+
+    The input to the subtask is as follows:
+    ${inputDescription}
+
+    There are some variables stored in the context that you can use for reference:
+    ${contextVariables}
+    `;
+    }
+    // Static factory method
+    static createPromptAction(name, description, tools, llmProvider, llmConfig) {
+        return new ActionImpl('prompt', name, description, tools, llmProvider, llmConfig);
+    }
+}
+
+// src/services/workflow/templates.ts
+function createWorkflowPrompts(tools) {
+    return {
+        formatSystemPrompt: () => {
+            const toolDescriptions = tools
+                .map((tool) => `
+Tool: ${tool.name}
+Description: ${tool.description}
+Input Schema: ${JSON.stringify(tool.input_schema, null, 2)}
+        `)
+                .join('\n');
+            return `You are a workflow generation assistant that creates Eko framework workflows.
+The following tools are available:
+
+${toolDescriptions}
+
+Generate a complete workflow that:
+1. Only uses the tools listed above
+2. Properly sequences tool usage based on dependencies
+3. Ensures each action has appropriate input/output schemas, and that the "tools" field in each action is populated with the sufficient subset of all available tools needed to complete the action
+4. Creates a clear, logical flow to accomplish the user's goal
+5. Includes detailed descriptions for each action, ensuring that the actions, when combined, is a complete solution to the user's problem
+6. You should always add a SubTask at the end of the workflow to summarize it, and this SubTask should always call the "summary_workflow" tool. It's dependencies should be all of the SubTasks`;
+        },
+        formatUserPrompt: (requirement) => `Create a workflow for the following requirement: ${requirement}`,
+        modifyUserPrompt: (prompt) => `Modify workflow: ${prompt}`,
+    };
+}
+function createWorkflowGenerationTool(registry) {
+    return {
+        name: 'generate_workflow',
+        description: `Generate a workflow following the Eko framework DSL schema.
+The workflow must only use the available tools and ensure proper dependencies between nodes.`,
+        input_schema: {
+            type: 'object',
+            properties: {
+                workflow: registry.getWorkflowSchema(),
+            },
+            required: ['workflow'],
+        },
+    };
+}
+
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+let getRandomValues;
+const rnds8 = new Uint8Array(16);
+function rng() {
+    if (!getRandomValues) {
+        if (typeof crypto === 'undefined' || !crypto.getRandomValues) {
+            throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+        }
+        getRandomValues = crypto.getRandomValues.bind(crypto);
+    }
+    return getRandomValues(rnds8);
+}
+
+const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native = { randomUUID };
+
+function v4(options, buf, offset) {
+    if (native.randomUUID && true && !options) {
+        return native.randomUUID();
+    }
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return unsafeStringify(rnds);
+}
+
+class WorkflowGenerator {
+    constructor(llmProvider, toolRegistry) {
+        this.llmProvider = llmProvider;
+        this.toolRegistry = toolRegistry;
+        this.message_history = [];
+    }
+    async generateWorkflow(prompt) {
+        return this.doGenerateWorkflow(prompt, false);
+    }
+    async generateWorkflowFromJson(json) {
+        return this.createWorkflowFromData(json);
+    }
+    async modifyWorkflow(prompt) {
+        return this.doGenerateWorkflow(prompt, true);
+    }
+    async doGenerateWorkflow(prompt, modify) {
+        // Create prompts with current set of tools
+        const prompts = createWorkflowPrompts(this.toolRegistry.getToolDefinitions());
+        let messages = [];
+        if (modify) {
+            messages = this.message_history;
+            messages.push({
+                role: 'user',
+                content: prompts.modifyUserPrompt(prompt),
             });
         }
-        if (toolCalls && toolCalls.length > 0) {
-            for (let i = 0; i < toolCalls.length; i++) {
-                let toolCall = toolCalls[i];
-                content.push({
-                    type: 'tool_use',
-                    id: toolCall.id,
-                    name: toolCall.name,
-                    input: toolCall.input,
-                });
-            }
+        else {
+            messages = this.message_history = [
+                {
+                    role: 'system',
+                    content: prompts.formatSystemPrompt(),
+                },
+                {
+                    role: 'user',
+                    content: prompts.formatUserPrompt(prompt),
+                },
+            ];
         }
-        return {
-            textContent,
-            content,
-            toolCalls,
-            stop_reason,
+        const params = {
+            temperature: 0.7,
+            maxTokens: 8192,
+            tools: [createWorkflowGenerationTool(this.toolRegistry)],
+            toolChoice: { type: 'tool', name: 'generate_workflow' },
         };
-    }
-    async generateStream(messages, params, handler) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        const stream = await this.client.chat.completions.create(this.buildParams(messages, params, true));
-        (_a = handler.onStart) === null || _a === void 0 ? void 0 : _a.call(handler);
-        let textContent = null;
-        let toolCalls = [];
-        let stop_reason = null;
-        let currentToolUse = null;
-        try {
-            for await (const chunk of stream) {
-                for (let i = 0; i < chunk.choices.length; i++) {
-                    let choice = chunk.choices[i];
-                    if (choice.delta) {
-                        if (choice.delta.content) {
-                            if (textContent == null) {
-                                textContent = '';
-                            }
-                            textContent += choice.delta.content;
-                            (_b = handler.onContent) === null || _b === void 0 ? void 0 : _b.call(handler, choice.delta.content);
-                        }
-                        else if (choice.delta.tool_calls && choice.delta.tool_calls.length > 0) {
-                            let tool_calls = choice.delta.tool_calls[0];
-                            if (!currentToolUse) {
-                                currentToolUse = {
-                                    id: tool_calls.id || '',
-                                    name: ((_c = tool_calls.function) === null || _c === void 0 ? void 0 : _c.name) || '',
-                                    accumulatedJson: ((_d = tool_calls.function) === null || _d === void 0 ? void 0 : _d.arguments) || '',
-                                };
-                            }
-                            else {
-                                if (tool_calls.id) {
-                                    currentToolUse.id = tool_calls.id;
-                                }
-                                if ((_e = tool_calls.function) === null || _e === void 0 ? void 0 : _e.name) {
-                                    currentToolUse.name = (_f = tool_calls.function) === null || _f === void 0 ? void 0 : _f.name;
-                                }
-                                currentToolUse.accumulatedJson += ((_g = tool_calls.function) === null || _g === void 0 ? void 0 : _g.arguments) || '';
-                            }
-                        }
-                    }
-                    if (choice.finish_reason) {
-                        stop_reason = choice.finish_reason;
-                        if (currentToolUse) {
-                            const toolCall = {
-                                id: currentToolUse.id,
-                                name: currentToolUse.name,
-                                input: JSON.parse(currentToolUse.accumulatedJson),
-                            };
-                            toolCalls.push(toolCall);
-                            (_h = handler.onToolUse) === null || _h === void 0 ? void 0 : _h.call(handler, toolCall);
-                            currentToolUse = null;
-                        }
-                    }
+        const response = await this.llmProvider.generateText(messages, params);
+        if (!response.toolCalls.length || !response.toolCalls[0].input.workflow) {
+            messages.pop();
+            throw new Error('Failed to generate workflow: Invalid response from LLM');
+        }
+        messages.push({
+            role: 'assistant',
+            content: [
+                {
+                    type: 'tool_use',
+                    id: response.toolCalls[0].id,
+                    name: response.toolCalls[0].name,
+                    input: response.toolCalls[0].input,
+                },
+            ],
+        }, {
+            role: 'user',
+            content: [
+                {
+                    type: 'tool_result',
+                    tool_use_id: response.toolCalls[0].id,
+                    content: 'ok',
+                },
+            ],
+        });
+        const workflowData = response.toolCalls[0].input.workflow;
+        // Forcibly add special tools
+        const specialTools = [
+            "cancel_workflow",
+            "human_input_text",
+            "human_operate",
+        ];
+        for (const node of workflowData.nodes) {
+            for (const tool of specialTools) {
+                if (!node.action.tools.includes(tool)) {
+                    node.action.tools.push(tool);
                 }
             }
-            let content = [];
-            if (textContent) {
-                content.push({
-                    type: 'text',
-                    text: textContent,
-                });
-            }
-            if (toolCalls && toolCalls.length > 0) {
-                for (let i = 0; i < toolCalls.length; i++) {
-                    let toolCall = toolCalls[i];
-                    content.push({
-                        type: 'tool_use',
-                        id: toolCall.id,
-                        name: toolCall.name,
-                        input: toolCall.input,
-                    });
-                }
+        }
+        // Validate all tools exist
+        for (const node of workflowData.nodes) {
+            if (!this.toolRegistry.hasTools(node.action.tools)) {
+                throw new Error(`Workflow contains undefined tools: ${node.action.tools}`);
             }
-            (_j = handler.onComplete) === null || _j === void 0 ? void 0 : _j.call(handler, {
-                textContent: textContent,
-                content: content,
-                toolCalls: toolCalls,
-                stop_reason: stop_reason,
-            });
         }
-        catch (error) {
-            (_k = handler.onError) === null || _k === void 0 ? void 0 : _k.call(handler, error);
+        // Generate a new UUID if not provided
+        if (!workflowData.id) {
+            workflowData.id = v4();
+        }
+        // debug
+        console.log("Debug the workflow...");
+        console.log(workflowData);
+        console.log("Debug the workflow...Done");
+        return this.createWorkflowFromData(workflowData);
+    }
+    createWorkflowFromData(data) {
+        const workflow = new WorkflowImpl(data.id, data.name, data.description || '', [], new Map(Object.entries(data.variables || {})), this.llmProvider, {
+            logLevel: 'info',
+            includeTimestamp: true,
+        });
+        // Add nodes to workflow
+        if (Array.isArray(data.nodes)) {
+            data.nodes.forEach((nodeData) => {
+                const tools = nodeData.action.tools.map((toolName) => this.toolRegistry.getTool(toolName));
+                const action = ActionImpl.createPromptAction(nodeData.action.name, nodeData.action.description, tools, this.llmProvider, { maxTokens: 8192 });
+                const node = {
+                    id: nodeData.id,
+                    name: nodeData.name || nodeData.id,
+                    input: nodeData.input || { type: 'any', schema: {}, value: undefined },
+                    output: nodeData.output || { type: 'any', schema: {}, value: undefined },
+                    action: action,
+                    dependencies: nodeData.dependencies || [],
+                };
+                workflow.addNode(node);
+            });
         }
+        return workflow;
     }
 }
 
@@ -9140,18 +9579,11 @@ const workflowSchema = {
                         type: "array",
                         items: { type: "string" },
                     },
-                    input: {
-                        type: "object",
-                        properties: {
-                            type: { type: "string" },
-                            schema: { type: "object" },
-                        },
-                    },
                     output: {
                         type: "object",
                         properties: {
-                            type: { type: "string" },
-                            schema: { type: "object" },
+                            name: { type: "string" },
+                            description: { type: "string" },
                         },
                     },
                     action: {
@@ -9239,25 +9671,7 @@ class Eko {
     constructor(config) {
         this.toolRegistry = new ToolRegistry();
         this.workflowGeneratorMap = new Map();
-        if (typeof config == 'string') {
-            this.llmProvider = new ClaudeProvider(config);
-        }
-        else if ('llm' in config) {
-            if (config.llm == 'claude') {
-                let claudeConfig = config;
-                this.llmProvider = new ClaudeProvider(claudeConfig.apiKey, claudeConfig.modelName, claudeConfig.options);
-            }
-            else if (config.llm == 'openai') {
-                let openaiConfig = config;
-                this.llmProvider = new OpenaiProvider(openaiConfig.apiKey, openaiConfig.modelName, openaiConfig.options);
-            }
-            else {
-                throw new Error('Unknown parameter: llm > ' + config['llm']);
-            }
-        }
-        else {
-            this.llmProvider = config;
-        }
+        this.llmProvider = LLMProviderFactory.buildLLMProvider(config);
         Eko.tools.forEach((tool) => this.toolRegistry.registerTool(tool));
     }
     async generate(prompt, param) {
@@ -9280,8 +9694,27 @@ class Eko {
         return workflow;
     }
     async execute(workflow, callback) {
+        // Inject LLM provider at workflow level
+        workflow.llmProvider = this.llmProvider;
+        // Process each node's action
+        for (const node of workflow.nodes) {
+            if (node.action.type === 'prompt') {
+                // Inject LLM provider
+                node.action.llmProvider = this.llmProvider;
+                // Resolve tools
+                node.action.tools = node.action.tools.map(tool => {
+                    if (typeof tool === 'string') {
+                        return this.toolRegistry.getTool(tool);
+                    }
+                    return tool;
+                });
+            }
+        }
         return await workflow.execute(callback);
     }
+    async cancel(workflow) {
+        return await workflow.cancel();
+    }
     async modify(workflow, prompt) {
         const generator = this.workflowGeneratorMap.get(workflow);
         workflow = await generator.modifyWorkflow(prompt);
@@ -9465,31 +9898,30 @@ class WorkflowParser {
             errors,
         };
     }
-    /**
-     * Convert parsed JSON to runtime Workflow object
-     */
     static toRuntime(json) {
         const variables = new Map(Object.entries(json.variables || {}));
-        const workflow = new WorkflowImpl(json.id, json.name, json.description, [], variables);
+        const workflow = new WorkflowImpl(json.id, json.name, json.description, [], variables, undefined, {
+            logLevel: 'info',
+            includeTimestamp: true,
+        });
         // Convert nodes
         json.nodes.forEach((nodeJson) => {
+            const action = ActionImpl.createPromptAction(nodeJson.action.name, nodeJson.action.description, 
+            // Pass tool names as strings, they'll be resolved at execution time
+            nodeJson.action.tools || [], undefined, // LLM provider will be injected at execution time
+            { maxTokens: 8192 });
             const node = {
                 id: nodeJson.id,
                 name: nodeJson.name || nodeJson.id,
                 description: nodeJson.description,
                 dependencies: nodeJson.dependencies || [],
-                input: this.convertIO(nodeJson.input),
-                output: this.convertIO(nodeJson.output),
-                action: {
-                    type: nodeJson.action.type,
-                    name: nodeJson.action.name,
-                    description: nodeJson.action.description,
-                    tools: nodeJson.action.tools || [],
-                    execute: async (input, context) => {
-                        // Default implementation - should be overridden by specific action types
-                        return input;
-                    },
+                input: { items: [] },
+                output: nodeJson.output || {
+                    name: `${nodeJson.name || nodeJson.id}_output`,
+                    description: `Output of node ${nodeJson.name || nodeJson.id}`,
+                    value: null,
                 },
+                action: action,
             };
             workflow.addNode(node);
         });
@@ -9509,32 +9941,25 @@ class WorkflowParser {
                 name: node.name,
                 description: node.description,
                 dependencies: node.dependencies,
-                input: node.input,
                 output: node.output,
                 action: {
                     type: node.action.type,
                     name: node.action.name,
                     description: node.action.description,
-                    tools: node.action.tools,
+                    tools: node.action.tools
+                        .map((tool) => (typeof tool === 'string' ? tool : tool.name))
+                        .filter((tool) => tool !== 'write_context'),
                 },
             })),
             variables: Object.fromEntries(workflow.variables),
         };
     }
-    /**
-     * Helper to convert IO definitions
-     */
-    static convertIO(io) {
-        return {
-            type: (io === null || io === void 0 ? void 0 : io.type) || 'object',
-            schema: (io === null || io === void 0 ? void 0 : io.schema) || {},
-            value: null,
-        };
-    }
 }
 
 exports.ClaudeProvider = ClaudeProvider;
 exports.Eko = Eko;
+exports.ExecutionLogger = ExecutionLogger;
+exports.LLMProviderFactory = LLMProviderFactory;
 exports.OpenaiProvider = OpenaiProvider;
 exports.ToolRegistry = ToolRegistry;
 exports.WorkflowGenerator = WorkflowGenerator;