@olane/o-lane 0.7.12-alpha.6 → 0.7.12-alpha.61

package/dist/src/errors/capability-errors.js

@@ -0,0 +1,142 @@
+/**
+ * Structured error types for capability execution
+ */
+export var CapabilityErrorType;
+(function (CapabilityErrorType) {
+    // Tool/Resource errors
+    CapabilityErrorType["NOT_FOUND"] = "not_found";
+    CapabilityErrorType["UNAUTHORIZED"] = "unauthorized";
+    CapabilityErrorType["FORBIDDEN"] = "forbidden";
+    // Configuration errors
+    CapabilityErrorType["INVALID_CONFIG"] = "invalid_config";
+    CapabilityErrorType["MISSING_PARAMETER"] = "missing_parameter";
+    CapabilityErrorType["INVALID_PARAMETER"] = "invalid_parameter";
+    // Execution errors
+    CapabilityErrorType["TOOL_ERROR"] = "tool_error";
+    CapabilityErrorType["TIMEOUT"] = "timeout";
+    CapabilityErrorType["NETWORK_ERROR"] = "network_error";
+    // State errors
+    CapabilityErrorType["INVALID_STATE"] = "invalid_state";
+    CapabilityErrorType["RESOURCE_EXHAUSTED"] = "resource_exhausted";
+    // Unknown
+    CapabilityErrorType["UNKNOWN"] = "unknown";
+})(CapabilityErrorType || (CapabilityErrorType = {}));
+/**
+ * Structured capability error with context and remediation suggestions
+ */
+export class CapabilityError extends Error {
+    constructor(type, message, context = {}, originalError) {
+        super(message);
+        this.name = 'CapabilityError';
+        this.type = type;
+        this.context = context;
+        this.originalError = originalError;
+        // Maintain proper stack trace
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, CapabilityError);
+        }
+    }
+    /**
+     * Get a human-readable error message with context
+     */
+    toHumanReadable() {
+        let message = `${this.getErrorTypeLabel()}: ${this.message}`;
+        if (this.context.cycle !== undefined) {
+            message += `\n\nOccurred in Cycle ${this.context.cycle}`;
+        }
+        if (this.context.capabilityType) {
+            message += `\nCapability: ${this.context.capabilityType}`;
+        }
+        if (this.context.toolAddress) {
+            message += `\nTool: ${this.context.toolAddress}`;
+        }
+        if (this.context.method) {
+            message += `\nMethod: ${this.context.method}`;
+        }
+        const remediation = this.getRemediation();
+        if (remediation) {
+            message += `\n\nSuggestion: ${remediation}`;
+        }
+        return message;
+    }
+    /**
+     * Get a friendly label for the error type
+     */
+    getErrorTypeLabel() {
+        const labels = {
+            [CapabilityErrorType.NOT_FOUND]: 'Resource Not Found',
+            [CapabilityErrorType.UNAUTHORIZED]: 'Unauthorized',
+            [CapabilityErrorType.FORBIDDEN]: 'Forbidden',
+            [CapabilityErrorType.INVALID_CONFIG]: 'Invalid Configuration',
+            [CapabilityErrorType.MISSING_PARAMETER]: 'Missing Parameter',
+            [CapabilityErrorType.INVALID_PARAMETER]: 'Invalid Parameter',
+            [CapabilityErrorType.TOOL_ERROR]: 'Tool Execution Error',
+            [CapabilityErrorType.TIMEOUT]: 'Timeout',
+            [CapabilityErrorType.NETWORK_ERROR]: 'Network Error',
+            [CapabilityErrorType.INVALID_STATE]: 'Invalid State',
+            [CapabilityErrorType.RESOURCE_EXHAUSTED]: 'Resource Exhausted',
+            [CapabilityErrorType.UNKNOWN]: 'Unknown Error',
+        };
+        return labels[this.type] || 'Error';
+    }
+    /**
+     * Get remediation suggestion based on error type
+     */
+    getRemediation() {
+        const remediations = {
+            [CapabilityErrorType.NOT_FOUND]: 'Verify the tool address exists and is accessible. Use search to find available tools.',
+            [CapabilityErrorType.UNAUTHORIZED]: 'Check that you have the necessary permissions to access this resource.',
+            [CapabilityErrorType.INVALID_CONFIG]: 'Review the configuration parameters and ensure they match the required format.',
+            [CapabilityErrorType.MISSING_PARAMETER]: 'Provide all required parameters. Use the tool\'s handshake to see parameter requirements.',
+            [CapabilityErrorType.INVALID_PARAMETER]: 'Check that parameter values match the expected types and constraints.',
+            [CapabilityErrorType.TOOL_ERROR]: 'Review the tool\'s error message and adjust your request accordingly.',
+            [CapabilityErrorType.TIMEOUT]: 'The operation took too long. Try simplifying the request or increasing the timeout.',
+            [CapabilityErrorType.NETWORK_ERROR]: 'Check your network connection and try again.',
+            [CapabilityErrorType.RESOURCE_EXHAUSTED]: 'You may have hit a rate limit or resource quota. Try again later.',
+        };
+        return remediations[this.type] || null;
+    }
+    /**
+     * Convert to JSON for serialization
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            message: this.message,
+            context: this.context,
+            humanReadable: this.toHumanReadable(),
+            stack: this.stack,
+        };
+    }
+    /**
+     * Create a CapabilityError from a generic error
+     */
+    static from(error, context = {}) {
+        if (error instanceof CapabilityError) {
+            return error;
+        }
+        // Try to infer error type from message
+        let type = CapabilityErrorType.UNKNOWN;
+        const message = error?.message || String(error);
+        if (message.includes('not found') || message.includes('404')) {
+            type = CapabilityErrorType.NOT_FOUND;
+        }
+        else if (message.includes('unauthorized') || message.includes('401')) {
+            type = CapabilityErrorType.UNAUTHORIZED;
+        }
+        else if (message.includes('forbidden') || message.includes('403')) {
+            type = CapabilityErrorType.FORBIDDEN;
+        }
+        else if (message.includes('timeout')) {
+            type = CapabilityErrorType.TIMEOUT;
+        }
+        else if (message.includes('network') || message.includes('ECONNREFUSED')) {
+            type = CapabilityErrorType.NETWORK_ERROR;
+        }
+        else if (message.includes('parameter') || message.includes('config')) {
+            type = CapabilityErrorType.INVALID_CONFIG;
+        }
+        return new CapabilityError(type, message, context, error instanceof Error ? error : undefined);
+    }
+}

