@olane/o-lane 0.7.1

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

@@ -0,0 +1,50 @@
+import { oObject } from '@olane/o-core';
+import { oLane } from '../o-lane.js';
+import { oLaneStatus } from '../enum/o-lane.status-enum.js';
+export class oLaneManager extends oObject {
+    constructor(config) {
+        super();
+        this.config = config;
+        this.lanes = [];
+    }
+    get maxLanes() {
+        return this.config?.maxLanes || 100;
+    }
+    async createLane(config) {
+        const lane = new oLane(config);
+        this.lanes.push(lane);
+        if (this.activeLanes.length > this.maxLanes) {
+            throw new Error('Max lanes reached');
+        }
+        if (this.staleLanes.length > this.maxLanes) {
+            this.cleanLanes();
+        }
+        return lane;
+    }
+    cleanLanes() {
+        this.logger.info(`Cleaning ${this.staleLanes.length} stale lanes`);
+        this.lanes = this.lanes.filter((l) => l.status < oLaneStatus.COMPLETED);
+    }
+    cancelLane(lane) {
+        this.lanes = this.lanes.filter((l) => {
+            if (l.id === lane.id) {
+                lane.cancel();
+            }
+            return l.id !== lane.id;
+        });
+    }
+    getLane(id) {
+        return this.lanes.find((l) => l.id === id);
+    }
+    async teardown() {
+        for (const lane of this.lanes) {
+            await lane.cancel();
+        }
+    }
+    get activeLanes() {
+        return this.lanes.filter((l) => l.status === oLaneStatus.RUNNING);
+    }
+    get staleLanes() {
+        return this.lanes.filter((l) => l.status >= oLaneStatus.COMPLETED);
+    }
+}

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

@@ -0,0 +1,10 @@
+export declare class oLaneContext {
+    private context;
+    constructor(context: any);
+    add(value: string): void;
+    addAll(contexts: string[]): void;
+    clear(): void;
+    toJSON(): string[];
+    toString(): string;
+}
+//# sourceMappingURL=o-lane.context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-lane.context.d.ts","sourceRoot":"","sources":["../../src/o-lane.context.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAgB;gBACnB,OAAO,EAAE,GAAG;IAIxB,GAAG,CAAC,KAAK,EAAE,MAAM;IAIjB,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE;IAUzB,KAAK;IAIL,MAAM;IAIN,QAAQ;CAGT"}

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

@@ -0,0 +1,28 @@
+export class oLaneContext {
+    constructor(context) {
+        this.context = [];
+        this.context = context;
+    }
+    add(value) {
+        this.context.push(value);
+    }
+    addAll(contexts) {
+        try {
+            for (const context of contexts) {
+                this.context.push(context);
+            }
+        }
+        catch (e) {
+            console.error('Error adding contexts: ', e);
+        }
+    }
+    clear() {
+        this.context = [];
+    }
+    toJSON() {
+        return this.context;
+    }
+    toString() {
+        return '\n\n' + this.context.join('\n') + '\n\n';
+    }
+}

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

@@ -0,0 +1,40 @@
+import { oObject } from '@olane/o-core';
+import { oLaneConfig } from './interfaces/o-lane.config.js';
+import { CID } from 'multiformats';
+import { oIntent } from './intent/index.js';
+import { oIntentEncoder } from './intent-encoder/index.js';
+import { oLaneStatus } from './enum/o-lane.status-enum.js';
+import { oCapabilityConfig, oCapabilityResult } from './capabilities/index.js';
+export declare class oLane extends oObject {
+    protected readonly config: oLaneConfig;
+    sequence: oCapabilityResult[];
+    cid: CID | undefined;
+    id: string;
+    parentLaneId: string | undefined;
+    intentEncoder: oIntentEncoder;
+    MAX_CYCLES: number;
+    status: oLaneStatus;
+    result: oCapabilityResult | undefined;
+    constructor(config: oLaneConfig);
+    get intent(): oIntent;
+    toCIDInput(): any;
+    toJSON(): {
+        config: any;
+        sequence: oCapabilityResult[];
+        result: oCapabilityResult | undefined;
+    };
+    addSequence(result: oCapabilityResult): void;
+    toCID(): Promise<CID>;
+    store(): Promise<void>;
+    get agentHistory(): string;
+    preflight(): Promise<void>;
+    execute(): Promise<oCapabilityResult | undefined>;
+    get capabilities(): import("./capabilities/o-capability.js").oCapability[];
+    resultToConfig(result: any): oCapabilityConfig;
+    doCapability(currentStep: oCapabilityResult): Promise<oCapabilityResult>;
+    loop(): Promise<oCapabilityResult>;
+    postflight(response?: oCapabilityResult): Promise<oCapabilityResult | undefined>;
+    cancel(): void;
+    get node(): import("./o-lane.tool.js").oLaneTool;
+}
+//# sourceMappingURL=o-lane.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-lane.d.ts","sourceRoot":"","sources":["../../src/o-lane.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,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;IAeX,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;IAqClC,UAAU,CACd,QAAQ,CAAC,EAAE,iBAAiB,GAC3B,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC;IAYzC,MAAM;IAKN,IAAI,IAAI,yCAEP;CACF"}

