@olane/o-mcp 0.6.1

package/README.md

@@ -0,0 +1,86 @@
+TLDR; we created a forked MCP version that is faster, better, and cheaper. [Link to get started]
+
+## What is MCP Missing?
+
+### **Today / Problem Description**
+
+MCP servers are built to enable LLM / AI systems to synthesize workflows from complex tasks. This means MCPs will work great if…
+
+1. You have built your MCP well (example: *as an intention-based tool, not as an API wrapper)*
+    1. *You actively maintain* documentation to support *how* to use your services
+    2. LLM / AI understands how to synthesize plans around small workflows using the tools provided
+2. You pay for intelligent models that can reason / do chain of thought processing.
+
+Every LLM / AI system will need to rerun this, every time. Today it has no working memory on the workflows/plans it runs.
+
+We asked ourselves…”why are these plans and workflows being thrown out?”
+
+### **Olane + MCP = oMCP**
+
+We have forked the MCP client & server to capture and re-use these workflows, reducing intelligence requirements and improving MCP completion by X%. [Link to the repo]
+
+## How did we do this?
+
+We centered our focus on these problems:
+
+1. How can we enable smaller models to succeed just like bigger ones?
+2. How can we reduce waste / reduce token usage?
+3. How can we make AI - MCP usage more deterministic?
+4. How can we improve the speed of MCP usage?
+
+Like teaching a small child, we learned that by simply following the KISS model (KISS → “keep it simple stupid”), we achieved all of this and more. 
+
+> Smaller AI models need less noise and more clear instruction to succeed. In other words, “spell it out for them”
+> 
+
+<aside>
+💡
+
+*Engaging / thoughtful hook? Brendon scratchpad*
+
+How do you get the *right* context from an MCP server to complete your task?
+
+- Do you just throw everything at it? → No, this is wasteful
+- Do you try to condense the knowledge to cost optimize? → Maybe…but how without data loss
+- Do you try to organize MCP usage and learn from similar use-cases? Let’s try it and see what happens…
+</aside>
+
+![normal-mcp.png](./docs/assets/normal-mcp.png)
+
+![o-mcp-flow.png](./docs/assets/o-mcp-flow.png)
+
+### Breaking it down further…
+
+We combine large model successes + failures + a little search to help give small models a helping hand in achieving their dreams.
+
+<aside>
+💡
+
+We learn from past successes & failures to create few shot RL guidelines on how to best utilize the MCP server. 
+
+</aside>
+
+**Example**: 
+
+```
+“Get my latest pull requests”
+Results in the following steps:
+
+1. Client connects to MCP server with an “intent” + “model”
+2. The MCP server searches for past success, failure and relevant tool methods
+3. Client receives the package and creates new "workflow" tool uses
+4. Execute!
+```
+
+### So how does this meet our goals?
+
+1. Smaller model support → more relevant / clear context is now achieved
+2. Reduce token usage → avoid sending irrelevant context when possible / refine tool offerings & also reduce model size requirements
+3. More deterministic → by learning from past failures & successes, we know how to stay within the bounds of success with clear guardrails
+4. Speed improvement → less tokens to process = more speed
+
+### Examples
+
+1. Github example → what models can we test / prove to how it works?
+2. Figma example → same as above ^^
+3. Slack / more complex examples → same as above ^

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mcp-bridge.tool.js';
+export * from './mcp.tool.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,2 @@
+export * from './mcp-bridge.tool.js';
+export * from './mcp.tool.js';

package/dist/src/mcp-bridge.tool.d.ts

@@ -0,0 +1,12 @@
+import { oToolConfig, oVirtualTool, ToolResult } from '@olane/o-tool';
+import { oRequest } from '@olane/o-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { McpTool } from './mcp.tool.js';
+export declare class McpBridgeTool extends oVirtualTool {
+    constructor(config: oToolConfig);
+    _tool_validate_url(request: oRequest): Promise<ToolResult>;
+    _tool_add_remote_server(request: oRequest): Promise<ToolResult>;
+    _tool_add_local_server(request: oRequest): Promise<ToolResult>;
+    createMcpTool(mcpClient: Client, url: string, name?: string): Promise<McpTool>;
+}
+//# sourceMappingURL=mcp-bridge.tool.d.ts.map

