@olane/o-lane 0.7.18 → 0.7.19

package/dist/src/prompts/o-prompt.js

@@ -0,0 +1,92 @@
+import { oObject } from "@olane/o-core";
+import Handlebars from "handlebars";
+export class oPrompt extends oObject {
+    constructor(config) {
+        super();
+        if (!config.rawValue) {
+            throw new Error('rawValue is required in oPromptConfig');
+        }
+        this.rawValue = config.rawValue;
+        this.type = config.type;
+        this.provider = config.provider;
+        this.params = config.params || {};
+    }
+    /**
+     * Extracts all template variables from the rawValue template
+     * @returns Array of variable names found in the template
+     */
+    getRequiredVariables() {
+        // Match handlebars variables: {{variable}} or {{object.property}}
+        const regex = /\{\{([^}]+)\}\}/g;
+        const matches = this.rawValue.matchAll(regex);
+        const variables = new Set();
+        for (const match of matches) {
+            // Extract the variable name (before any dots for nested properties)
+            const fullPath = match[1].trim();
+            const rootVariable = fullPath.split('.')[0];
+            variables.add(rootVariable);
+        }
+        return Array.from(variables);
+    }
+    /**
+     * Validates that all required template variables are present in params
+     * @throws Error if any required variables are missing
+     */
+    validate() {
+        const requiredVariables = this.getRequiredVariables();
+        const providedKeys = Object.keys(this.params);
+        const missingVariables = requiredVariables.filter((variable) => !providedKeys.includes(variable));
+        if (missingVariables.length > 0) {
+            throw new Error(`Missing required template variables: ${missingVariables.join(', ')}. ` +
+                `Required: [${requiredVariables.join(', ')}], ` +
+                `Provided: [${providedKeys.join(', ')}]`);
+        }
+    }
+    /**
+     * Compiles the template with provided params
+     * @returns The compiled template string
+     * @throws Error if template variables are missing or compilation fails
+     */
+    compile() {
+        // Validate first to provide clear error messages
+        this.validate();
+        try {
+            // Compile template if not already compiled
+            if (!this.compiledTemplate) {
+                this.compiledTemplate = Handlebars.compile(this.rawValue, {
+                    strict: true,
+                    noEscape: true, // Don't HTML-escape variables
+                });
+            }
+            // Render the template with params
+            const result = this.compiledTemplate(this.params);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to compile template: ${error.message}. ` +
+                    `Template type: ${this.type}, Provider: ${this.provider}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Alias for compile() for clearer semantics
+     */
+    render() {
+        return this.compile();
+    }
+    // Getters for config properties
+    getRawValue() {
+        return this.rawValue;
+    }
+    getType() {
+        return this.type;
+    }
+    getProvider() {
+        return this.provider;
+    }
+    getParams() {
+        return this.params;
+    }
+}

package/dist/src/storage/default.prompt-loader.d.ts

@@ -0,0 +1,14 @@
+import { oCapabilityType } from "../capabilities/enums/o-capability.type-enum.js";
+import { PromptLoader } from "./prompt-loader.js";
+import { oPrompt } from "../prompts/o-prompt.js";
+export declare class PromptLoaderDefault extends PromptLoader {
+    /**
+     * Load a prompt for the given capability type
+     * @param type The capability type
+     * @param params Parameters to populate the template
+     * @param provider Provider identifier (defaults to 'default')
+     * @returns oPrompt instance
+     */
+    loadPromptForType(type: oCapabilityType, params?: any, provider?: string): Promise<oPrompt>;
+}
+//# sourceMappingURL=default.prompt-loader.d.ts.map

package/dist/src/storage/default.prompt-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.prompt-loader.d.ts","sourceRoot":"","sources":["../../../src/storage/default.prompt-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iDAAiD,CAAC;AAGlF,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEjD,qBAAa,mBAAoB,SAAQ,YAAY;IAEnD;;;;;;OAMG;IACG,iBAAiB,CACrB,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,GAAQ,EAChB,QAAQ,GAAE,MAAkB,GAC3B,OAAO,CAAC,OAAO,CAAC;CAqBpB"}

package/dist/src/storage/default.prompt-loader.js

@@ -0,0 +1,34 @@
+import { oCapabilityType } from "../capabilities/enums/o-capability.type-enum.js";
+import { AGENT_PROMPT_TEMPLATE } from "../prompts/agent.prompt.js";
+import { CONFIGURE_PROMPT_TEMPLATE } from "../prompts/configure.prompt.js";
+import { PromptLoader } from "./prompt-loader.js";
+import { oPrompt } from "../prompts/o-prompt.js";
+export class PromptLoaderDefault extends PromptLoader {
+    /**
+     * Load a prompt for the given capability type
+     * @param type The capability type
+     * @param params Parameters to populate the template
+     * @param provider Provider identifier (defaults to 'default')
+     * @returns oPrompt instance
+     */
+    async loadPromptForType(type, params = {}, provider = 'default') {
+        // Get the raw template
+        let rawValue;
+        if (type === oCapabilityType.CONFIGURE) {
+            rawValue = CONFIGURE_PROMPT_TEMPLATE;
+        }
+        else if (type === oCapabilityType.EVALUATE) {
+            rawValue = AGENT_PROMPT_TEMPLATE;
+        }
+        else {
+            throw new Error(`Unsupported template type: ${type}`);
+        }
+        // Create and return oPrompt instance
+        return new oPrompt({
+            rawValue,
+            type,
+            provider,
+            params,
+        });
+    }
+}

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

@@ -1,8 +1,6 @@
-export * from './prompt-storage-provider.tool.js';
 export * from './interfaces/prompt-storage.interface.js';
 export * from './methods/prompt-storage.methods.js';
-export * from './prompt-schema.js';
-export * from './prompt-seeder.js';
 export * from './prompt-loader.js';
 export * from './o-lane.storage.js';
+export * from './o-lane.storage-manager.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/index.ts"],"names":[],"mappings":"AACA,cAAc,mCAAmC,CAAC;AAGlD,cAAc,0CAA0C,CAAC;AAGzD,cAAc,qCAAqC,CAAC;AAGpD,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/index.ts"],"names":[],"mappings":"AACA,cAAc,0CAA0C,CAAC;AAGzD,cAAc,qCAAqC,CAAC;AAEpD,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC"}

package/dist/src/storage/index.js

@@ -1,12 +1,8 @@
-// Prompt Storage Provider
-export * from './prompt-storage-provider.tool.js';
 // Interfaces
 export * from './interfaces/prompt-storage.interface.js';
 // Methods
 export * from './methods/prompt-storage.methods.js';
-// Prompt Management
-export * from './prompt-schema.js';
-export * from './prompt-seeder.js';
 export * from './prompt-loader.js';
 // Existing storage
 export * from './o-lane.storage.js';
+export * from './o-lane.storage-manager.js';

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

@@ -0,0 +1,71 @@
+/**
+ * oLaneStorageManager
+ *
+ * Handles all storage operations for oLane instances including:
+ * - CID generation and caching
+ * - Serialization
+ * - Persistence to storage
+ * - Replay from storage
+ * - Config persistence for startup
+ */
+import { CID } from 'multiformats';
+import { oCapabilityResult, oCapabilityType } from '../capabilities/index.js';
+type oLane = any;
+export declare class oLaneStorageManager {
+    private cid;
+    private lane;
+    constructor(lane: oLane);
+    /**
+     * Generate the input object for CID creation
+     * @returns Object containing intent, address, and context
+     */
+    generateCIDInput(): any;
+    /**
+     * Serialize the lane to JSON
+     * @returns Serialized lane object
+     */
+    serialize(): any;
+    /**
+     * Generate or retrieve cached CID for this lane
+     * @returns Content Identifier (CID) for this lane
+     */
+    generateCID(): Promise<CID>;
+    /**
+     * Store the lane to persistent storage
+     * @returns CID of the stored lane
+     * @throws Error if node is not in valid state
+     */
+    save(): Promise<CID>;
+    /**
+     * Persist lane CID to config storage for startup replay
+     * @param cid Content Identifier of the lane
+     * @param response Capability result containing addresses to index
+     */
+    persistToConfig(cid: CID, response?: oCapabilityResult): Promise<void>;
+    /**
+     * Replay a stored lane from storage by CID
+     * This method loads a lane's execution sequence and replays it to restore network state
+     * @param cid Content Identifier of the stored lane
+     * @returns Final capability result from replay
+     */
+    replay(cid: string): Promise<oCapabilityResult | undefined>;
+    /**
+     * Determine if a capability should be re-executed during replay
+     * Execute and Configure capabilities are re-executed as they modify network state
+     * Other capabilities use cached results
+     * @param capabilityType The type of capability to check
+     * @returns True if capability should be re-executed
+     */
+    shouldReplayCapability(capabilityType: oCapabilityType): boolean;
+    /**
+     * Get the cached CID if available
+     * @returns Cached CID or undefined
+     */
+    getCachedCID(): CID | undefined;
+    /**
+     * Clear the cached CID
+     */
+    clearCache(): void;
+}
+export {};
+//# sourceMappingURL=o-lane.storage-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-lane.storage-manager.d.ts","sourceRoot":"","sources":["../../../src/storage/o-lane.storage-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGnC,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAqB,MAAM,0BAA0B,CAAC;AAGjG,KAAK,KAAK,GAAG,GAAG,CAAC;AAEjB,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,IAAI,CAAQ;gBAER,IAAI,EAAE,KAAK;IAIvB;;;OAGG;IACH,gBAAgB,IAAI,GAAG;IAQvB;;;OAGG;IACH,SAAS,IAAI,GAAG;IAQhB;;;OAGG;IACG,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC;IAWjC;;;;OAIG;IACG,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC;IAyB1B;;;;OAIG;IACG,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAwC5E;;;;;OAKG;IACG,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAoEjE;;;;;;OAMG;IACH,sBAAsB,CAAC,cAAc,EAAE,eAAe,GAAG,OAAO;IAShE;;;OAGG;IACH,YAAY,IAAI,GAAG,GAAG,SAAS;IAI/B;;OAEG;IACH,UAAU,IAAI,IAAI;CAGnB"}

package/dist/src/storage/o-lane.storage-manager.js

@@ -0,0 +1,208 @@
+/**
+ * oLaneStorageManager
+ *
+ * Handles all storage operations for oLane instances including:
+ * - CID generation and caching
+ * - Serialization
+ * - Persistence to storage
+ * - Replay from storage
+ * - Config persistence for startup
+ */
+import { oAddress, oError, oErrorCodes, NodeState } from '@olane/o-core';
+import { CID } from 'multiformats';
+import * as json from 'multiformats/codecs/json';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { oCapabilityResult, oCapabilityType } from '../capabilities/index.js';
+export class oLaneStorageManager {
+    constructor(lane) {
+        this.lane = lane;
+    }
+    /**
+     * Generate the input object for CID creation
+     * @returns Object containing intent, address, and context
+     */
+    generateCIDInput() {
+        return {
+            intent: this.lane.config.intent.toString(),
+            address: this.lane.config.caller?.toString(),
+            context: this.lane.config.context?.toString() || '',
+        };
+    }
+    /**
+     * Serialize the lane to JSON
+     * @returns Serialized lane object
+     */
+    serialize() {
+        return {
+            config: this.generateCIDInput(),
+            sequence: this.lane.sequence,
+            result: this.lane.result,
+        };
+    }
+    /**
+     * Generate or retrieve cached CID for this lane
+     * @returns Content Identifier (CID) for this lane
+     */
+    async generateCID() {
+        if (this.cid) {
+            return this.cid;
+        }
+        const bytes = json.encode(this.generateCIDInput());
+        const hash = await sha256.digest(bytes);
+        const cid = CID.create(1, json.code, hash);
+        this.cid = cid;
+        return cid;
+    }
+    /**
+     * Store the lane to persistent storage
+     * @returns CID of the stored lane
+     * @throws Error if node is not in valid state
+     */
+    async save() {
+        this.lane.logger.debug('Storing lane...');
+        const cid = await this.generateCID();
+        if (this.lane.node.state !== NodeState.RUNNING) {
+            throw new oError(oErrorCodes.INVALID_STATE, 'Node is not in a valid state to store a lane');
+        }
+        const params = {
+            key: cid.toString(),
+            value: JSON.stringify(this.serialize()),
+        };
+        this.lane.logger.debug('Storing lane params: ', params);
+        await this.lane.node.use(oAddress.lane(), {
+            method: 'put',
+            params: params,
+        });
+        return cid;
+    }
+    /**
+     * Persist lane CID to config storage for startup replay
+     * @param cid Content Identifier of the lane
+     * @param response Capability result containing addresses to index
+     */
+    async persistToConfig(cid, response) {
+        this.lane.logger.debug('Lane marked for persistence (auto-triggered by tool response or explicitly set), saving to config...');
+        try {
+            // Get the OS instance name from the node's system name
+            const systemName = this.lane.node.config.systemName || 'default-os';
+            await this.lane.node.use(new oAddress('o://os-config'), {
+                method: 'add_lane_to_config',
+                params: {
+                    osName: systemName,
+                    cid: cid.toString(),
+                },
+            });
+            // Index any addresses returned in the response
+            const data = response?.result;
+            if (data?.addresses_to_index) {
+                for (const address of data.addresses_to_index) {
+                    this.lane.logger.debug('Indexing address: ', address.toString());
+                    await this.lane.node
+                        .use(new oAddress(address), {
+                        method: 'index_network',
+                        params: {},
+                    })
+                        .catch((error) => {
+                        this.lane.logger.error('Error indexing address: ', error);
+                    });
+                }
+            }
+            this.lane.logger.debug('Lane CID added to startup config via o://os-config');
+        }
+        catch (error) {
+            this.lane.logger.error('Failed to add lane to startup config: ', error);
+            throw error;
+        }
+    }
+    /**
+     * Replay a stored lane from storage by CID
+     * This method loads a lane's execution sequence and replays it to restore network state
+     * @param cid Content Identifier of the stored lane
+     * @returns Final capability result from replay
+     */
+    async replay(cid) {
+        this.lane.logger.debug('Replaying lane from CID: ', cid);
+        try {
+            // Load the lane data from storage
+            const laneData = await this.lane.node.use(oAddress.lane(), {
+                method: 'get',
+                params: { key: cid },
+            });
+            if (!laneData || !laneData.result) {
+                throw new Error(`Lane not found in storage for CID: ${cid}`);
+            }
+            const data = laneData.result.data;
+            const storedLane = JSON.parse(data.value);
+            // Validate stored lane structure
+            if (!storedLane.sequence || !Array.isArray(storedLane.sequence)) {
+                throw new Error('Invalid lane data: missing or invalid sequence');
+            }
+            // Iterate through the stored sequence and replay capabilities
+            for (const sequenceItem of storedLane.sequence) {
+                const capabilityType = sequenceItem.type;
+                // Determine if this capability should be replayed
+                if (this.shouldReplayCapability(capabilityType)) {
+                    this.lane.logger.debug(`Replaying capability: ${capabilityType}`);
+                    // Create a capability result with replay flag
+                    const replayStep = new oCapabilityResult({
+                        type: capabilityType,
+                        config: {
+                            ...sequenceItem.config,
+                            isReplay: true,
+                            node: this.lane.node,
+                            history: this.lane.agentHistory,
+                        },
+                        result: sequenceItem.result,
+                        error: sequenceItem.error,
+                    });
+                    // Execute the capability in replay mode
+                    const result = await this.lane.doCapability(replayStep);
+                    this.lane.addSequence(result);
+                    // If the capability is STOP, end replay
+                    if (result.type === oCapabilityType.STOP) {
+                        return result;
+                    }
+                }
+                else {
+                    this.lane.logger.debug(`Skipping capability (using cached result): ${capabilityType}`);
+                    // Add the cached result to sequence without re-executing
+                    this.lane.addSequence(sequenceItem);
+                }
+            }
+            this.lane.logger.debug('Lane replay completed successfully');
+            return this.lane.result;
+        }
+        catch (error) {
+            this.lane.logger.error('Error during lane replay: ', error);
+            throw error;
+        }
+    }
+    /**
+     * Determine if a capability should be re-executed during replay
+     * Execute and Configure capabilities are re-executed as they modify network state
+     * Other capabilities use cached results
+     * @param capabilityType The type of capability to check
+     * @returns True if capability should be re-executed
+     */
+    shouldReplayCapability(capabilityType) {
+        const replayTypes = [
+            oCapabilityType.EXECUTE,
+            oCapabilityType.CONFIGURE,
+            oCapabilityType.MULTIPLE_STEP,
+        ];
+        return replayTypes.includes(capabilityType);
+    }
+    /**
+     * Get the cached CID if available
+     * @returns Cached CID or undefined
+     */
+    getCachedCID() {
+        return this.cid;
+    }
+    /**
+     * Clear the cached CID
+     */
+    clearCache() {
+        this.cid = undefined;
+    }
+}

package/dist/src/storage/prompt-loader.d.ts

@@ -3,38 +3,20 @@
  *
  * Loads and compiles prompts from PromptStorageProvider with fallback to hardcoded versions
  */
-import { PromptStorageProvider } from './prompt-storage-provider.tool.js';
+import { oCapabilityType } from '../capabilities/index.js';
+import { oPrompt } from '../prompts/o-prompt.js';
 /**
- * Loads prompts from storage and compiles them into final prompt strings
+ * Loads prompts from storage and returns oPrompt instances
  */
 export declare class PromptLoader {
-    private storage?;
-    private cache;
-    private useStorage;
-    constructor(storage?: PromptStorageProvider | undefined);
+    protected cache: Map<oCapabilityType, oPrompt>;
     /**
-     * Generate agent prompt (equivalent to AGENT_PROMPT function)
+     * Load a prompt template for a given capability type
+     * @param type The capability type
+     * @param params Optional parameters to populate the template
+     * @param provider Optional provider identifier
+     * @returns oPrompt instance ready for compilation
      */
-    generateAgentPrompt(intent: string, context: string, agentHistory: string, extraInstructions: string): Promise<string>;
-    /**
-     * Generate custom agent prompt (equivalent to CUSTOM_AGENT_PROMPT function)
-     */
-    generateCustomAgentPrompt(intent: string, context: string, agentHistory: string, cycleInstructions: string, outputInstructions: string, extraInstructions: string): Promise<string>;
-    /**
-     * Load configure instructions
-     */
-    loadConfigureInstructions(): Promise<string>;
-    /**
-     * Load a template from storage
-     */
-    private loadTemplate;
-    /**
-     * Clear the template cache
-     */
-    clearCache(): void;
-    /**
-     * Enable or disable storage usage
-     */
-    setUseStorage(use: boolean): void;
+    loadPromptForType(type: oCapabilityType, params?: any, provider?: string): Promise<oPrompt>;
 }
 //# sourceMappingURL=prompt-loader.d.ts.map

package/dist/src/storage/prompt-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-loader.d.ts","sourceRoot":"","sources":["../../../src/storage/prompt-loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAU1E;;GAEG;AACH,qBAAa,YAAY;IAIX,OAAO,CAAC,OAAO,CAAC;IAH5B,OAAO,CAAC,KAAK,CAAgD;IAC7D,OAAO,CAAC,UAAU,CAAiB;gBAEf,OAAO,CAAC,mCAAuB;IAMnD;;OAEG;IACG,mBAAmB,CACvB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC,MAAM,CAAC;IAiClB;;OAEG;IACG,yBAAyB,CAC7B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,EACpB,iBAAiB,EAAE,MAAM,EACzB,kBAAkB,EAAE,MAAM,EAC1B,iBAAiB,EAAE,MAAM,GACxB,OAAO,CAAC,MAAM,CAAC;IA0ClB;;OAEG;IACG,yBAAyB,IAAI,OAAO,CAAC,MAAM,CAAC;IAqBlD;;OAEG;YACW,YAAY;IAgC1B;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;CAGlC"}
+{"version":3,"file":"prompt-loader.d.ts","sourceRoot":"","sources":["../../../src/storage/prompt-loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEjD;;GAEG;AACH,qBAAa,YAAY;IACvB,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,CAAuC;IAErF;;;;;;OAMG;IACG,iBAAiB,CACrB,IAAI,EAAE,eAAe,EACrB,MAAM,CAAC,EAAE,GAAG,EACZ,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC;CAIpB"}

package/dist/src/storage/prompt-loader.js

@@ -3,124 +3,21 @@
  *
  * Loads and compiles prompts from PromptStorageProvider with fallback to hardcoded versions
  */
-import { PROMPT_KEYS, PROMPT_IDS, } from './prompt-schema.js';
-import { AGENT_PROMPT } from '../prompts/agent.prompt.js';
-import { CUSTOM_AGENT_PROMPT } from '../prompts/custom.prompt.js';
-import { CONFIGURE_INSTRUCTIONS } from '../prompts/configure.prompt.js';
 /**
- * Loads prompts from storage and compiles them into final prompt strings
+ * Loads prompts from storage and returns oPrompt instances
  */
 export class PromptLoader {
-    constructor(storage) {
-        this.storage = storage;
+    constructor() {
         this.cache = new Map();
-        this.useStorage = true;
-        if (!storage) {
-            this.useStorage = false;
-        }
     }
     /**
-     * Generate agent prompt (equivalent to AGENT_PROMPT function)
+     * Load a prompt template for a given capability type
+     * @param type The capability type
+     * @param params Optional parameters to populate the template
+     * @param provider Optional provider identifier
+     * @returns oPrompt instance ready for compilation
      */
-    async generateAgentPrompt(intent, context, agentHistory, extraInstructions) {
-        if (!this.useStorage || !this.storage) {
-            // Fallback to hardcoded version
-            return AGENT_PROMPT(intent, context, agentHistory, extraInstructions);
-        }
-        try {
-            // Load templates from storage
-            const cycleInstructions = await this.loadTemplate(PROMPT_IDS.AGENT, PROMPT_KEYS.CYCLE_INSTRUCTIONS);
-            const outputInstructions = await this.loadTemplate(PROMPT_IDS.AGENT, PROMPT_KEYS.OUTPUT_INSTRUCTIONS);
-            // Compile using custom agent prompt
-            return await this.generateCustomAgentPrompt(intent, context, agentHistory, cycleInstructions, outputInstructions, extraInstructions);
-        }
-        catch (error) {
-            // Fallback to hardcoded version on error
-            console.warn('Failed to load prompts from storage, using fallback', error);
-            return AGENT_PROMPT(intent, context, agentHistory, extraInstructions);
-        }
-    }
-    /**
-     * Generate custom agent prompt (equivalent to CUSTOM_AGENT_PROMPT function)
-     */
-    async generateCustomAgentPrompt(intent, context, agentHistory, cycleInstructions, outputInstructions, extraInstructions) {
-        if (!this.useStorage || !this.storage) {
-            // Fallback to hardcoded version
-            return CUSTOM_AGENT_PROMPT(intent, context, agentHistory, cycleInstructions, outputInstructions, extraInstructions);
-        }
-        try {
-            // Load base template from storage
-            const baseTemplate = await this.loadTemplate(PROMPT_IDS.AGENT, PROMPT_KEYS.BASE_TEMPLATE);
-            // Replace placeholders with actual values
-            return baseTemplate
-                .replace('{{intent}}', intent)
-                .replace('{{context}}', context)
-                .replace('{{agentHistory}}', agentHistory)
-                .replace('{{cycleInstructions}}', cycleInstructions)
-                .replace('{{outputInstructions}}', outputInstructions)
-                .replace('{{extraInstructions}}', extraInstructions);
-        }
-        catch (error) {
-            // Fallback to hardcoded version on error
-            console.warn('Failed to load base template from storage, using fallback', error);
-            return CUSTOM_AGENT_PROMPT(intent, context, agentHistory, cycleInstructions, outputInstructions, extraInstructions);
-        }
-    }
-    /**
-     * Load configure instructions
-     */
-    async loadConfigureInstructions() {
-        if (!this.useStorage || !this.storage) {
-            // Fallback to hardcoded version
-            return CONFIGURE_INSTRUCTIONS;
-        }
-        try {
-            return await this.loadTemplate(PROMPT_IDS.AGENT, PROMPT_KEYS.CONFIGURE_INSTRUCTIONS);
-        }
-        catch (error) {
-            // Fallback to hardcoded version on error
-            console.warn('Failed to load configure instructions from storage, using fallback', error);
-            return CONFIGURE_INSTRUCTIONS;
-        }
-    }
-    /**
-     * Load a template from storage
-     */
-    async loadTemplate(promptId, key) {
-        // Check cache first
-        const cacheKey = `${promptId}:${key}`;
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey).content;
-        }
-        if (!this.storage) {
-            throw new Error('Storage not available');
-        }
-        // Load from storage
-        const response = await this.storage.use(this.storage.address, {
-            method: 'get',
-            params: { promptId, key },
-        });
-        if (!response.result.success) {
-            throw new Error(`Failed to load template: ${response.result.error}`);
-        }
-        const template = response.result?.data?.value;
-        if (!template || !template.content) {
-            throw new Error(`Template not found: ${promptId}/${key}`);
-        }
-        // Cache for future use
-        this.cache.set(cacheKey, template);
-        return template.content;
-    }
-    /**
-     * Clear the template cache
-     */
-    clearCache() {
-        this.cache.clear();
-    }
-    /**
-     * Enable or disable storage usage
-     */
-    setUseStorage(use) {
-        this.useStorage = use && !!this.storage;
+    async loadPromptForType(type, params, provider) {
+        throw new Error('Not implemented');
     }
 }

package/dist/test/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/dist/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../test/index.ts"],"names":[],"mappings":""}

package/dist/test/index.js

@@ -0,0 +1,2 @@
+"use strict";
+console.log('hi');