package/dist/src/o-lane.js

@@ -0,0 +1,202 @@
+import { oError, oErrorCodes, oObject, } from '@olane/o-core';
+import { CID } from 'multiformats';
+import * as json from 'multiformats/codecs/json';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { v4 as uuidv4 } from 'uuid';
+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';
+export class oLane extends oObject {
+    constructor(config) {
+        super('o-lane:' + `[${config.intent.value}]`);
+        this.config = config;
+        this.sequence = [];
+        this.id = uuidv4();
+        this.MAX_CYCLES = 20;
+        this.status = oLaneStatus.PENDING;
+        this.sequence = Object.assign([], this.config.sequence || []);
+        this.parentLaneId = this.config.parentLaneId;
+        this.intentEncoder = new oIntentEncoder();
+        // set a max cycles if one is not provided
+        if (!!process.env.MAX_CYCLES) {
+            this.MAX_CYCLES = parseInt(process.env.MAX_CYCLES);
+        }
+        this.MAX_CYCLES = this.config.maxCycles || this.MAX_CYCLES;
+    }
+    get intent() {
+        return this.config.intent;
+    }
+    toCIDInput() {
+        return {
+            intent: this.config.intent,
+            address: this.config.caller?.toString(),
+            context: this.config.context?.toString() || '',
+        };
+    }
+    toJSON() {
+        return {
+            config: this.toCIDInput(),
+            sequence: this.sequence,
+            result: this.result,
+        };
+    }
+    addSequence(result) {
+        this.sequence.push(result);
+        if (this.config.streamTo) {
+            this.node
+                .use(this.config.streamTo, {
+                method: 'receive_stream',
+                params: {
+                    data: result.result || result.error || '',
+                },
+            })
+                .catch((error) => {
+                this.logger.error('Error sending agent stream: ', error);
+            });
+        }
+    }
+    async toCID() {
+        if (this.cid) {
+            return this.cid;
+        }
+        const bytes = json.encode(this.toCIDInput());
+        const hash = await sha256.digest(bytes);
+        const cid = CID.create(1, json.code, hash);
+        return cid;
+    }
+    async store() {
+        this.logger.debug('Storing plan...');
+        const cid = await this.toCID();
+        const params = {
+            key: cid.toString(),
+            value: JSON.stringify(this.toJSON()),
+        };
+        this.logger.debug('Storing plan params: ', params);
+        // await this.node.use(oAddress.lane(), {
+        //   method: 'put',
+        //   params: params,
+        // });
+    }
+    get agentHistory() {
+        const added = {};
+        return (this.sequence
+            ?.filter((s) => {
+            if (added[s.id]) {
+                return false;
+            }
+            added[s.id] = true;
+            return true;
+        })
+            ?.map((s, index) => {
+            const result = s.result || s.error;
+            return `[Cycle ${index + 1} Begin ${s.id}]\n
+            Cycle Intent: ${s.config?.intent}\n
+            Cycle Result:\n
+            ${typeof result === 'string'
+                ? result
+                : JSON.stringify({
+                    ...result,
+                }, null, 2)} \n[Cycle ${index + 1} End ${s.id}]`;
+        })
+            .join('\n') || '');
+    }
+    async preflight() {
+        this.logger.debug('Preflight...');
+        this.status = oLaneStatus.PREFLIGHT;
+    }
+    async execute() {
+        this.logger.debug('Executing...');
+        await this.preflight();
+        this.status = oLaneStatus.RUNNING;
+        try {
+            this.result = await this.loop();
+        }
+        catch (error) {
+            this.logger.error('Error in execute: ', error);
+            this.status = oLaneStatus.FAILED;
+        }
+        await this.postflight(this.result);
+        this.status = oLaneStatus.COMPLETED;
+        return this.result;
+    }
+    get capabilities() {
+        return this.config.capabilities || ALL_CAPABILITIES.map((c) => new c());
+    }
+    resultToConfig(result) {
+        const obj = result.result || result.error;
+        return {
+            ...result.config,
+            history: this.agentHistory,
+            params: typeof obj === 'object' ? obj : {},
+            laneConfig: {
+                ...this.config,
+                sequence: this.sequence, // pass the full sequence to the next capability
+            },
+        };
+    }
+    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;
+            }
+        }
+        throw new oError(oErrorCodes.INVALID_CAPABILITY, 'Unknown capability');
+    }
+    async loop() {
+        if (!this.node) {
+            throw new Error('Node not set');
+        }
+        let iterations = 0;
+        let currentStep = new oCapabilityResult({
+            type: oCapabilityType.EVALUATE,
+            result: null,
+            config: {
+                laneConfig: this.config,
+                intent: this.intent,
+                node: this.node,
+                history: this.agentHistory,
+            },
+        });
+        while (iterations++ < this.MAX_CYCLES &&
+            this.status === oLaneStatus.RUNNING) {
+            // update the history
+            if (currentStep.config) {
+                currentStep.config.history = this.agentHistory;
+            }
+            // perform the latest capability
+            const result = await this.doCapability(currentStep);
+            this.addSequence(result);
+            if (result.type === oCapabilityType.STOP) {
+                return result;
+            }
+            // update the current step
+            currentStep = result;
+        }
+        throw new Error('Plan failed');
+    }
+    async postflight(response) {
+        this.logger.debug('Postflight...');
+        this.status = oLaneStatus.POSTFLIGHT;
+        try {
+            await this.store();
+            this.logger.debug('Saving plan...', response);
+        }
+        catch (error) {
+            this.logger.error('Error in postflight: ', error);
+        }
+        return response;
+    }
+    cancel() {
+        this.logger.debug('Cancelling lane...');
+        this.status = oLaneStatus.CANCELLED;
+    }
+    get node() {
+        return this.config.currentNode;
+    }
+}

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