package/dist/src/errors/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Error handling exports
+ */
+export { CapabilityError, CapabilityErrorType, type CapabilityErrorContext, } from './capability-errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/errors/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC"}

package/dist/src/errors/index.js

@@ -0,0 +1,4 @@
+/**
+ * Error handling exports
+ */
+export { CapabilityError, CapabilityErrorType, } from './capability-errors.js';

package/dist/src/formatters/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utilities for programmatic markdown generation
+ * Used only for system-generated content like execution traces
+ * AI-generated responses handle their own formatting via prompts
+ */
+export { MarkdownBuilder } from './markdown-builder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/formatters/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/src/formatters/index.js

@@ -0,0 +1,6 @@
+/**
+ * Utilities for programmatic markdown generation
+ * Used only for system-generated content like execution traces
+ * AI-generated responses handle their own formatting via prompts
+ */
+export { MarkdownBuilder } from './markdown-builder.js';

package/dist/src/formatters/markdown-builder.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Utility class for building markdown formatted strings
+ * Used for programmatic content generation (execution traces, etc.)
+ * NOT used for AI-generated responses - AI handles its own formatting
+ */
+export declare class MarkdownBuilder {
+    private parts;
+    /**
+     * Add a header
+     */
+    header(text: string, level?: number): this;
+    /**
+     * Add a paragraph
+     */
+    paragraph(text: string): this;
+    /**
+     * Add a bulleted list
+     */
+    list(items: string[], ordered?: boolean): this;
+    /**
+     * Add a code block
+     */
+    code(content: string, language?: string): this;
+    /**
+     * Add inline code
+     */
+    inline(text: string): string;
+    /**
+     * Add bold text
+     */
+    bold(text: string): string;
+    /**
+     * Add italic text
+     */
+    italic(text: string): string;
+    /**
+     * Add a link
+     */
+    link(text: string, url: string): string;
+    /**
+     * Add a collapsible details section
+     */
+    details(summary: string, content: string): this;
+    /**
+     * Add a horizontal rule
+     */
+    hr(): this;
+    /**
+     * Add raw text without additional spacing
+     */
+    raw(text: string): this;
+    /**
+     * Add a line break
+     */
+    br(): this;
+    /**
+     * Build the final markdown string
+     */
+    build(): string;
+    /**
+     * Create a new builder instance
+     */
+    static create(): MarkdownBuilder;
+}
+//# sourceMappingURL=markdown-builder.d.ts.map

package/dist/src/formatters/markdown-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-builder.d.ts","sourceRoot":"","sources":["../../../src/formatters/markdown-builder.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAgB;IAE7B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,IAAI;IAO7C;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAQ7B;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,GAAE,OAAe,GAAG,IAAI;IASrD;;OAEG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAW,GAAG,IAAI;IAQlD;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI5B;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI1B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI5B;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAIvC;;OAEG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAU/C;;OAEG;IACH,EAAE,IAAI,IAAI;IAMV;;OAEG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKvB;;OAEG;IACH,EAAE,IAAI,IAAI;IAKV;;OAEG;IACH,KAAK,IAAI,MAAM;IAIf;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,eAAe;CAGjC"}