package/dist/src/mcp-bridge.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-bridge.tool.d.ts","sourceRoot":"","sources":["../../src/mcp-bridge.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAY,QAAQ,EAAc,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIxC,qBAAa,aAAc,SAAQ,YAAY;gBACjC,MAAM,EAAE,WAAW;IASzB,kBAAkB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAsB1D,uBAAuB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAuC/D,sBAAsB,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IA+B9D,aAAa,CACjB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,OAAO,CAAC;CAuBpB"}

package/dist/src/mcp-bridge.tool.js

@@ -0,0 +1,109 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { McpTool } from './mcp.tool.js';
+import { MCP_BRIDGE_METHODS } from './methods/mcp-bridge.methods.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+export class McpBridgeTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: new oAddress('o://mcp'),
+            description: 'Tool to help add MCP servers to the network',
+            methods: MCP_BRIDGE_METHODS,
+        });
+    }
+    async _tool_validate_url(request) {
+        const params = request.params;
+        const { mcpServerUrl } = params;
+        // check the URL contents to see if it is a valid MCP server or a link describing one
+        const response = await this.use(new oAddress('o://perplexity'), {
+            method: 'completion',
+            params: {
+                model: 'sonar',
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Is this url an MCP server: ${mcpServerUrl}? Be concise in your answer.`,
+                    },
+                ],
+            },
+        });
+        return {
+            result: response.result.data.message,
+        };
+    }
+    async _tool_add_remote_server(request) {
+        const params = request.params;
+        // params have already been validated
+        const { mcpServerUrl, headers } = params;
+        try {
+            this.logger.debug('Adding MCP server: ' + mcpServerUrl);
+            const transport = new StreamableHTTPClientTransport(new URL(mcpServerUrl), {
+                requestInit: {
+                    headers: headers,
+                },
+            });
+            const mcpClient = new Client({
+                name: 'o-node:mcp:' + this.peerId.toString(),
+                version: '1.0.0',
+                headers: headers,
+            });
+            await mcpClient.connect(transport);
+            await this.createMcpTool(mcpClient, mcpServerUrl);
+            return {
+                message: 'Successfully added MCP server with ' +
+                    this.childNodes.length +
+                    ' tools',
+            };
+        }
+        catch (e) {
+            throw new Error('Error when trying to add MCP server (' +
+                mcpServerUrl +
+                ') to the network: ' +
+                e?.message);
+        }
+    }
+    async _tool_add_local_server(request) {
+        const params = request.params;
+        this.logger.debug('Adding local MCP server: ', params);
+        // params have already been validated
+        const { command, args, name } = params;
+        // this.logger.debug('Adding local MCP server: ' + mcpServerUrl);
+        const transport = new StdioClientTransport({
+            command: command,
+            args: args,
+        });
+        const mcpClient = new Client({
+            name: 'o-node:mcp:' + this.peerId.toString(),
+            version: '1.0.0',
+        });
+        await mcpClient.connect(transport);
+        await this.createMcpTool(mcpClient, args.join(' '), name);
+        return {
+            _save: true,
+            message: 'Successfully added local MCP server',
+        };
+    }
+    async createMcpTool(mcpClient, url, name) {
+        this.logger.debug('Creating MCP tool: ', name, url);
+        const mcpTool = new McpTool({
+            name: name || 'mcp-' + Date.now(),
+            description: 'MCP server for ' + url,
+            address: new oAddress(`o://${name || `mcp-${Date.now()}`}`),
+            mcpClient: mcpClient,
+            dependencies: [],
+            leader: this.config.leader,
+            parent: this.address,
+        });
+        this.addChildNode(mcpTool);
+        await this.startChildren();
+        await mcpTool.setupTools();
+        await this.use(new oAddress(mcpTool.address.toString()), {
+            method: 'index_network',
+            params: {},
+        });
+        return mcpTool;
+    }
+}

package/dist/src/mcp.tool.d.ts

@@ -0,0 +1,15 @@
+import { oToolConfig, oVirtualTool } from '@olane/o-tool';
+import { oAddress } from '@olane/o-core';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+export declare class McpTool extends oVirtualTool {
+    private mcpClient;
+    constructor(config: oToolConfig & {
+        address: oAddress;
+        mcpClient: Client;
+    });
+    setupTools(): Promise<void>;
+    myTools(): Promise<string[]>;
+    index(): Promise<any>;
+    whoami(): Promise<any>;
+}
+//# sourceMappingURL=mcp.tool.d.ts.map