@@ -0,0 +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;
+    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>;
+    teardown(): Promise<void>;
+}
+//# sourceMappingURL=o-lane.tool.d.ts.map

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

@@ -0,0 +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;IA2B7C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAIhC"}

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

@@ -0,0 +1,64 @@
+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 {
+    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,
+            sequence: pc.sequence.map((s) => {
+                return s.result;
+            }),
+        };
+    }
+    async teardown() {
+        await this.manager.teardown();
+        await super.teardown();
+    }
+}

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

@@ -0,0 +1,2 @@
+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

@@ -0,0 +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,WA6HxB,CAAC"}

package/dist/src/prompts/agent.prompt.js

@@ -0,0 +1,118 @@
+import { CUSTOM_AGENT_PROMPT } from './custom.prompt.js';
+export const AGENT_PROMPT = (intent, context, agentHistory, extraInstructions) => CUSTOM_AGENT_PROMPT(intent, context, agentHistory, `
+  Every Step Instructions:
+1. Review the provided user intent, context and agent history
+2. If you can complete the user intent, return the "Stop Response" using the [RETURN INSTRUCTIONS] steps
+3. If the intent is already completed in past cycles, return the "Stop Response" using the [RETURN INSTRUCTIONS] steps
+4. If you experience 3 similar errors in a row, return the "Stop Response" indicating an error and follow the [RETURN INSTRUCTIONS] steps
+5. Review the current step number and perform the instructions associated with that step
+6. Start with step 1
+
+Step 1 - Evaluate the intent
+1. A complex step means there are multiple actions required to complete the user's intent
+2. If the intent is not-complex, continue to step 2
+3. If the intent is complex, break it up into a list of simple concise intents. Return the "Complex Intent Response" using the [RETURN INSTRUCTIONS]
+
+Step 2 - Search for tools and context
+1. If all entities and tool addresses are known within the user intent, continue to step 4
+2. If you know the tool address to use to complete the user intent, continue to step 4
+3. If there are unknown tool addresses or entities within the user intent, generate search queries to resolve the unknown entities. 
+4. 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.
+5. 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.
+6. Use the search results data & tooling to help you resolve the unknown entities.
+7. Continue to step 3.
+
+Step 3 - Filter Search Results
+1. If all search results are relevant to the user intent resolution, continue to step 4.
+2. Filter the search results for information that may contain supporting data or tooling that can help complete the user intent.
+3. If you do not see anything that can help you. Return the "Stop Response" using the [RETURN INSTRUCTIONS]
+4. Continue to step 4
+
+Step 4 - Configure the target tool address use
+1. Identify the tool address that most likely will help you complete the user intent.
+2. Review the provided context for past cycles that contain configuration instructions for the target tool address.
+3. If there is no configuration instructions for the target tool address, return the "Configure Response" using the [RETURN INSTRUCTIONS]
+4. If the tool use configuration is already known, continue to step 5
+
+Step 5 - Use target tool address
+1. If the target tool address configuration is known, return the "Use Tool Response" using the [RETURN INSTRUCTIONS]
+2. 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.
+3. 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
+4. Continue to step 6
+
+Step 6 - Review the tool use results
+1. Analyze each tool use result
+2. Summarize the result of each tool use in 1 concise sentence
+3. In the summary, clearly mention if it succeeded or failed
+4. If it failed, make sure to include why it failed
+
+
+  `, `
+[RETURN INSTRUCTIONS BEGIN]
+These are the types of cycle responses: "Complex Intent Response", "Search Response", "Use Tool Response", "Stop Response", "Error Response", "Configure Response".
+
+All Return Step Instructions:
+1. Do not explain your reasoning process, just return the output in the correct format.
+2. Determine what type of results we have
+3. Output the respective results using the matching output type.
+4. Generate a reasoning key value pair for why this result was returned.
+5. The reasoning should be no longer than 1 sentence.
+6. Do not include \`\`\`json or \`\`\` in your output.
+
+Complex Intent Results:
+{
+  "intents": [
+    "simple intent 1",
+    "simple intent 2",
+    "simple intent 3",
+  ],
+  "reasoning": string,
+  "type": "multiple_step",
+}
+
+Configure Response:
+{
+  "intent": string,
+  "toolAddress": string,
+  "reasoning": string,
+  "type": "configure",
+}
+
+Search Response:
+{
+  "queries": [
+    {
+      "query": "vector database query key terms to search for",
+      "limit": number,
+    }
+  ],
+  "isExternal": boolean,
+  "reasoning": string,
+  "type": "search",
+}
+
+Stop Response:
+{
+  "result": string,
+  "reasoning": string,
+  "type": "stop",
+}
+
+Error Response:
+{
+  "result": "string explaining the error",
+  "reasoning": string,
+  "type": "evaluate",
+}
+
+Use Tool Response:
+{
+  "task": {
+    "address": string,
+    "payload": { "method": string, "params": any }
+  }
+  "type": "task",
+}
+[RETURN INSTRUCTIONS END]
+
+  `, extraInstructions);

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

