@olane/o-lane 0.7.12-alpha.9 → 0.7.12

package/dist/src/o-lane.js

@@ -1,4 +1,4 @@
-import { oAddress, oError, oErrorCodes, NodeState, oObject, } from '@olane/o-core';
+import { oAddress, oError, oErrorCodes, NodeState, oObject, oResponse, } from '@olane/o-core';
 import { CID } from 'multiformats';
 import * as json from 'multiformats/codecs/json';
 import { sha256 } from 'multiformats/hashes/sha2';
@@ -7,6 +7,7 @@ import { oIntentEncoder } from './intent-encoder/index.js';
 import { oLaneStatus } from './enum/o-lane.status-enum.js';
 import { oCapabilityResult, oCapabilityType, } from './capabilities/index.js';
 import { ALL_CAPABILITIES } from './capabilities-all/o-capability.all.js';
+import { MarkdownBuilder } from './formatters/index.js';
 export class oLane extends oObject {
     constructor(config) {
         super('o-lane:' + `[${config.intent.value}]`);
@@ -18,6 +19,7 @@ export class oLane extends oObject {
         this.sequence = Object.assign([], this.config.sequence || []);
         this.parentLaneId = this.config.parentLaneId;
         this.intentEncoder = new oIntentEncoder();
+        this.onChunk = this.config.onChunk;
         // set a max cycles if one is not provided
         if (!!process.env.MAX_CYCLES) {
             this.MAX_CYCLES = parseInt(process.env.MAX_CYCLES);
@@ -84,42 +86,142 @@ export class oLane extends oObject {
     }
     get agentHistory() {
         const added = {};
-        return (this.sequence
-            ?.filter((s) => {
+        const MAX_RESULT_LENGTH = 1000; // Truncate large results
+        const KEEP_FULL_DETAIL_COUNT = 3; // Keep full detail for last N cycles
+        const filteredSequence = this.sequence?.filter((s) => {
             if (added[s.id]) {
                 return false;
             }
             added[s.id] = true;
             return true;
-        })
+        });
+        return (filteredSequence
             ?.map((s, index) => {
+            const isRecent = index >= filteredSequence.length - KEEP_FULL_DETAIL_COUNT;
             const result = s.result || s.error;
-            return `[Cycle ${index + 1} Begin ${s.id}]\n
-            Cycle Intent: ${s.config?.intent.toString()}\n
-            Cycle Result:\n
-            ${typeof result === 'string'
-                ? result
-                : JSON.stringify({
-                    ...result,
-                }, null, 2)} \n[Cycle ${index + 1} End ${s.id}]`;
+            const params = s.config?.params || {};
+            // Extract summary and reasoning if available
+            const summary = params.summary || '';
+            const reasoning = params.reasoning || '';
+            // Format result, truncating if not a recent cycle
+            let formattedResult;
+            if (typeof result === 'string') {
+                formattedResult =
+                    isRecent || result.length <= MAX_RESULT_LENGTH
+                        ? result
+                        : result.substring(0, MAX_RESULT_LENGTH) + '... (truncated)';
+            }
+            else {
+                const jsonStr = JSON.stringify(result, null, 2);
+                formattedResult =
+                    isRecent || jsonStr.length <= MAX_RESULT_LENGTH
+                        ? jsonStr
+                        : jsonStr.substring(0, MAX_RESULT_LENGTH) + '... (truncated)';
+            }
+            // Build formatted history entry
+            let entry = `[Cycle ${index + 1}: ${s.type}]\n`;
+            entry += `Intent: ${s.config?.intent.toString()}\n`;
+            if (summary) {
+                entry += `Summary: ${summary}\n`;
+            }
+            if (reasoning) {
+                entry += `Reasoning: ${reasoning}\n`;
+            }
+            if (s.error) {
+                entry += `Error: ${s.error}\n`;
+            }
+            else {
+                entry += `Result: ${formattedResult}\n`;
+            }
+            return entry;
         })
             .join('\n') || '');
     }
+    /**
+     * Generate a human-readable execution trace of the lane
+     * Shows the decision points and flow of execution
+     */
+    getExecutionTrace() {
+        const mb = MarkdownBuilder.create();
+        mb.header('Execution Trace', 2);
+        mb.paragraph(`Intent: ${this.config.intent.value}`);
+        mb.paragraph(`Cycles: ${this.sequence.length}`);
+        mb.paragraph(`Status: ${this.status}`);
+        if (this.sequence.length === 0) {
+            mb.paragraph('No execution cycles recorded.');
+            return mb.build();
+        }
+        mb.br();
+        mb.header('Cycle Details', 3);
+        this.sequence.forEach((step, index) => {
+            const params = step.config?.params || {};
+            const summary = params.summary || '';
+            const reasoning = params.reasoning || '';
+            mb.br();
+            mb.raw(`${mb.bold(`Cycle ${index + 1}`)} [${step.type}]`);
+            if (summary) {
+                mb.raw(`\n└─ ${mb.italic('Summary:')} ${summary}`);
+            }
+            if (reasoning) {
+                mb.raw(`\n└─ ${mb.italic('Reasoning:')} ${reasoning}`);
+            }
+            if (step.error) {
+                mb.raw(`\n└─ ❌ ${mb.bold('Error:')} ${step.error}`);
+            }
+            else if (step.type === oCapabilityType.STOP) {
+                mb.raw(`\n└─ ✓ ${mb.bold('Completed')}`);
+            }
+        });
+        // Add final result summary
+        if (this.result) {
+            mb.br();
+            mb.hr();
+            mb.header('Final Result', 3);
+            const resultParams = this.result.config?.params || {};
+            const finalSummary = resultParams.summary || '';
+            if (finalSummary) {
+                mb.paragraph(finalSummary);
+            }
+            if (this.result.error) {
+                mb.paragraph(`${mb.bold('Status:')} Failed`);
+                mb.paragraph(`${mb.bold('Error:')} ${this.result.error}`);
+            }
+            else {
+                mb.paragraph(`${mb.bold('Status:')} Success`);
+            }
+        }
+        return mb.build();
+    }
     async preflight() {
         this.logger.debug('Preflight...');
         this.status = oLaneStatus.PREFLIGHT;
+        this.logger.debug('Pinging intelligence tool...');
+        // ping the intelligence tool to ensure it is available
+        await this.node.use(new oAddress('o://intelligence'), {
+            method: 'ping',
+            params: {},
+        });
     }
     async execute() {
         this.logger.debug('Executing...');
-        await this.preflight();
-        this.status = oLaneStatus.RUNNING;
         try {
+            await this.preflight().catch((error) => {
+                this.logger.error('Error in preflight: ', error);
+                this.result = new oCapabilityResult({
+                    type: oCapabilityType.ERROR,
+                    result: null,
+                    error: 'Intelligence services are not available. Try again later.',
+                });
+                throw new oError(oErrorCodes.INVALID_STATE, 'Intelligence services are not available. Try again later.');
+            });
+            this.status = oLaneStatus.RUNNING;
             this.result = await this.loop();
         }
         catch (error) {
             this.logger.error('Error in execute: ', error);
             this.status = oLaneStatus.FAILED;
         }
+        this.logger.debug('Completed loop...');
         await this.postflight(this.result);
         this.status = oLaneStatus.COMPLETED;
         return this.result;
@@ -137,19 +239,32 @@ export class oLane extends oObject {
                 ...this.config,
                 sequence: this.sequence, // pass the full sequence to the next capability
             },
+            useStream: this.config.useStream || false,
         };
     }
     async doCapability(currentStep) {
-        const capabilityType = currentStep.type;
-        for (const capability of this.capabilities) {
-            if (capability.type === capabilityType && currentStep.config) {
-                const capabilityConfig = this.resultToConfig(currentStep);
-                const result = await capability.execute({
-                    ...capabilityConfig,
-                });
-                return result;
+        try {
+            const capabilityType = currentStep.type;
+            for (const capability of this.capabilities) {
+                if (capability.type === capabilityType && currentStep.config) {
+                    const capabilityConfig = this.resultToConfig(currentStep);
+                    this.logger.debug('Executing capability: ', capabilityType);
+                    const result = await capability.execute({
+                        ...capabilityConfig,
+                    });
+                    return result;
+                }
             }
         }
+        catch (error) {
+            this.logger.error('Error in doCapability: ', error);
+            const errorResult = new oCapabilityResult({
+                type: oCapabilityType.ERROR,
+                result: null,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            });
+            return errorResult;
+        }
         throw new oError(oErrorCodes.INVALID_CAPABILITY, 'Unknown capability');
     }
     async loop() {
@@ -181,6 +296,12 @@ export class oLane extends oObject {
                 this.logger.debug('Capability result flagged for persistence - automatically setting persistToConfig');
                 this.config.persistToConfig = true;
             }
+            await this.emitNonFinalChunk(result, {
+                data: {
+                    ...result,
+                    config: undefined,
+                },
+            });
             if (result.type === oCapabilityType.STOP) {
                 return result;
             }
@@ -189,6 +310,18 @@ export class oLane extends oObject {
         }
         throw new Error('Plan failed');
     }
+    async emitNonFinalChunk(result, payload) {
+        if (this.config.useStream && this.onChunk) {
+            await this.onChunk(new oResponse({
+                ...payload,
+                _last: false,
+                _isStreaming: true,
+                _connectionId: this.node.address.toString(),
+                _requestMethod: 'unknown',
+                id: this.config.requestId ?? uuidv4(), // Use request ID for proper correlation, fallback to UUID
+            }));
+        }
+    }
     async postflight(response) {
         this.logger.debug('Postflight...');
         this.status = oLaneStatus.POSTFLIGHT;
@@ -211,9 +344,14 @@ export class oLane extends oObject {
                     const data = response?.result;
                     if (data.addresses_to_index) {
                         for (const address of data.addresses_to_index) {
-                            await this.node.use(new oAddress(address), {
+                            this.logger.debug('Indexing address: ', address.toString());
+                            await this.node
+                                .use(new oAddress(address), {
                                 method: 'index_network',
                                 params: {},
+                            })
+                                .catch((error) => {
+                                this.logger.error('Error indexing address: ', error);
                             });
                         }
                     }
@@ -232,6 +370,10 @@ export class oLane extends oObject {
     cancel() {
         this.logger.debug('Cancelling lane...');
         this.status = oLaneStatus.CANCELLED;
+        // tell all capabilities to cancel
+        for (const capability of this.capabilities) {
+            capability.cancel();
+        }
     }
     /**
      * Replay a stored lane from storage by CID

package/dist/src/o-lane.mixin.d.ts

@@ -0,0 +1,17 @@
+import { oToolBase } from '@olane/o-tool';
+/**
+ * withLane mixin - adds lane execution capabilities to any tool base class
+ * This mixin pattern allows lane functionality to be composed with different
+ * base classes (e.g., node-based, browser-based, or other implementations)
+ *
+ * @example
+ * ```typescript
+ * // Apply to node-based tool
+ * export class oLaneTool extends withLane(oNodeTool) {}
+ *
+ * // Future: Apply to browser-based tool
+ * export class oBrowserLaneTool extends withLane(oBrowserTool) {}
+ * ```
+ */
+export declare function withLane<T extends new (...args: any[]) => oToolBase>(Base: T): T;
+//# sourceMappingURL=o-lane.mixin.d.ts.map

package/dist/src/o-lane.mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-lane.mixin.d.ts","sourceRoot":"","sources":["../../src/o-lane.mixin.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAQ1C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,SAAS,EAClE,IAAI,EAAE,CAAC,GACN,CAAC,CAiJH"}

package/dist/src/o-lane.mixin.js

@@ -0,0 +1,136 @@
+import { CoreUtils, oAddress, oError, oErrorCodes, oResponse, } from '@olane/o-core';
+import { oCapabilityType } from './capabilities/index.js';
+import { oIntent } from './intent/index.js';
+import { oLaneContext } from './o-lane.context.js';
+import { oLaneManager } from './manager/o-lane.manager.js';
+import { oCapabilityResult } from './capabilities/o-capability.result.js';
+/**
+ * withLane mixin - adds lane execution capabilities to any tool base class
+ * This mixin pattern allows lane functionality to be composed with different
+ * base classes (e.g., node-based, browser-based, or other implementations)
+ *
+ * @example
+ * ```typescript
+ * // Apply to node-based tool
+ * export class oLaneTool extends withLane(oNodeTool) {}
+ *
+ * // Future: Apply to browser-based tool
+ * export class oBrowserLaneTool extends withLane(oBrowserTool) {}
+ * ```
+ */
+export function withLane(Base) {
+    return class extends Base {
+        constructor(...args) {
+            super(...args);
+            this.manager = new oLaneManager();
+        }
+        async _tool_handshake(handshake) {
+            this.logger.debug('Performing handshake with intent: ', handshake.params.intent);
+            let tools = await this.myTools();
+            let methods = this.methods;
+            const { tool } = handshake.params;
+            if (tool) {
+                tools = tools.filter((t) => t === tool);
+                methods = { tool: this.methods[tool] };
+            }
+            return new oCapabilityResult({
+                result: {
+                    tools: tools.filter((t) => t !== 'handshake' && t !== 'intent'),
+                    methods: methods,
+                },
+                type: oCapabilityType.HANDSHAKE,
+            });
+        }
+        /**
+         * Where all intents go to be resolved.
+         * @param request
+         * @returns
+         */
+        async _tool_intent(request) {
+            this.logger.debug('Intent resolution called: ', request.params);
+            const { intent, context, streamTo, _isStreaming = false } = request.params;
+            const pc = await this.manager.createLane({
+                intent: new oIntent({ intent: intent }),
+                currentNode: this,
+                caller: this.address,
+                streamTo: streamTo ? new oAddress(streamTo) : undefined,
+                useStream: _isStreaming,
+                requestId: request.id, // Pass request ID for proper response correlation
+                onChunk: _isStreaming
+                    ? async (chunk) => {
+                        if (chunk?._last ||
+                            chunk?.result?._last ||
+                            chunk?.result?.data?._last) {
+                            this.logger.error('UNEXPECTED LAST CHUNK RECEIVED', JSON.stringify(chunk, null, 2));
+                            throw new oError(oErrorCodes.INVALID_ACTION, 'Misbehaving client sent unexpected last chunk');
+                        }
+                        await CoreUtils.sendStreamResponse(oResponse.fromJSON(chunk), request.stream);
+                    }
+                    : undefined,
+                context: context
+                    ? new oLaneContext([
+                        `[Chat History Context Begin]\n${context}\n[Chat History Context End]`,
+                    ])
+                    : undefined,
+            });
+            // TODO: brendon experiment review
+            // stream.addEventListener('close', () => {
+            //   this.logger.debug('Stream closed, cancelling lane for intent:', intent);
+            //   pc.cancel();
+            // });
+            let response;
+            response = await pc.execute();
+            const completeResponse = {
+                result: response?.result,
+                humanResult: response?.humanResult, // Full human-readable formatted result (AI-generated markdown)
+                summary: response?.config?.params?.summary, // Short 1-2 sentence summary
+                error: response?.error,
+                cycles: pc.sequence.length,
+                cid: pc.cid?.toString(),
+                sequence: pc.sequence.map((s) => {
+                    return s.result;
+                }),
+            };
+            await new Promise((resolve) => setTimeout(resolve, 3000)); // TODO: fix this: wait for 3 seconds to let the stream send 2 messages lol
+            console.log('completeResponse', completeResponse);
+            return completeResponse;
+        }
+        /**
+         * Replay a stored lane from storage by CID
+         * This restores network state from a previously executed lane
+         * @param request - Request containing the CID of the lane to replay
+         * @returns The result of the replayed lane
+         */
+        async _tool_replay(request) {
+            this.logger.debug('Lane replay called: ', request.params);
+            const { cid } = request.params;
+            if (!cid || typeof cid !== 'string') {
+                throw new Error('CID parameter is required and must be a string');
+            }
+            // Create a lane instance for replay
+            const lane = await this.manager.createLane({
+                intent: new oIntent({ intent: 'replay' }),
+                currentNode: this,
+                caller: this.address,
+            });
+            try {
+                const response = await lane.replay(cid);
+                this.logger.debug('Lane replay response: ', response);
+                return {
+                    result: response?.result,
+                    error: response?.error,
+                    cycles: lane.sequence.length,
+                    cid: cid,
+                };
+            }
+            catch (error) {
+                this.logger.error('Lane replay failed: ', error);
+                throw error;
+            }
+        }
+        async teardown() {
+            await this.manager.teardown();
+            await super.teardown();
+        }
+    };
+}

package/dist/src/o-lane.tool.d.ts

@@ -1,23 +1,16 @@
-import { oRequest } from '@olane/o-core';
 import { oNodeConfig, oNodeTool } from '@olane/o-node';
-import { oHandshakeResult } from './interfaces/index.js';
-export declare class oLaneTool extends oNodeTool {
-    private manager;
+declare const oLaneTool_base: typeof oNodeTool;
+/**
+ * oLaneTool - Node-based tool with lane execution capabilities
+ * This class composes the withLane mixin with oNodeTool to provide
+ * a concrete implementation for node-based lane execution.
+ *
+ * All lane-specific functionality is provided by the withLane mixin,
+ * making this implementation backward compatible while enabling
+ * future flexibility to apply lane capabilities to other base classes.
+ */
+export declare class oLaneTool extends oLaneTool_base {
     constructor(config: oNodeConfig);
-    _tool_handshake(handshake: oRequest): Promise<oHandshakeResult>;
-    /**
-     * Where all intents go to be resolved.
-     * @param request
-     * @returns
-     */
-    _tool_intent(request: oRequest): Promise<any>;
-    /**
-     * Replay a stored lane from storage by CID
-     * This restores network state from a previously executed lane
-     * @param request - Request containing the CID of the lane to replay
-     * @returns The result of the replayed lane
-     */
-    _tool_replay(request: oRequest): Promise<any>;
-    teardown(): Promise<void>;
 }
+export {};
 //# sourceMappingURL=o-lane.tool.d.ts.map

package/dist/src/o-lane.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-lane.tool.d.ts","sourceRoot":"","sources":["../../src/o-lane.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAOzD,qBAAa,SAAU,SAAQ,SAAS;IACtC,OAAO,CAAC,OAAO,CAAe;gBAElB,MAAM,EAAE,WAAW;IAKzB,eAAe,CAAC,SAAS,EAAE,QAAQ,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyBrE;;;;OAIG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA4BnD;;;;;OAKG;IACG,YAAY,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IA8B7C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAIhC"}
+{"version":3,"file":"o-lane.tool.d.ts","sourceRoot":"","sources":["../../src/o-lane.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;;AAGvD;;;;;;;;GAQG;AACH,qBAAa,SAAU,SAAQ,cAAmB;gBACpC,MAAM,EAAE,WAAW;CAGhC"}

package/dist/src/o-lane.tool.js

@@ -1,98 +1,16 @@
-import { oAddress } from '@olane/o-core';
 import { oNodeTool } from '@olane/o-node';
-import { oCapabilityType } from './capabilities/index.js';
-import { oIntent } from './intent/index.js';
-import { oLaneContext } from './o-lane.context.js';
-import { oLaneManager } from './manager/o-lane.manager.js';
-import { oCapabilityResult } from './capabilities/o-capability.result.js';
-export class oLaneTool extends oNodeTool {
+import { withLane } from './o-lane.mixin.js';
+/**
+ * oLaneTool - Node-based tool with lane execution capabilities
+ * This class composes the withLane mixin with oNodeTool to provide
+ * a concrete implementation for node-based lane execution.
+ *
+ * All lane-specific functionality is provided by the withLane mixin,
+ * making this implementation backward compatible while enabling
+ * future flexibility to apply lane capabilities to other base classes.
+ */
+export class oLaneTool extends withLane(oNodeTool) {
     constructor(config) {
         super(config);
-        this.manager = new oLaneManager();
-    }
-    async _tool_handshake(handshake) {
-        this.logger.debug('Performing handshake with intent: ', handshake.params.intent);
-        let tools = await this.myTools();
-        let methods = this.methods;
-        const { tool } = handshake.params;
-        if (tool) {
-            tools = tools.filter((t) => t === tool);
-            methods = { tool: this.methods[tool] };
-        }
-        return new oCapabilityResult({
-            result: {
-                tools: tools.filter((t) => t !== 'handshake' && t !== 'intent'),
-                methods: methods,
-            },
-            type: oCapabilityType.HANDSHAKE,
-        });
-    }
-    /**
-     * Where all intents go to be resolved.
-     * @param request
-     * @returns
-     */
-    async _tool_intent(request) {
-        this.logger.debug('Intent resolution called: ', request.params);
-        const { intent, context, streamTo } = request.params;
-        const pc = await this.manager.createLane({
-            intent: new oIntent({ intent: intent }),
-            currentNode: this,
-            caller: this.address,
-            streamTo: streamTo ? new oAddress(streamTo) : undefined,
-            context: context
-                ? new oLaneContext([
-                    `[Chat History Context Begin]\n${context}\n[Chat History Context End]`,
-                ])
-                : undefined,
-        });
-        const response = await pc.execute();
-        this.logger.debug('Intent resolution response: ', response);
-        return {
-            result: response?.result,
-            error: response?.error,
-            cycles: pc.sequence.length,
-            cid: pc.cid?.toString(),
-            sequence: pc.sequence.map((s) => {
-                return s.result;
-            }),
-        };
-    }
-    /**
-     * Replay a stored lane from storage by CID
-     * This restores network state from a previously executed lane
-     * @param request - Request containing the CID of the lane to replay
-     * @returns The result of the replayed lane
-     */
-    async _tool_replay(request) {
-        this.logger.debug('Lane replay called: ', request.params);
-        const { cid } = request.params;
-        if (!cid || typeof cid !== 'string') {
-            throw new Error('CID parameter is required and must be a string');
-        }
-        // Create a lane instance for replay
-        const lane = await this.manager.createLane({
-            intent: new oIntent({ intent: 'replay' }),
-            currentNode: this,
-            caller: this.address,
-        });
-        try {
-            const response = await lane.replay(cid);
-            this.logger.debug('Lane replay response: ', response);
-            return {
-                result: response?.result,
-                error: response?.error,
-                cycles: lane.sequence.length,
-                cid: cid,
-            };
-        }
-        catch (error) {
-            this.logger.error('Lane replay failed: ', error);
-            throw error;
-        }
-    }
-    async teardown() {
-        await this.manager.teardown();
-        await super.teardown();
     }
 }

package/dist/src/prompts/agent.prompt.d.ts

@@ -1,2 +1,13 @@
+/**
+ * Cycle instructions for seeding - extracted from agent workflow
+ */
+export declare const CYCLE_INSTRUCTIONS_SEED = "\n  Every Step Instructions:\n1. Review the provided user intent, context and agent history\n2. If you can complete the user intent, return the \"Stop Response\" using the [RETURN INSTRUCTIONS] steps\n3. If the intent is already completed in past cycles, return the \"Stop Response\" using the [RETURN INSTRUCTIONS] steps\n4. If you experience 3 similar errors in a row, return the \"Stop Response\" indicating an error and follow the [RETURN INSTRUCTIONS] steps\n5. Review the current step number and perform the instructions associated with that step\n6. Start with step 1\n\nStep 1 - Evaluate the intent\n1. A complex step means there are multiple actions required to complete the user's intent\n2. If the intent is not-complex, continue to step 2\n3. If the intent is complex, break it up into a list of simple concise intents. Return the \"Complex Intent Response\" using the [RETURN INSTRUCTIONS]\n\nStep 2 - Search for tools and context\n1. If all entities and tool addresses are known within the user intent, continue to step 4\n2. If you know the tool address to use to complete the user intent, continue to step 4\n3. If there are unknown tool addresses or entities within the user intent, generate search queries to resolve the unknown entities. \n4. Use the o://mcp search tool to find model context protocol servers (MCP servers) that can help you add tooling that could help you complete the user intent.\n5. If there is a placeholder address used (o://.../placeholder), do not extract the contents of the placeholder address unless necessary for completing the user intent.\n6. Use the search results data & tooling to help you resolve the unknown entities.\n7. Continue to step 3.\n\nStep 3 - Filter Search Results\n1. If all search results are relevant to the user intent resolution, continue to step 4.\n2. Filter the search results for information that may contain supporting data or tooling that can help complete the user intent.\n3. If you do not see anything that can help you. Return the \"Stop Response\" using the [RETURN INSTRUCTIONS]\n4. Continue to step 4\n\nStep 4 - Configure the target tool address use\n1. Identify the tool address that most likely will help you complete the user intent.\n2. Review the provided context for past cycles that contain configuration instructions for the target tool address.\n3. If there is no configuration instructions for the target tool address, return the \"Configure Response\" using the [RETURN INSTRUCTIONS]\n4. Identify if there are any missing parameter values for the target tool address and search for them if so.\n5. If the tool use configuration is already known including all parameter values, continue to step 5\n\nStep 5 - Use target tool address\n1. If the target tool address configuration is known, return the \"Use Tool Response\" using the [RETURN INSTRUCTIONS]\n2. If the target tool address with the same configuration has failed in the past cycles, return the \"Error Response\" using the [RETURN INSTRUCTIONS] steps to indicate the error.\n3. Using this filtered tool list, return the \"Use Tool Response\" using the [RETURN INSTRUCTIONS] steps to return a series of addresses and respective intents to align with the current user intent resolution goal\n4. Continue to step 6\n\nStep 6 - Review the tool use results\n1. Analyze each tool use result\n2. When formatting tool results for the user in a Stop Response, present as clean markdown:\n   - For general contexts, present as clean markdown:\n     * Use headings to organize different sections\n     * Use lists for multiple items\n     * Use bold for important values or labels\n     * Use code blocks for addresses (e.g., `o://tool-address`)\n     * Transform raw JSON into readable prose and structured lists\n3. In the summary field, provide a 1-2 sentence overview\n4. If it failed, clearly explain why in a user-friendly way\n\n\n  ";
+/**
+ * Output instructions for seeding - extracted from return format specifications
+ */
+export declare const OUTPUT_INSTRUCTIONS_SEED = "\n[RETURN INSTRUCTIONS BEGIN]\nThese are the types of cycle responses: \"Complex Intent Response\", \"Search Response\", \"Use Tool Response\", \"Stop Response\", \"Error Response\", \"Configure Response\".\n\nAll Return Step Instructions:\n1. Do not explain your reasoning process, just return the output in the correct format.\n2. Determine what type of results we have\n3. Output the respective results using the matching output type.\n4. Generate a reasoning key value pair for why this result was returned.\n5. The reasoning should be no longer than 1 sentence.\n6. The summary should be a short message used to inform the user of the result of the cycle. These updates should be insightful and concise and within 1-2 sentences.\n6. Do not include ```json or ``` in your output.\n\nComplex Intent Results:\n{\n  \"intents\": [\n    \"simple intent 1\",\n    \"simple intent 2\",\n    \"simple intent 3\",\n  ],\n  \"summary\": string,\n  \"reasoning\": string,\n  \"type\": \"multiple_step\",\n}\n\nConfigure Response:\n{\n  \"intent\": string,\n  \"toolAddress\": string,\n  \"reasoning\": string,\n  \"summary\": string,\n  \"type\": \"configure\",\n}\n\nSearch Response:\n{\n  \"queries\": [\n    {\n      \"query\": \"vector database query key terms to search for\",\n      \"limit\": number,\n    }\n  ],\n  \"isExternal\": boolean,\n  \"reasoning\": string,\n  \"summary\": string,\n  \"type\": \"search\",\n}\n\nStop Response:\n{\n  \"result\": string, // IMPORTANT: Format this as clean, readable markdown. Use headers (##, ###), lists (-, 1.), bold (**text**), and code blocks (`code`) to make the response easy to read. Structure tool outputs, search results, and data clearly. Focus on what the user needs to know, not raw data dumps.\n  \"reasoning\": string,\n  \"addresses_to_index\": [string], // COMMENT: If the results of a tool use include \"address_to_index\", list them in the \"addresses_to_index\" array.\n  \"summary\": string, // A concise 1-2 sentence summary for the user\n  \"type\": \"stop\",\n}\n\nError Response:\n{\n  \"result\": \"string explaining the error\",\n  \"summary\": string,\n  \"reasoning\": string,\n  \"type\": \"evaluate\",\n}\n\nUse Tool Response:\n{\n  \"task\": {\n    \"address\": string,\n    \"payload\": { \"method\": string, \"params\": any }\n  },\n  \"summary\": string,\n  \"type\": \"task\",\n}\n[RETURN INSTRUCTIONS END]\n\n  ";
+/**
+ * Runtime agent prompt function with parameter interpolation
+ */
 export declare const AGENT_PROMPT: (intent: string, context: string, agentHistory: string, extraInstructions: string) => string;
 //# sourceMappingURL=agent.prompt.d.ts.map

package/dist/src/prompts/agent.prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.prompt.d.ts","sourceRoot":"","sources":["../../../src/prompts/agent.prompt.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,WACf,MAAM,WACL,MAAM,gBACD,MAAM,qBACD,MAAM,WA+HxB,CAAC"}
+{"version":3,"file":"agent.prompt.d.ts","sourceRoot":"","sources":["../../../src/prompts/agent.prompt.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,uBAAuB,izHAuDjC,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,wBAAwB,41EA4ElC,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,YAAY,WACf,MAAM,WACL,MAAM,gBACD,MAAM,qBACD,MAAM,WASxB,CAAC"}