package/dist/src/mcp.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.tool.d.ts","sourceRoot":"","sources":["../../src/mcp.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAyC,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAGnE,qBAAa,OAAQ,SAAQ,YAAY;IACvC,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,WAAW,GAAG;QAAE,OAAO,EAAE,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAYpE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC3B,OAAO;IAQP,KAAK;IA2BL,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC;CAmB7B"}

package/dist/src/mcp.tool.js

@@ -0,0 +1,89 @@
+import { oVirtualTool } from '@olane/o-tool';
+import { oAddress, oToolError, oToolErrorCodes } from '@olane/o-core';
+import { v4 as uuidv4 } from 'uuid';
+export class McpTool extends oVirtualTool {
+    constructor(config) {
+        super({
+            ...config,
+            address: config.address,
+            description: config.description ||
+                'Tool for wrapping MCP servers to be used as tools in the network',
+        });
+        this.mcpClient = config.mcpClient;
+    }
+    // _tool_ functions are dynamically added to the tool based on the MCP server's methods
+    async setupTools() {
+        this.logger.debug('Setting up MCP tools');
+        const tools = await this.mcpClient.listTools();
+        this.logger.debug('MCP tools: ', tools);
+        tools.tools.forEach((tool) => {
+            this.logger.debug('Setting up MCP server tool: ' + tool.name);
+            this.methods[tool.name] = {
+                name: tool.name,
+                description: tool.description || '',
+                parameters: tool.inputSchema.properties,
+                dependencies: [],
+            };
+            // @ts-ignore
+            this[`_tool_${tool.name}`] = async (request) => {
+                this.logger.debug('Calling MCP tool: ' + tool.name, request);
+                const params = request.params;
+                const result = await this.mcpClient.callTool({
+                    name: tool.name,
+                    arguments: params,
+                });
+                this.logger.debug('MCP tool result: ', result);
+                if (result.isError) {
+                    throw new oToolError(oToolErrorCodes.TOOL_ERROR, JSON.stringify(result.content));
+                }
+                return result.content;
+            };
+        });
+        await this.startChildren();
+    }
+    async myTools() {
+        const tools = await this.mcpClient.listTools();
+        return tools.tools.map((tool) => {
+            return tool.name;
+        });
+    }
+    // let's customize the index functionality to ensure we capture MCP insights
+    async index() {
+        const result = await super.index();
+        // add each mcp tool to the vector store
+        const tools = await this.mcpClient.listTools();
+        await Promise.all(tools.tools.map((tool) => {
+            return this.use(new oAddress('o://vector-store'), {
+                method: 'add_documents',
+                params: {
+                    documents: [
+                        {
+                            pageContent: tool.description,
+                            metadata: {
+                                address: this.address?.toString() + '/' + tool.name,
+                                id: uuidv4(),
+                            },
+                        },
+                    ],
+                },
+            });
+        })).catch((err) => {
+            this.logger.error('Error adding MCP tools to vector store: ', err);
+        });
+        return result;
+    }
+    async whoami() {
+        // do nothing
+        const tools = await this.mcpClient.listTools();
+        return {
+            tools: tools.tools.map((tool) => {
+                this.logger.debug('MCP Tool Definition: ', tool.name, tool.description, tool.inputSchema);
+                return {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema.properties,
+                };
+            }),
+        };
+    }
+}

package/dist/src/methods/mcp-bridge.methods.d.ts

@@ -0,0 +1,5 @@
+import { oMethod } from '@olane/o-protocol';
+export declare const MCP_BRIDGE_METHODS: {
+    [key: string]: oMethod;
+};
+//# sourceMappingURL=mcp-bridge.methods.d.ts.map

package/dist/src/methods/mcp-bridge.methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-bridge.methods.d.ts","sourceRoot":"","sources":["../../../src/methods/mcp-bridge.methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,eAAO,MAAM,kBAAkB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAkExD,CAAC"}

package/dist/src/methods/mcp-bridge.methods.js