@@ -0,0 +1,2 @@
+export declare const CONFIGURE_INSTRUCTIONS = "\n  Configure Request Instructions:\n1. Review the provided user intent and context\n2. If you can complete the user intent, return the answer using the [RETURN INSTRUCTIONS] steps\n3. If you experience an error trying to use a tool more than 2 times, stop here and follow the [RETURN INSTRUCTIONS] steps to indicate the error.\n3. Review the current step number and perform the instructions associated with that step.\n4. Start with step 1\n\nStep 1 - Validate the intent\n1. If the intent is not a configure request, continue to step 5\n2. If the context provided would suggest that the intent is already solved, continue to step 5\n2. Continue to step 2\n\nStep 2 - Choose Method\n1. Review the method options and metadata to determine the best method to resolve the user's intent.\n2. Choose the best method to resolve the user's intent.\n3. Continue to step 3\n\nStep 3 - Select Parameters\n1. Review the parameters for the selected best method.\n2. Extract the parameter values from the agent history, provided context and intent. Do NOT use a parameter value that is not mentioned previously.\n3. Do not use placeholder values for parameter values.\n4. Do not use parameter values that are not explicitly mentioned in the agent history, provided context or intent.\n3. Identify missing parameter values.\n4. If you have enough information to complete the configure request, go to step 5.\n5. Continue to step 4\n\nStep 4 - Search for missing parameter values\n1. Identify other methods that can be used to resolve the missing parameter values.\n2. Identify methods that can be used to resolve the missing parameter values.\n3. Continue to step 5\n\nStep 5 - Finish\n1. If the intent seems to be already solved, return answer results.\n1. If this is not a configure request, return an error.\n2. If you are missing parameter values, generate the intents for the \"Complex Intent\" results using other methods or search to help.\n2. If you have enough information to complete the configure request, follow the [RETURN INSTRUCTIONS] steps to return the \"configure results\".\n3. If you do not have enough information to complete the configure request, return an error.\n\n  ";
+//# sourceMappingURL=configure.prompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"configure.prompt.d.ts","sourceRoot":"","sources":["../../../src/prompts/configure.prompt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,woEAuChC,CAAC"}