package/dist/src/formatters/markdown-builder.js

@@ -0,0 +1,120 @@
+/**
+ * Utility class for building markdown formatted strings
+ * Used for programmatic content generation (execution traces, etc.)
+ * NOT used for AI-generated responses - AI handles its own formatting
+ */
+export class MarkdownBuilder {
+    constructor() {
+        this.parts = [];
+    }
+    /**
+     * Add a header
+     */
+    header(text, level = 1) {
+        const prefix = '#'.repeat(Math.max(1, Math.min(6, level)));
+        this.parts.push(`${prefix} ${text}`);
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Add a paragraph
+     */
+    paragraph(text) {
+        if (text) {
+            this.parts.push(text);
+            this.parts.push('');
+        }
+        return this;
+    }
+    /**
+     * Add a bulleted list
+     */
+    list(items, ordered = false) {
+        items.forEach((item, idx) => {
+            const prefix = ordered ? `${idx + 1}. ` : '- ';
+            this.parts.push(`${prefix}${item}`);
+        });
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Add a code block
+     */
+    code(content, language = '') {
+        this.parts.push(`\`\`\`${language}`);
+        this.parts.push(content);
+        this.parts.push('```');
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Add inline code
+     */
+    inline(text) {
+        return `\`${text}\``;
+    }
+    /**
+     * Add bold text
+     */
+    bold(text) {
+        return `**${text}**`;
+    }
+    /**
+     * Add italic text
+     */
+    italic(text) {
+        return `*${text}*`;
+    }
+    /**
+     * Add a link
+     */
+    link(text, url) {
+        return `[${text}](${url})`;
+    }
+    /**
+     * Add a collapsible details section
+     */
+    details(summary, content) {
+        this.parts.push('<details>');
+        this.parts.push(`<summary>${summary}</summary>`);
+        this.parts.push('');
+        this.parts.push(content);
+        this.parts.push('</details>');
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Add a horizontal rule
+     */
+    hr() {
+        this.parts.push('---');
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Add raw text without additional spacing
+     */
+    raw(text) {
+        this.parts.push(text);
+        return this;
+    }
+    /**
+     * Add a line break
+     */
+    br() {
+        this.parts.push('');
+        return this;
+    }
+    /**
+     * Build the final markdown string
+     */
+    build() {
+        return this.parts.join('\n').trim();
+    }
+    /**
+     * Create a new builder instance
+     */
+    static create() {
+        return new MarkdownBuilder();
+    }
+}

package/dist/src/interfaces/o-lane.config.d.ts

@@ -15,5 +15,7 @@ export interface oLaneConfig {
     parentLaneId?: string;
     maxCycles?: number;
     persistToConfig?: boolean;
+    onChunk?: (chunk: any) => void;
+    useStream?: boolean;
 }
 //# sourceMappingURL=o-lane.config.d.ts.map

package/dist/src/interfaces/o-lane.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-lane.config.d.ts","sourceRoot":"","sources":["../../../src/interfaces/o-lane.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAS,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,MAAM,WAAW,WAAW;IAE1B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,QAAQ,CAAC;IAEjB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IAEjB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAG7B,WAAW,EAAE,SAAS,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B"}
+{"version":3,"file":"o-lane.config.d.ts","sourceRoot":"","sources":["../../../src/interfaces/o-lane.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAS,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAC;AAC9D,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,MAAM,WAAW,WAAW;IAE1B,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,QAAQ,CAAC;IAEjB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC;IAEjB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;IAG7B,WAAW,EAAE,SAAS,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB"}

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

@@ -15,6 +15,7 @@ export declare class oLane extends oObject {
     MAX_CYCLES: number;
     status: oLaneStatus;
     result: oCapabilityResult | undefined;
+    onChunk?: (chunk: any) => void;
     constructor(config: oLaneConfig);
     get intent(): oIntent;
     toCIDInput(): any;
@@ -27,6 +28,11 @@ export declare class oLane extends oObject {
     toCID(): Promise<CID>;
     store(): Promise<CID>;
     get agentHistory(): string;
+    /**
+     * Generate a human-readable execution trace of the lane
+     * Shows the decision points and flow of execution
+     */
+    getExecutionTrace(): string;
     preflight(): Promise<void>;
     execute(): Promise<oCapabilityResult | undefined>;
     get capabilities(): import("./capabilities/o-capability.js").oCapability[];

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

@@ -1 +1 @@
-{"version":3,"file":"o-lane.d.ts","sourceRoot":"","sources":["../../src/o-lane.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,OAAO,EAER,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAInC,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EAElB,MAAM,yBAAyB,CAAC;AAGjC,qBAAa,KAAM,SAAQ,OAAO;IAUpB,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,WAAW;IAT3C,QAAQ,EAAE,iBAAiB,EAAE,CAAM;IACnC,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC;IACrB,EAAE,EAAE,MAAM,CAAY;IACtB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,aAAa,EAAE,cAAc,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAM;IACxB,MAAM,EAAE,WAAW,CAAuB;IAC1C,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;gBAEd,MAAM,EAAE,WAAW;IAalD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,UAAU,IAAI,GAAG;IAQjB,MAAM;;;;;IAQN,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAgB/B,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC;IAUrB,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC;IAuB3B,IAAI,YAAY,WA8Bf;IACK,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAK1B,OAAO,IAAI,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAevD,IAAI,YAAY,2DAEf;IAED,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,iBAAiB;IAaxC,YAAY,CAChB,WAAW,EAAE,iBAAiB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;IAevB,IAAI,IAAI,OAAO,CAAC,iBAAiB,CAAC;IA8ClC,UAAU,CACd,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAiDzC,MAAM;IAKN;;;OAGG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAwEjE;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAS9B,IAAI,IAAI,yCAEP;CACF"}
+{"version":3,"file":"o-lane.d.ts","sourceRoot":"","sources":["../../src/o-lane.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,OAAO,EAGR,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAInC,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC3D,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EAElB,MAAM,yBAAyB,CAAC;AAIjC,qBAAa,KAAM,SAAQ,OAAO;IAWpB,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,WAAW;IAV3C,QAAQ,EAAE,iBAAiB,EAAE,CAAM;IACnC,GAAG,EAAE,GAAG,GAAG,SAAS,CAAC;IACrB,EAAE,EAAE,MAAM,CAAY;IACtB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,aAAa,EAAE,cAAc,CAAC;IAC9B,UAAU,EAAE,MAAM,CAAM;IACxB,MAAM,EAAE,WAAW,CAAuB;IAC1C,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACtC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;gBAEP,MAAM,EAAE,WAAW;IAalD,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,UAAU,IAAI,GAAG;IAQjB,MAAM;;;;;IAQN,WAAW,CAAC,MAAM,EAAE,iBAAiB;IAgB/B,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC;IAUrB,KAAK,IAAI,OAAO,CAAC,GAAG,CAAC;IAuB3B,IAAI,YAAY,WA8Df;IAED;;;OAGG;IACH,iBAAiB,IAAI,MAAM;IA+DrB,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAW1B,OAAO,IAAI,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IA4BvD,IAAI,YAAY,2DAEf;IAED,cAAc,CAAC,MAAM,EAAE,GAAG,GAAG,iBAAiB;IAcxC,YAAY,CAChB,WAAW,EAAE,iBAAiB,GAC7B,OAAO,CAAC,iBAAiB,CAAC;IAiBvB,IAAI,IAAI,OAAO,CAAC,iBAAiB,CAAC;IA+DlC,UAAU,CACd,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAsDzC,MAAM;IASN;;;OAGG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAwEjE;;;;OAIG;IACH,OAAO,CAAC,sBAAsB;IAS9B,IAAI,IAAI,yCAEP;CACF"}

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,6 +239,7 @@ 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) {
@@ -144,8 +247,10 @@ export class oLane extends oObject {
         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,
+                    onChunk: this.onChunk,
                 });
                 return result;
             }
@@ -181,6 +286,19 @@ export class oLane extends oObject {
                 this.logger.debug('Capability result flagged for persistence - automatically setting persistToConfig');
                 this.config.persistToConfig = true;
             }
+            if (this.config.useStream && this.onChunk) {
+                this.onChunk(new oResponse({
+                    data: {
+                        ...result,
+                        config: undefined,
+                    },
+                    _last: false,
+                    _isStreaming: true,
+                    _connectionId: this.node.address.toString(),
+                    _requestMethod: 'unknown',
+                    id: uuidv4(),
+                }));
+            }
             if (result.type === oCapabilityType.STOP) {
                 return result;
             }
@@ -211,9 +329,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 +355,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.tool.d.ts

@@ -1,5 +1,5 @@
 import { oRequest } from '@olane/o-core';
-import { oNodeConfig, oNodeTool } from '@olane/o-node';
+import { oNodeConfig, oNodeTool, oStreamRequest } from '@olane/o-node';
 import { oHandshakeResult } from './interfaces/index.js';
 export declare class oLaneTool extends oNodeTool {
     private manager;
@@ -10,7 +10,7 @@ export declare class oLaneTool extends oNodeTool {
      * @param request
      * @returns
      */
-    _tool_intent(request: oRequest): Promise<any>;
+    _tool_intent(request: oStreamRequest): Promise<any>;
     /**
      * Replay a stored lane from storage by CID
      * This restores network state from a previously executed lane