@@ -0,0 +1,65 @@
+export const MCP_BRIDGE_METHODS = {
+    validate_url: {
+        name: 'validate_url',
+        description: 'Validate if a URL is a valid MCP server or a link to something else.',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'mcpServerUrl',
+                type: 'string',
+                value: 'string',
+                description: 'The URL of the MCP server to validate',
+                required: true,
+            },
+        ],
+    },
+    add_remote_server: {
+        name: 'add_remote_server',
+        description: 'Add a MCP server that is hosted on a remote server',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'mcpServerUrl',
+                type: 'string',
+                value: 'string',
+                description: 'The URL of the MCP server to use',
+                required: true,
+            },
+            {
+                name: 'headers',
+                type: 'object',
+                value: 'Record<string, string>',
+                description: 'The headers to send to the MCP server',
+                required: false,
+            },
+        ],
+    },
+    add_local_server: {
+        name: 'add_local_server',
+        description: 'Add a local MCP server to the bridge using command and arguments',
+        dependencies: [],
+        parameters: [
+            {
+                name: 'command',
+                type: 'string',
+                value: 'string',
+                description: 'The command to execute for the local MCP server',
+                required: true,
+            },
+            {
+                name: 'args',
+                type: 'array',
+                value: 'string[]',
+                description: 'The arguments to pass to the command',
+                required: true,
+            },
+            {
+                name: 'name',
+                type: 'string',
+                value: 'string',
+                description: 'The name for the MCP server',
+                required: true,
+            },
+        ],
+    },
+};

package/dist/src/o-client.mcp.d.ts