package/dist/src/prompts/configure.prompt.js

@@ -0,0 +1,40 @@
+export const CONFIGURE_INSTRUCTIONS = `
+  Configure Request Instructions:
+1. Review the provided user intent and context
+2. If you can complete the user intent, return the answer using the [RETURN INSTRUCTIONS] steps
+3. If you experience an error trying to use a tool more than 2 times, stop here and follow the [RETURN INSTRUCTIONS] steps to indicate the error.
+3. Review the current step number and perform the instructions associated with that step.
+4. Start with step 1
+
+Step 1 - Validate the intent
+1. If the intent is not a configure request, continue to step 5
+2. If the context provided would suggest that the intent is already solved, continue to step 5
+2. Continue to step 2
+
+Step 2 - Choose Method
+1. Review the method options and metadata to determine the best method to resolve the user's intent.
+2. Choose the best method to resolve the user's intent.
+3. Continue to step 3
+
+Step 3 - Select Parameters
+1. Review the parameters for the selected best method.
+2. Extract the parameter values from the agent history, provided context and intent. Do NOT use a parameter value that is not mentioned previously.
+3. Do not use placeholder values for parameter values.
+4. Do not use parameter values that are not explicitly mentioned in the agent history, provided context or intent.
+3. Identify missing parameter values.
+4. If you have enough information to complete the configure request, go to step 5.
+5. Continue to step 4
+
+Step 4 - Search for missing parameter values
+1. Identify other methods that can be used to resolve the missing parameter values.
+2. Identify methods that can be used to resolve the missing parameter values.
+3. Continue to step 5
+
+Step 5 - Finish
+1. If the intent seems to be already solved, return answer results.
+1. If this is not a configure request, return an error.
+2. If you are missing parameter values, generate the intents for the "Complex Intent" results using other methods or search to help.
+2. If you have enough information to complete the configure request, follow the [RETURN INSTRUCTIONS] steps to return the "configure results".
+3. If you do not have enough information to complete the configure request, return an error.
+
+  `;

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

@@ -0,0 +1,2 @@
+export declare const CUSTOM_AGENT_PROMPT: (intent: string, context: string, agentHistory: string, cycleInstructions: string, outputInstructions: string, extraInstructions: string) => string;
+//# sourceMappingURL=custom.prompt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"custom.prompt.d.ts","sourceRoot":"","sources":["../../../src/prompts/custom.prompt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,WACtB,MAAM,WACL,MAAM,gBACD,MAAM,qBACD,MAAM,sBACL,MAAM,qBACP,MAAM,WAyE1B,CAAC"}