saico 2.4.0 → 2.6.0

package/README.md

@@ -27,7 +27,6 @@ class MyAgent extends Saico {
         super({
             name: 'my-agent',
             prompt: 'You are a helpful assistant.',
-            tool_handler: (name, args) => this.handleTool(name, args),
             functions: [{
                 type: 'function',
                 function: {
@@ -43,11 +42,9 @@ class MyAgent extends Saico {
         });
     }
 
-    async handleTool(name, argsString) {
-        const args = JSON.parse(argsString);
-        if (name === 'get_weather')
-            return `Weather in ${args.location}: 72F, sunny`;
-        return 'Unknown tool';
+    // Tool implementations — define TOOL_ prefix methods
+    async TOOL_get_weather(args) {
+        return `Weather in ${args.location}: 72F, sunny`;
     }
 }
 
@@ -72,7 +69,7 @@ Saico separates construction from activation:
 const agent = new Saico({
     name: 'agent',
     prompt: 'System prompt here',
-    dynamodb_table: 'my_data',  // optional DB
+    dynamodb: { region: 'us-east-1', credentials: { accessKeyId: 'AK', secretAccessKey: 'SK' } },
 });
 
 // DB methods work before activation
@@ -145,7 +142,6 @@ When a Saico's context is not the deepest active one, its last 5 user/assistant
 const child = agent.spawnTaskWithContext({
     name: 'subtask',
     prompt: 'Handle this specific sub-task',
-    tool_handler: (name, args) => handleSubTools(name, args),
     functions: [/* child-specific tools */]
 }, [
     async function main() {
@@ -177,7 +173,6 @@ new Saico({
 
     // AI config
     prompt: 'System prompt',
-    tool_handler: fn,          // async (name, argsString) => result
     functions: [],             // OpenAI function definitions
 
     // Behavior
@@ -194,8 +189,10 @@ new Saico({
     // Storage
     redis: true,               // Set false to skip Redis proxy
     key: 'custom-redis-key',
-    dynamodb_table: 'table',   // Auto-creates DynamoDB adapter
-    dynamodb_region: 'us-east-1',
+    dynamodb: {                // DynamoDB config (creates adapter)
+        region: 'us-east-1',
+        credentials: { accessKeyId: '...', secretAccessKey: '...' },
+    },
     db: customAdapter,         // Any adapter with put/get/delete/query interface
 
     // User data
@@ -245,26 +242,26 @@ await agent.closeSession();  // Close context and cancel task
 
 ## Database Access
 
-Saico provides backend-agnostic DB methods. Configure via `dynamodb_table` (auto-creates DynamoDB adapter) or `db` (any adapter implementing the interface).
+Saico provides backend-agnostic DB methods. Configure via `opt.dynamodb` (auto-creates DynamoDB adapter) or `opt.db` (any adapter). Table name is required on every call. Child Saico instances without their own DB inherit the parent's adapter automatically via `_getDb()`.
 
 ```js
-// CRUD
-await agent.dbPutItem({ id: '123', name: 'test' });
-const item = await agent.dbGetItem('id', '123');
-await agent.dbDeleteItem('id', '123');
-const items = await agent.dbQuery('email-index', 'email', 'user@test.com');
-const all = await agent.dbGetAll();
+// CRUD — table name required on every call
+await agent.dbPutItem({ id: '123', name: 'test' }, 'my-table');
+const item = await agent.dbGetItem('id', '123', 'my-table');
+await agent.dbDeleteItem('id', '123', 'my-table');
+const items = await agent.dbQuery('email-index', 'email', 'user@test.com', 'my-table');
+const all = await agent.dbGetAll('my-table');
 
 // Updates
-await agent.dbUpdate('id', '123', 'status', 'active');
-await agent.dbUpdatePath('id', '123', [{ key: 'nested' }], 'field', 'value');
-await agent.dbListAppend('id', '123', 'tags', 'new-tag');
+await agent.dbUpdate('id', '123', 'status', 'active', 'my-table');
+await agent.dbUpdatePath('id', '123', [{ key: 'nested' }], 'field', 'value', 'my-table');
+await agent.dbListAppend('id', '123', 'tags', 'new-tag', 'my-table');
 
 // Counters
-const nextId = await agent.dbNextCounterId('OrderId');
-const count = await agent.dbGetCounterValue('OrderId');
-await agent.dbSetCounterValue('OrderId', 100);
-const total = await agent.dbCountItems();
+const nextId = await agent.dbNextCounterId('OrderId', 'counters');
+const count = await agent.dbGetCounterValue('OrderId', 'counters');
+await agent.dbSetCounterValue('OrderId', 100, 'counters');
+const total = await agent.dbCountItems('my-table');
 ```
 
 Override `_deserializeRecord(raw)` to transform raw DB records on retrieval (e.g., restore class instances):
@@ -286,7 +283,6 @@ const json = agent.serialize();
 
 // Restore
 const restored = Saico.deserialize(json, {
-    tool_handler: myHandler,
     functions: myFunctions,
 });
 ```
@@ -309,16 +305,26 @@ agent.someProperty = 'value';  // Auto-saved to Redis
 
 Properties prefixed with `_` are internal and not persisted.
 
-## Tool Handler Interface
+## Tool Implementation (TOOL_ methods)
+
+Define tool implementations as `TOOL_`-prefixed methods on your Saico subclass. When the LLM returns a tool call, Context automatically searches the Saico hierarchy (current → up parents → down children) to find and invoke the matching method with parsed arguments.
 
 ```js
-async function toolHandler(toolName, argumentsString) {
-    const args = JSON.parse(argumentsString);
-    // Execute tool logic
-    return result;  // string or { content: string, functions?: [] }
+class MyAgent extends Saico {
+    async TOOL_get_weather(args) {
+        // args is already JSON.parse'd
+        return `Weather in ${args.location}: 72F, sunny`;
+    }
+
+    async TOOL_search(args) {
+        const results = await search(args.query);
+        return { content: JSON.stringify(results), functions: updatedTools };
+    }
 }
 ```
 
+Return a string or `{ content: string, functions?: [] }`.
+
 ### Tool Safety Features
 
 - **Depth control** — `max_depth` (default: 5) prevents infinite tool call recursion
@@ -339,13 +345,12 @@ const { createTask, createContext, createQ } = require('saico');
 const task = createTask({
     name: 'my-task',
     prompt: 'You are helpful',
-    tool_handler: handler,
     functions: tools
 });
 const reply = await task.sendMessage('Hello');
 
 // Standalone context (legacy)
-const ctx = createQ('System prompt', null, 'tag', 4000, null, handler);
+const ctx = createQ('System prompt', null, 'tag', 4000);
 const reply = await ctx.sendMessage('user', 'Hello', functions);
 ```
 
@@ -371,7 +376,7 @@ saico/
 npm test
 ```
 
-294 tests covering Saico lifecycle, task hierarchy, message handling, tool calls, DB adapters, serialization, and integration flows.
+293 tests covering Saico lifecycle, task hierarchy, message handling, tool calls, DB adapters, serialization, and integration flows.
 
 ## Requirements
 

package/dynamo.js

@@ -3,9 +3,8 @@
 /**
  * DynamoDBAdapter — Generic DynamoDB access layer.
  *
- * Generalized from ../backend/aws.js. Provides CRUD, update, list-append,
- * counter, and scan operations. All methods accept an optional `table`
- * parameter that defaults to `this.defaultTable`.
+ * Provides CRUD, update, list-append, counter, and scan operations.
+ * Table name is required on every call.
  *
  * AWS SDK v3 packages are required only when this module is loaded.
  */
@@ -18,14 +17,16 @@ const { unmarshall, marshall } = require('@aws-sdk/util-dynamodb');
 class DynamoDBAdapter {
     /**
      * @param {Object} opt
-     * @param {string} opt.table - Default table name for all operations
      * @param {string} [opt.region='us-east-1'] - AWS region
+     * @param {Object} [opt.credentials] - AWS credentials { accessKeyId, secretAccessKey }
      * @param {DynamoDBClient} [opt.client] - Injectable DynamoDB client (for testing)
      */
     constructor(opt = {}) {
-        this.defaultTable = opt.table || null;
         this._region = opt.region || 'us-east-1';
-        this._client = opt.client || new DynamoDBClient({ region: this._region });
+        this._client = opt.client || new DynamoDBClient({
+            region: this._region,
+            ...(opt.credentials && { credentials: opt.credentials }),
+        });
         this.__docClient = null;
     }
 
@@ -36,9 +37,8 @@ class DynamoDBAdapter {
     }
 
     _table(table) {
-        const t = table || this.defaultTable;
-        if (!t) throw new Error('DynamoDBAdapter: no table specified');
-        return t;
+        if (!table) throw new Error('DynamoDBAdapter: table name required');
+        return table;
     }
 
     _unmarshall(item) {

package/index.js

@@ -54,7 +54,6 @@ async function init(config = {}) {
  * @param {Object|string} opt - Task options or name string
  * @param {string} opt.name - Task name
  * @param {string} opt.prompt - System prompt (if provided, creates a context)
- * @param {Function} opt.tool_handler - Tool handler function
  * @param {Array} opt.functions - Available functions for AI
  * @param {boolean} opt.cancel - Whether task is cancelable
  * @param {Object} opt.bind - Bind context for state functions
@@ -80,7 +79,6 @@ function createTask(opt, states = []) {
             token_limit: opt.token_limit,
             max_depth: opt.max_depth,
             max_tool_repetition: opt.max_tool_repetition,
-            tool_handler: opt.tool_handler,
             functions: opt.functions,
             sequential_mode: opt.sequential_mode
         });
@@ -99,11 +97,10 @@ function createTask(opt, states = []) {
  * @param {string} tag - Context tag identifier
  * @param {number} token_limit - Token limit for summarization
  * @param {Array} msgs - Initial messages
- * @param {Function} tool_handler - Tool handler function
  * @param {Object} config - Additional configuration
  * @returns {Context} Proxied Context instance
  */
-function createQ(prompt, parent, tag, token_limit, msgs, tool_handler, config = {}) {
+function createQ(prompt, parent, tag, token_limit, msgs, config = {}) {
     // For backward compatibility, if parent is a Context, get its task
     let task = null;
     if (parent && parent.task) {
@@ -114,7 +111,6 @@ function createQ(prompt, parent, tag, token_limit, msgs, tool_handler, config =
         tag,
         token_limit,
         msgs,
-        tool_handler,
         ...config
     });
 

package/itask.js

@@ -110,7 +110,6 @@ function Itask(opt, states){
     // Store options for context creation (prompt, functions, etc.)
     this.prompt = opt.prompt;
     this.functions = opt.functions;
-    this.tool_handler = opt.tool_handler;
 
     // register root if no explicit spawn_parent provided
     // If opt.spawn_parent provided, spawn under it

package/msgs.js

@@ -24,7 +24,6 @@ class Context {
         this.token_limit = config.token_limit || 1000000000;
         this.lower_limit = this.token_limit * 0.85;
         this.upper_limit = this.token_limit * 0.98;
-        this.tool_handler = config.tool_handler || task?.tool_handler;
         this.functions = config.functions || task?.functions || null;
 
         // Recursive depth and repetition control
@@ -63,8 +62,6 @@ class Context {
     // Set the task reference (used when context is created separately)
     setTask(task) {
         this.task = task;
-        if (!this.tool_handler)
-            this.tool_handler = task?.tool_handler;
         if (!this.functions)
             this.functions = task?.functions;
     }
@@ -287,10 +284,9 @@ class Context {
 
                     try {
                         const correspondingDeferred = deferredGroup.find(d => d.call.id === call.id);
-                        const handler = correspondingDeferred?.originalMessage.opts.handler || this.tool_handler;
                         const timeout = correspondingDeferred?.originalMessage.opts.timeout;
 
-                        result = await this._executeToolCallWithTimeout(call, handler, timeout);
+                        result = await this._executeToolCallWithTimeout(call, timeout);
                         if (_snap !== null &&
                             _snap !== JSON.stringify(this._snapshotPublicProps(this.task)))
                             this._appendToolDigest(call.function.name, result?.content || '');
@@ -669,7 +665,7 @@ class Context {
         }
     }
 
-    async _executeToolCallWithTimeout(call, handler, customTimeoutMs = null) {
+    async _executeToolCallWithTimeout(call, customTimeoutMs = null) {
         const timeoutMs = customTimeoutMs || 5000;
 
         return new Promise(async (resolve) => {
@@ -688,7 +684,7 @@ class Context {
             }, timeoutMs);
 
             try {
-                const result = await this.interpretAndApplyChanges(call, handler);
+                const result = await this.interpretAndApplyChanges(call);
 
                 if (!completed) {
                     completed = true;
@@ -1005,7 +1001,7 @@ class Context {
                             ? JSON.stringify(this._snapshotPublicProps(this.task)) : null;
                         try {
                             const result = await this._executeToolCallWithTimeout(
-                                call, o.opts?.handler, o.opts?.timeout);
+                                call, o.opts?.timeout);
                             const item = toolCallsWithResults.find(item => item.call.id === call.id);
                             if (item) item.result = result;
                             if (_snap !== null &&
@@ -1064,27 +1060,84 @@ class Context {
         }
     }
 
-    async interpretAndApplyChanges(call, handler) {
-        _log('apply tool', call.function.name, 'have handler', !!handler, !!this.tool_handler);
+    /**
+     * Search the Saico hierarchy for a TOOL_<toolName> method.
+     * Order: current task → walk UP parents → walk DOWN children (BFS).
+     */
+    _findToolImplementation(toolName) {
+        const methodName = 'TOOL_' + toolName;
+        const check = (task) =>
+            task?._saico && typeof task._saico[methodName] === 'function' ? task._saico : null;
+
+        // 1. Current task
+        let found = check(this.task);
+        if (found) return { saico: found, methodName };
+
+        // 2. Walk UP parent chain
+        let t = this.task?.parent;
+        while (t) {
+            found = check(t);
+            if (found) return { saico: found, methodName };
+            t = t.parent;
+        }
+
+        // 3. Walk DOWN from this.task (BFS)
+        if (this.task) {
+            const queue = [...this.task.child];
+            while (queue.length > 0) {
+                const child = queue.shift();
+                if (child._completed) continue;
+                found = check(child);
+                if (found) return { saico: found, methodName };
+                if (child.child?.size > 0) queue.push(...child.child);
+            }
+        }
+
+        return null;
+    }
+
+    async interpretAndApplyChanges(call) {
         if (!call)
             return { content: '', functions: null };
 
-        _log('invoking function', call.function.name);
-        handler ||= this.tool_handler;
-        let result = await handler(call.function.name, call.function.arguments);
+        const toolName = call.function.name;
+        _log('apply tool', toolName);
+
+        const impl = this._findToolImplementation(toolName);
+        if (!impl) {
+            _log('No TOOL_ method found for:', toolName);
+            return {
+                content: `Error: No implementation found for tool "${toolName}". ` +
+                    `Expected a TOOL_${toolName}(args) method on a Saico instance in the hierarchy.`,
+                functions: null
+            };
+        }
+
+        _log('invoking TOOL_' + toolName, 'on', impl.saico.name || impl.saico.constructor.name);
+
+        let parsedArgs;
+        try {
+            parsedArgs = JSON.parse(call.function.arguments);
+        } catch (e) {
+            return {
+                content: `Error: Failed to parse arguments for tool "${toolName}": ${e.message}`,
+                functions: null
+            };
+        }
+
+        let result = await impl.saico[impl.methodName](parsedArgs);
 
         let content = result?.content || result || '';
         let functions = result?.functions || null;
 
         if (content && typeof content !== 'string')
             content = JSON.stringify(content);
-        else if (!content)
-        {
-            content = `tool call ${call.function.name} ${call.id} completed. do not reply. wait for the next msg `
-                +`from the user`;
+        else if (!content) {
+            content = `tool call ${toolName} ${call.id} completed. do not reply. wait for the next msg `
+                + `from the user`;
         }
 
-        _log('FUNCTION RESULT', call.function.name, call.id, content.substring(0, 50) + '...',
+        _log('FUNCTION RESULT', toolName, call.id, content.substring(0, 50) + '...',
             functions ? 'with functions' : 'no functions');
         return { content, functions };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saico",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "main": "index.js",
   "type": "commonjs",
   "description": "Hierarchical AI Conversation Orchestrator - Task hierarchy with conversation contexts",

package/saico.js

@@ -29,14 +29,11 @@ class Saico {
      * @param {string} [opt.id] - Instance ID (auto-generated if omitted)
      * @param {string} [opt.name] - Instance name (defaults to class name)
      * @param {string} [opt.prompt] - Class-level system prompt
-     * @param {Function} [opt.tool_handler] - Tool handler function
      * @param {Array} [opt.functions] - Available AI functions
      * @param {string} [opt.key] - Redis key override (default: 'saico:<id>')
      * @param {boolean} [opt.redis=true] - Set false to skip Redis proxy
      * @param {boolean} [opt.isolate] - Isolate: don't aggregate from ancestors
-     * @param {string} [opt.dynamodb_table] - DynamoDB table name (enables db accessor)
-     * @param {string} [opt.dynamodb_region] - AWS region for DynamoDB
-     * @param {Object} [opt.dynamodb_client] - Injectable DynamoDB client (for testing)
+     * @param {Object} [opt.dynamodb] - DynamoDB config { region, credentials: { accessKeyId, secretAccessKey }, client }
      * @param {Object} [opt.db] - Pluggable DB backend
      * @param {Object} [opt.store] - Store instance override
      * @param {Object} [opt.userData] - Initial user data
@@ -53,7 +50,6 @@ class Saico {
         // Public configuration
         this.name = opt.name || this.constructor.name || 'saico';
         this.prompt = opt.prompt || '';
-        this.tool_handler = opt.tool_handler || null;
         this.functions = opt.functions || null;
 
         // Absorbed from Sid
@@ -70,12 +66,12 @@ class Saico {
 
         // DB backend — pluggable storage adapter.
         this._db = opt.db || null;
-        if (!this._db && opt.dynamodb_table) {
+        if (!this._db && opt.dynamodb) {
             const { DynamoDBAdapter } = require('./dynamo.js');
             this._db = new DynamoDBAdapter({
-                table: opt.dynamodb_table,
-                region: opt.dynamodb_region,
-                client: opt.dynamodb_client,
+                region: opt.dynamodb.region,
+                credentials: opt.dynamodb.credentials,
+                client: opt.dynamodb.client,
             });
         }
 
@@ -96,7 +92,6 @@ class Saico {
      * @param {Object} opts
      * @param {boolean} [opts.createQ] - If true, attach a message Q (Context)
      * @param {string} [opts.prompt] - Additional prompt (appended to class-level)
-     * @param {Function} [opts.tool_handler] - Override tool handler
      * @param {Array} [opts.functions] - Override functions
      * @param {Array} [opts.states] - Task state functions
      * @param {Itask} [opts.parent] - Parent task to spawn under
@@ -126,7 +121,6 @@ class Saico {
             id: opts.taskId,
             async: true,
             store: this._store,
-            tool_handler: opts.tool_handler || this.tool_handler,
             functions: opts.functions || this.functions,
             bind: this, // State functions run with Saico instance as `this`
         };
@@ -148,7 +142,6 @@ class Saico {
                 max_tool_repetition: opts.max_tool_repetition ?? this.sessionConfig.max_tool_repetition,
                 queue_limit: opts.queue_limit ?? this.sessionConfig.queue_limit,
                 min_chat_messages: opts.min_chat_messages ?? this.sessionConfig.min_chat_messages,
-                tool_handler: taskOpt.tool_handler,
                 functions: taskOpt.functions,
                 sequential_mode: opts.sequential_mode,
                 msgs: opts.msgs,
@@ -334,7 +327,6 @@ class Saico {
                 max_tool_repetition: opt.max_tool_repetition ?? this.sessionConfig.max_tool_repetition,
                 queue_limit: opt.queue_limit ?? this.sessionConfig.queue_limit,
                 min_chat_messages: opt.min_chat_messages ?? this.sessionConfig.min_chat_messages,
-                tool_handler: opt.tool_handler || this.tool_handler,
                 functions: opt.functions || this.functions,
             });
             childTask.setContext(childContext);
@@ -452,76 +444,90 @@ class Saico {
 
     // ---- Generic DB access ----
 
+    /**
+     * Find a DB backend — own _db first, then walk UP the parent Saico chain.
+     * Throws if no backend found anywhere.
+     */
+    _getDb() {
+        if (this._db) return this._db;
+        let task = this._task?.parent;
+        while (task) {
+            if (task._saico?._db) return task._saico._db;
+            task = task.parent;
+        }
+        throw new Error('No DB backend configured. Set opt.dynamodb or opt.db on this Saico or an ancestor.');
+    }
+
     async dbPutItem(item, table) {
-        if (!this._db) return;
-        return this._db.put(item, table);
+        const db = this._getDb();
+        return db.put(item, table);
     }
 
     async dbGetItem(key, value, table) {
-        if (!this._db) return;
-        const result = await this._db.get(key, value, table);
+        const db = this._getDb();
+        const result = await db.get(key, value, table);
         return result ? this._deserializeRecord(result) : result;
     }
 
     async dbDeleteItem(key, value, table) {
-        if (!this._db) return;
-        return this._db.delete(key, value, table);
+        const db = this._getDb();
+        return db.delete(key, value, table);
     }
 
     async dbQuery(index, key, value, table) {
-        if (!this._db) return;
-        const results = await this._db.query(index, key, value, table);
+        const db = this._getDb();
+        const results = await db.query(index, key, value, table);
         return Array.isArray(results)
             ? results.map(r => this._deserializeRecord(r))
             : results;
     }
 
     async dbGetAll(table) {
-        if (!this._db) return;
-        const results = await this._db.getAll(table);
+        const db = this._getDb();
+        const results = await db.getAll(table);
         return Array.isArray(results)
             ? results.map(r => this._deserializeRecord(r))
             : results;
     }
 
     async dbUpdate(key, keyValue, setKey, item, table) {
-        if (!this._db) return;
-        return this._db.update(key, keyValue, setKey, item, table);
+        const db = this._getDb();
+        return db.update(key, keyValue, setKey, item, table);
     }
 
     async dbUpdatePath(key, keyValue, path, setKey, item, table) {
-        if (!this._db) return;
-        return this._db.updatePath(key, keyValue, path, setKey, item, table);
+        const db = this._getDb();
+        return db.updatePath(key, keyValue, path, setKey, item, table);
     }
 
     async dbListAppend(key, keyValue, setKey, item, table) {
-        if (!this._db) return;
-        return this._db.listAppend(key, keyValue, setKey, item, table);
+        const db = this._getDb();
+        return db.listAppend(key, keyValue, setKey, item, table);
     }
 
     async dbListAppendPath(key, keyValue, path, setKey, item, table) {
-        if (!this._db) return;
-        return this._db.listAppendPath(key, keyValue, path, setKey, item, table);
+        const db = this._getDb();
+        return db.listAppendPath(key, keyValue, path, setKey, item, table);
     }
 
     async dbNextCounterId(counter, table) {
-        if (!this._db) return;
-        return this._db.nextCounterId(counter, table);
+        const db = this._getDb();
+        return db.nextCounterId(counter, table);
     }
 
     async dbGetCounterValue(counter, table) {
-        if (!this._db) return;
-        return this._db.getCounterValue(counter, table);
+        const db = this._getDb();
+        return db.getCounterValue(counter, table);
     }
 
     async dbSetCounterValue(counter, value, table) {
-        if (!this._db) return;
-        return this._db.setCounterValue(counter, value, table);
+        const db = this._getDb();
+        return db.setCounterValue(counter, value, table);
     }
 
     async dbCountItems(table) {
-        if (!this._db) return;
-        return this._db.countItems(table);
+        const db = this._getDb();
+        return db.countItems(table);
     }
 
     // ---- DB deserialization hook ----
@@ -565,7 +571,7 @@ class Saico {
     /**
      * Restore a Saico instance from serialized data.
      * @param {string|Object} data - Serialized data (JSON string or object)
-     * @param {Object} opt - Options (tool_handler, functions, store, states, etc.)
+     * @param {Object} opt - Options (functions, store, states, etc.)
      * @returns {Saico}
      */
     static deserialize(data, opt = {}) {
@@ -578,7 +584,6 @@ class Saico {
             userData: parsed.userData,
             sessionConfig: parsed.sessionConfig,
             isolate: parsed.isolate,
-            tool_handler: opt.tool_handler,
             functions: opt.functions || parsed.task?.context?.functions,
             store: opt.store,
             redis: false, // No Redis proxy during deserialization
@@ -593,7 +598,6 @@ class Saico {
                 taskId: parsed.task.id,
                 tag: parsed.task.context?.tag,
                 chat_history: parsed.task.context?.chat_history,
-                tool_handler: opt.tool_handler,
                 functions: opt.functions || parsed.task.context?.functions,
                 states: opt.states || [],
                 ...opt,