@@ -0,0 +1,15 @@
+import { Client, ClientOptions } from '@modelcontextprotocol/sdk/client/index.js';
+import { Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { IntentValue } from './o-transport.mcp';
+export type oClientOptions = ClientOptions & {
+    /** Value placed into `params._meta.intent` for every outgoing request/notification */
+    intent?: IntentValue | (() => IntentValue);
+};
+export declare class oClient extends Client {
+    private providedIntent?;
+    constructor(_clientInfo: Implementation, options?: oClientOptions);
+    connect(transport: Transport, options?: RequestOptions): Promise<void>;
+}
+//# sourceMappingURL=o-client.mcp.d.ts.map

package/dist/src/o-client.mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-client.mcp.d.ts","sourceRoot":"","sources":["../../src/o-client.mcp.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,MAAM,EACN,aAAa,EACd,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAEL,cAAc,EAEf,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAC1E,OAAO,EAAE,WAAW,EAA2B,MAAM,mBAAmB,CAAC;AAEzE,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG;IAC3C,sFAAsF;IACtF,MAAM,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,WAAW,CAAC,CAAC;CAC5C,CAAC;AAEF,qBAAa,OAAQ,SAAQ,MAAM;IACjC,OAAO,CAAC,cAAc,CAAC,CAAoC;gBAE/C,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,cAAc;IAK3D,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ7E"}

package/dist/src/o-client.mcp.js

@@ -0,0 +1,15 @@
+import { Client, } from '@modelcontextprotocol/sdk/client/index.js';
+import { IntentWrappingTransport } from './o-transport.mcp';
+export class oClient extends Client {
+    constructor(_clientInfo, options) {
+        super(_clientInfo, options);
+        this.providedIntent = options?.intent;
+    }
+    async connect(transport, options) {
+        const getIntent = () => typeof this.providedIntent === 'function'
+            ? this.providedIntent()
+            : this.providedIntent;
+        const wrapped = new IntentWrappingTransport(transport, getIntent);
+        return super.connect(wrapped, options);
+    }
+}

package/dist/src/o-server.mcp.d.ts

@@ -0,0 +1,13 @@
+import { Server, ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+import { Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+export type oServerOptions = ServerOptions & {
+    /** Validate that all incoming requests include `_meta.intent` */
+    requireIntent?: boolean;
+};
+export declare class oServer extends Server {
+    private requireIntent;
+    constructor(_serverInfo: Implementation, options?: oServerOptions);
+    connect(transport: Transport): Promise<void>;
+}
+//# sourceMappingURL=o-server.mcp.d.ts.map

package/dist/src/o-server.mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-server.mcp.d.ts","sourceRoot":"","sources":["../../src/o-server.mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,aAAa,EACd,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAEL,cAAc,EAEf,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAG1E,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG;IAC3C,iEAAiE;IACjE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,OAAQ,SAAQ,MAAM;IACjC,OAAO,CAAC,aAAa,CAAU;gBAEnB,WAAW,EAAE,cAAc,EAAE,OAAO,CAAC,EAAE,cAAc;IAK3D,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAenD"}

package/dist/src/o-server.mcp.js

@@ -0,0 +1,23 @@
+import { Server, } from '@modelcontextprotocol/sdk/server/index.js';
+import { IntentWrappingTransport } from './o-transport.mcp';
+export class oServer extends Server {
+    constructor(_serverInfo, options) {
+        super(_serverInfo, options);
+        this.requireIntent = !!options?.requireIntent;
+    }
+    async connect(transport) {
+        const wrapped = new IntentWrappingTransport(transport, () => undefined);
+        // Install a fallback request handler to enforce intent if requested
+        if (this.requireIntent) {
+            const prevFallback = this.fallbackRequestHandler;
+            this.fallbackRequestHandler = async (req, extra) => {
+                const meta = req?.params?._meta || extra._meta || {};
+                if (typeof meta.intent === 'undefined') {
+                    throw new Error('Missing required _meta.intent');
+                }
+                return prevFallback ? prevFallback(req, extra) : {};
+            };
+        }
+        return super.connect(wrapped);
+    }
+}

package/dist/src/o-transport.mcp.d.ts

@@ -0,0 +1,17 @@
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+export type IntentValue = unknown;
+export declare class IntentWrappingTransport implements Transport {
+    private inner;
+    private getIntent;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    sessionId?: string;
+    setProtocolVersion?: (version: string) => void;
+    constructor(inner: Transport, getIntent: () => IntentValue | undefined);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=o-transport.mcp.d.ts.map

package/dist/src/o-transport.mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-transport.mcp.d.ts","sourceRoot":"","sources":["../../src/o-transport.mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAEf,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAE1E,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAElC,qBAAa,uBAAwB,YAAW,SAAS;IACvD,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;gBAEnC,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,GAAG,SAAS;IAqBhE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAyB5C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/src/o-transport.mcp.js

@@ -0,0 +1,55 @@
+import { isJSONRPCRequest, } from '@modelcontextprotocol/sdk/types.js';
+export class IntentWrappingTransport {
+    constructor(inner, getIntent) {
+        this.inner = inner;
+        this.getIntent = getIntent;
+        // plumb events through
+        this.inner.onclose = () => this.onclose && this.onclose();
+        this.inner.onerror = (err) => this.onerror && this.onerror(err);
+        this.inner.onmessage = (message, extra) => {
+            // Enforce presence of intent for incoming requests (server-side usage)
+            if (isJSONRPCRequest(message)) {
+                const params = message.params || {};
+                const meta = params._meta || {};
+                if (typeof meta.intent === 'undefined') {
+                    // If the protocol has installed a handler, let it decide; otherwise, drop-through.
+                    // We do not auto-respond here to avoid interfering with the protocol; enforcement should be done at handlers.
+                }
+            }
+            this.onmessage && this.onmessage(message);
+        };
+    }
+    async start() {
+        await this.inner.start();
+        this.sessionId = this.inner.sessionId;
+        this.setProtocolVersion = this.inner.setProtocolVersion;
+    }
+    async send(message) {
+        try {
+            // Inject `_meta.intent` for outgoing requests/notifications
+            const m = message;
+            if (m && typeof m === 'object') {
+                const hasParams = typeof m.params === 'object' && m.params !== null;
+                if (!hasParams) {
+                    m.params = {};
+                }
+                if (typeof m.params._meta !== 'object' || m.params._meta === null) {
+                    m.params._meta = {};
+                }
+                if (typeof m.params._meta.intent === 'undefined') {
+                    const intent = this.getIntent();
+                    if (typeof intent !== 'undefined') {
+                        m.params._meta.intent = intent;
+                    }
+                }
+            }
+        }
+        catch (_) {
+            // Best-effort injection; ignore errors and proceed
+        }
+        return this.inner.send(message);
+    }
+    async close() {
+        await this.inner.close();
+    }
+}

package/dist/test/benchmark.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=benchmark.spec.d.ts.map

package/dist/test/benchmark.spec.d.ts.map

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

package/dist/test/benchmark.spec.js

@@ -0,0 +1,48 @@
+import { expect } from 'chai';
+import { GITHUB_TEST_CASES } from './benchmarks/github/github.test-cases.js';
+import { McpBridgeTool } from '../src/index.js';
+import { NodeState } from '@olane/o-core';
+import { IntelligenceTool } from '@olane/o-intelligence';
+import { oLeaderNode } from '@olane/o-leader';
+const leader = new oLeaderNode({
+    parent: null,
+    leader: null,
+});
+const mcpTool = new McpBridgeTool({
+    parent: null,
+    leader: null,
+});
+leader.addChildNode(mcpTool);
+const intelligenceTool = new IntelligenceTool({
+    parent: mcpTool.address,
+    leader: mcpTool.address,
+});
+leader.addChildNode(intelligenceTool);
+describe('o-mcp start node', () => {
+    it('should be able to start a node', async () => {
+        await leader.start();
+        expect(mcpTool.state).to.equal(NodeState.RUNNING);
+    });
+});
+describe('o-mcp github-benchmarks', () => {
+    it('should be able to test github benchmarks', async () => {
+        for (const testCase of GITHUB_TEST_CASES) {
+            console.log(testCase.input);
+            const handshakeResponse = await mcpTool.use(mcpTool.address, {
+                method: 'handshake',
+                params: {
+                    intent: testCase.input,
+                },
+            });
+            console.log(handshakeResponse.result.data);
+            // const result = await testCase.output;
+            // expect(result).to.contain(testCase.output.contains);
+        }
+    });
+});
+describe('o-mcp stop node', () => {
+    it('should be able to stop a node', async () => {
+        await leader.stop();
+        expect(mcpTool.state).to.equal(NodeState.STOPPED);
+    });
+});

package/dist/test/benchmarks/github/github.test-cases.d.ts

@@ -0,0 +1,3 @@
+import { TestCase } from '../interfaces/test-case.interface';
+export declare const GITHUB_TEST_CASES: TestCase[];
+//# sourceMappingURL=github.test-cases.d.ts.map

package/dist/test/benchmarks/github/github.test-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.test-cases.d.ts","sourceRoot":"","sources":["../../../../test/benchmarks/github/github.test-cases.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mCAAmC,CAAC;AAE7D,eAAO,MAAM,iBAAiB,EAAE,QAAQ,EAUvC,CAAC"}

package/dist/test/benchmarks/github/github.test-cases.js

@@ -0,0 +1,10 @@
+export const GITHUB_TEST_CASES = [
+    {
+        name: 'github-001',
+        description: 'Test case for creating a new repository with 3 branches and a PR',
+        input: `Hey! I need to set up a new repo for this travel planner project I'm working on. Can you help me create a repository called travel-planner-app? I need to start with 3 branches: main, feature-maps, and feature-itinerary. \n\nFor the README.md on main, can you add this content: \"# Travel Planner App\n\nA comprehensive travel planning application that helps users organize their trips, find attractions, and discover local restaurants.\"\n\nI also need an app.js file on the feature-itinerary branch with this basic Express setup: \"// Main application entry point\nconst express = require('express');\nconst app = express();\n\napp.get('/', (req, res) => {\n  res.send('Welcome to Travel Planner!');\n});\n\napp.listen(3000, () => {\n  console.log('Server running on port 3000');\n});\"\n\nOh, and don't forget a .gitignore file on main with: \"# Node dependencies\nnode_modules/\nnpm-debug.log*\nyarn-debug.log*\nyarn-error.log*\n\n# Python cache and virtual environments\n__pycache__/\n*.pyc\n*.py.class\nvenv/\n*.env\"\n\nI found this budget_estimation.py file in the OSU NLP Group's TravelPlanner repo that might be useful. Can you copy it to the feature-maps branch? \n\nLastly, I'd like to create a PR from feature-itinerary to main. Title it \"Add basic Express server setup\" and for the description: \"This PR implements the initial Express server configuration with a basic route handler for the homepage.\" Thanks!`,
+        output: {
+            contains: 'a',
+        },
+    },
+];

package/dist/test/benchmarks/interfaces/test-case.interface.d.ts

@@ -0,0 +1,10 @@
+export interface TestCase {
+    name: string;
+    description: string;
+    input: string;
+    output: {
+        contains?: string;
+        matches?: string;
+    };
+}
+//# sourceMappingURL=test-case.interface.d.ts.map

package/dist/test/benchmarks/interfaces/test-case.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-case.interface.d.ts","sourceRoot":"","sources":["../../../../test/benchmarks/interfaces/test-case.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE;QACN,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH"}

package/dist/test/benchmarks/interfaces/test-case.interface.js

@@ -0,0 +1 @@
+export {};

package/dist/test/utils/mcp-repo.d.ts

@@ -0,0 +1,2 @@
+export declare const MCP_REPO: string[];
+//# sourceMappingURL=mcp-repo.d.ts.map

package/dist/test/utils/mcp-repo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-repo.d.ts","sourceRoot":"","sources":["../../../test/utils/mcp-repo.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ,UAIpB,CAAC"}

package/dist/test/utils/mcp-repo.js

@@ -0,0 +1,5 @@
+export const MCP_REPO = [
+    `Add https://api.githubcopilot.com/mcp/ with API key: ${process.env.GITHUB_API_KEY}`,
+    `Add MCP server: "command": "uvx" and "args": ["mcp-server-time"]`,
+    ``,
+];

package/dist/test/utils/models.d.ts

@@ -0,0 +1,9 @@
+export declare const MODELS: {
+    ollama: string[];
+    openai: string[];
+    anthropic: string[];
+    google: string[];
+    deepseek: string[];
+    xAi: string[];
+};
+//# sourceMappingURL=models.d.ts.map

package/dist/test/utils/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../test/utils/models.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC"}

package/dist/test/utils/models.js

@@ -0,0 +1,8 @@
+export const MODELS = {
+    ollama: ['llama3.2:latest', 'deepseek-r1:7b'],
+    openai: ['gpt-4o', 'gpt-4o-mini', 'gpt-5'],
+    anthropic: ['claude-3.5-sonnet', 'claude-3.5-sonnet-20240620'],
+    google: ['gemini-2.0-flash-001', 'gemini-2.0-flash-001-8b'],
+    deepseek: ['deepseek-r1', 'deepseek-r1-8b'],
+    xAi: ['grok-4-0709', 'grok-3-mini', 'grok-3-fast'],
+};

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@olane/o-mcp",
+  "version": "0.6.1",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "aegir test",
+    "test:node": "aegir test -t node",
+    "test:browser": "aegir test -t browser",
+    "dev": "DEBUG=o-protocol:* npx tsx src/tests/index.ts",
+    "build": "tsc",
+    "deep:clean": "rm -rf node_modules && rm package-lock.json",
+    "start:prod": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "update:lib": "npm install @olane/o-core@latest",
+    "lint": "eslint src/**/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/olane-labs/olane.git"
+  },
+  "author": "oLane Inc.",
+  "license": "ISC",
+  "description": "oLane Core",
+  "devDependencies": {
+    "@olane/o-config": "file:../o-config",
+    "@olane/o-core": "file:../..",
+    "@olane/o-protocol": "file:../o-protocol",
+    "@olane/o-tool": "file:../o-tool",
+    "@olane/o-leader": "file:../o-leader",
+    "@olane/o-intelligence": "file:../o-intelligence",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.29.0",
+    "@tsconfig/node20": "^20.1.6",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.6",
+    "eslint-plugin-prettier": "^5.5.0",
+    "globals": "^16.2.0",
+    "jest": "^30.0.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.20.3",
+    "typescript": "5.4.5"
+  },
+  "peerDependencies": {
+    "@olane/o-config": "^0.6.1",
+    "@olane/o-core": "^0.6.1",
+    "@olane/o-protocol": "^0.6.1",
+    "@olane/o-tool": "^0.6.1",
+    "@olane/o-leader": "^0.6.1",
+    "@modelcontextprotocol/sdk": "^1.13.0"
+  },
+  "dependencies": {
+    "debug": "^4.4.1",
+    "dotenv": "^16.5.0"
+  }
+}