@bedrockio/ai 0.4.4 → 0.5.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.5.1
+
+- Added basic api key authorization.
+
+## 0.5.0
+
+- Added `McpServer` and basic handling of using it in tools.
+
 ## 0.4.3
 
 - Moved to files whitelist.

package/dist/cjs/McpServer.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SUPPORTED_VERSIONS = ['2025-03-26', '2025-06-18'];
+const ERROR_INVALID_SESSION = -32000;
+const ERROR_UNAUTHORIZED = -32001;
+const ERROR_METHOD_NOT_FOUND = -32601;
+const ERROR_INVALID_REQUEST = -32600;
+const ERROR_INVALID_PARAMS = -32602;
+class McpServer {
+    constructor(options = {}) {
+        this.validateOptions(options);
+        this.options = options;
+    }
+    async handleRequest(ctx) {
+        const { body } = ctx.request;
+        const { method } = body;
+        if (method === 'notifications/initialized') {
+            return;
+        }
+        this.assertValidTransport(body);
+        await this.assertAuthorization(ctx);
+        let result;
+        if (method === 'initialize') {
+            this.setNewSessionId(ctx);
+            result = this.initialize(body);
+        }
+        this.assertValidSession(ctx);
+        if (method === 'ping') {
+            result = this.ping();
+        }
+        else if (method === 'tools/list') {
+            result = this.listTools();
+        }
+        else if (method === 'tools/call') {
+            result = await this.callTool(body, ctx);
+        }
+        else if (!result) {
+            result = this.unknownMethod();
+        }
+        return {
+            jsonrpc: '2.0',
+            id: body.id,
+            ...result,
+        };
+    }
+    // Validation
+    validateOptions(options) {
+        const { name, version } = options;
+        if (!name) {
+            throw new Error(`"name" required.`);
+        }
+        else if (!version) {
+            throw new Error(`"version" required.`);
+        }
+    }
+    assertValidTransport(body) {
+        const { id, method, jsonrpc } = body;
+        if (id == null || !method || !jsonrpc) {
+            throw new InvalidRequestError();
+        }
+    }
+    async assertAuthorization(ctx) {
+        const { apiKeyRequired, isValidApiKey } = this.options;
+        const bearer = this.getBearer(ctx);
+        if (apiKeyRequired || bearer) {
+            const isValid = await isValidApiKey(bearer, ctx);
+            if (!isValid) {
+                throw new UnauthorizedError();
+            }
+        }
+    }
+    assertValidSession(ctx) {
+        if (!this.hasValidSessionId(ctx)) {
+            throw new InvalidSessionError();
+        }
+        ctx.set('content-type', 'application/json; charset=utf-8');
+    }
+    // Calls
+    initialize(body) {
+        const { protocolVersion } = body.params;
+        if (!this.isSupportedVersion(protocolVersion)) {
+            return this.invalidVersion(body);
+        }
+        const { name, version } = this.options;
+        return {
+            result: {
+                protocolVersion,
+                serverInfo: {
+                    name,
+                    version,
+                },
+                capabilities: {
+                    tools: {},
+                },
+            },
+        };
+    }
+    ping() {
+        return {
+            result: {},
+        };
+    }
+    listTools() {
+        const { tools = [] } = this.options;
+        return {
+            result: {
+                tools: tools.map((tool) => {
+                    const { handler, ...rest } = tool;
+                    return rest;
+                }),
+            },
+        };
+    }
+    async callTool(body, ctx) {
+        const { name, arguments: args } = body.params;
+        if (this.hasTool(name)) {
+            return await this.callValidTool(name, args, ctx);
+        }
+        else {
+            return this.invalidToolCall(name);
+        }
+    }
+    async callValidTool(name, args, ctx) {
+        const tool = this.getTool(name);
+        const result = await tool.handler(args, ctx);
+        return {
+            result: {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            },
+        };
+    }
+    invalidToolCall(name) {
+        return {
+            error: {
+                code: ERROR_INVALID_PARAMS,
+                message: `Unknown tool: ${name}`,
+            },
+        };
+    }
+    // Error calls
+    unknownMethod() {
+        return {
+            error: {
+                code: ERROR_METHOD_NOT_FOUND,
+                message: 'Method not found',
+            },
+        };
+    }
+    invalidVersion(request) {
+        return {
+            error: {
+                code: ERROR_INVALID_PARAMS,
+                message: 'Unsupported protocol version',
+                data: {
+                    requested: request.params.protocolVersion,
+                    supported: SUPPORTED_VERSIONS,
+                },
+            },
+        };
+    }
+    // Tool helpers
+    getTool(name) {
+        const { tools = [] } = this.options;
+        return tools.find((tool) => {
+            return tool.name === name;
+        });
+    }
+    hasTool(name) {
+        return !!this.getTool(name);
+    }
+    // Session helpers
+    getSessionId(ctx) {
+        return this.options.getSessionId?.(ctx);
+    }
+    hasValidSessionId(ctx) {
+        const id = ctx.get('mcp-session-id');
+        if (id) {
+            return id === this.getSessionId(ctx);
+        }
+        else {
+            return true;
+        }
+    }
+    setNewSessionId(ctx) {
+        const sessionId = this.getSessionId(ctx);
+        if (sessionId) {
+            ctx.set('mcp-session-id', sessionId);
+        }
+    }
+    // Authorization helpers
+    getBearer(ctx) {
+        const authorization = ctx.get('authorization') || '';
+        return authorization.match(/Bearer (.+)/)?.[1];
+    }
+    // Version helpers
+    isSupportedVersion(version) {
+        return SUPPORTED_VERSIONS.includes(version);
+    }
+}
+exports.default = McpServer;
+class InvalidRequestError extends Error {
+    status = 400;
+    toJSON() {
+        return {
+            jsonrpc: '2.0',
+            error: {
+                code: ERROR_INVALID_REQUEST,
+                message: 'Invalid Request',
+            },
+        };
+    }
+}
+class UnauthorizedError extends Error {
+    status = 401;
+    toJSON() {
+        return {
+            jsonrpc: '2.0',
+            error: {
+                code: ERROR_UNAUTHORIZED,
+                message: 'Unauthorized',
+            },
+        };
+    }
+}
+class InvalidSessionError extends Error {
+    status = 404;
+    toJSON() {
+        return {
+            jsonrpc: '2.0',
+            error: {
+                code: ERROR_INVALID_SESSION,
+                message: 'Invalid Session',
+            },
+        };
+    }
+}

package/dist/cjs/index.js

@@ -1,10 +1,16 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServer = void 0;
 exports.createClient = createClient;
 const anthropic_js_1 = require("./anthropic.js");
 const google_js_1 = require("./google.js");
 const openai_js_1 = require("./openai.js");
 const xai_js_1 = require("./xai.js");
+var McpServer_js_1 = require("./McpServer.js");
+Object.defineProperty(exports, "McpServer", { enumerable: true, get: function () { return __importDefault(McpServer_js_1).default; } });
 function createClient(options = {}) {
     const { platform } = options;
     if (!platform) {

package/dist/cjs/openai.js

@@ -49,7 +49,23 @@ class OpenAiClient extends BaseClient_js_1.default {
         return response.output_text;
     }
     getStructuredResponse(response) {
-        return JSON.parse(response.output_text);
+        // Note here that certain cases (tool usage etc)
+        // can result in multiple outputs with identical
+        // content. These outputs are simply concatenated
+        // together in output_text which will result in a
+        // JSON parse error, so take the LAST output_text
+        // entry assuming that this is its "final answer".
+        const outputs = response.output
+            .filter((item) => {
+            return item.type === 'message';
+        })
+            .flatMap((item) => {
+            return item.content.filter((c) => {
+                return c.type === 'output_text';
+            });
+        });
+        const last = outputs[outputs.length - 1];
+        return JSON.parse(last.text);
     }
     getMessagesResponse(input, response) {
         return {

package/dist/esm/McpServer.js

@@ -0,0 +1,238 @@
+const SUPPORTED_VERSIONS = ['2025-03-26', '2025-06-18'];
+const ERROR_INVALID_SESSION = -32000;
+const ERROR_UNAUTHORIZED = -32001;
+const ERROR_METHOD_NOT_FOUND = -32601;
+const ERROR_INVALID_REQUEST = -32600;
+const ERROR_INVALID_PARAMS = -32602;
+export default class McpServer {
+    constructor(options = {}) {
+        this.validateOptions(options);
+        this.options = options;
+    }
+    async handleRequest(ctx) {
+        const { body } = ctx.request;
+        const { method } = body;
+        if (method === 'notifications/initialized') {
+            return;
+        }
+        this.assertValidTransport(body);
+        await this.assertAuthorization(ctx);
+        let result;
+        if (method === 'initialize') {
+            this.setNewSessionId(ctx);
+            result = this.initialize(body);
+        }
+        this.assertValidSession(ctx);
+        if (method === 'ping') {
+            result = this.ping();
+        }
+        else if (method === 'tools/list') {
+            result = this.listTools();
+        }
+        else if (method === 'tools/call') {
+            result = await this.callTool(body, ctx);
+        }
+        else if (!result) {
+            result = this.unknownMethod();
+        }
+        return {
+            jsonrpc: '2.0',
+            id: body.id,
+            ...result,
+        };
+    }
+    // Validation
+    validateOptions(options) {
+        const { name, version } = options;
+        if (!name) {
+            throw new Error(`"name" required.`);
+        }
+        else if (!version) {
+            throw new Error(`"version" required.`);
+        }
+    }
+    assertValidTransport(body) {
+        const { id, method, jsonrpc } = body;
+        if (id == null || !method || !jsonrpc) {
+            throw new InvalidRequestError();
+        }
+    }
+    async assertAuthorization(ctx) {
+        const { apiKeyRequired, isValidApiKey } = this.options;
+        const bearer = this.getBearer(ctx);
+        if (apiKeyRequired || bearer) {
+            const isValid = await isValidApiKey(bearer, ctx);
+            if (!isValid) {
+                throw new UnauthorizedError();
+            }
+        }
+    }
+    assertValidSession(ctx) {
+        if (!this.hasValidSessionId(ctx)) {
+            throw new InvalidSessionError();
+        }
+        ctx.set('content-type', 'application/json; charset=utf-8');
+    }
+    // Calls
+    initialize(body) {
+        const { protocolVersion } = body.params;
+        if (!this.isSupportedVersion(protocolVersion)) {
+            return this.invalidVersion(body);
+        }
+        const { name, version } = this.options;
+        return {
+            result: {
+                protocolVersion,
+                serverInfo: {
+                    name,
+                    version,
+                },
+                capabilities: {
+                    tools: {},
+                },
+            },
+        };
+    }
+    ping() {
+        return {
+            result: {},
+        };
+    }
+    listTools() {
+        const { tools = [] } = this.options;
+        return {
+            result: {
+                tools: tools.map((tool) => {
+                    const { handler, ...rest } = tool;
+                    return rest;
+                }),
+            },
+        };
+    }
+    async callTool(body, ctx) {
+        const { name, arguments: args } = body.params;
+        if (this.hasTool(name)) {
+            return await this.callValidTool(name, args, ctx);
+        }
+        else {
+            return this.invalidToolCall(name);
+        }
+    }
+    async callValidTool(name, args, ctx) {
+        const tool = this.getTool(name);
+        const result = await tool.handler(args, ctx);
+        return {
+            result: {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result),
+                    },
+                ],
+            },
+        };
+    }
+    invalidToolCall(name) {
+        return {
+            error: {
+                code: ERROR_INVALID_PARAMS,
+                message: `Unknown tool: ${name}`,
+            },
+        };
+    }
+    // Error calls
+    unknownMethod() {
+        return {
+            error: {
+                code: ERROR_METHOD_NOT_FOUND,
+                message: 'Method not found',
+            },
+        };
+    }
+    invalidVersion(request) {
+        return {
+            error: {
+                code: ERROR_INVALID_PARAMS,
+                message: 'Unsupported protocol version',
+                data: {
+                    requested: request.params.protocolVersion,
+                    supported: SUPPORTED_VERSIONS,
+                },
+            },
+        };
+    }
+    // Tool helpers
+    getTool(name) {
+        const { tools = [] } = this.options;
+        return tools.find((tool) => {
+            return tool.name === name;
+        });
+    }
+    hasTool(name) {
+        return !!this.getTool(name);
+    }
+    // Session helpers
+    getSessionId(ctx) {
+        return this.options.getSessionId?.(ctx);
+    }
+    hasValidSessionId(ctx) {
+        const id = ctx.get('mcp-session-id');
+        if (id) {
+            return id === this.getSessionId(ctx);
+        }
+        else {
+            return true;
+        }
+    }
+    setNewSessionId(ctx) {
+        const sessionId = this.getSessionId(ctx);
+        if (sessionId) {
+            ctx.set('mcp-session-id', sessionId);
+        }
+    }
+    // Authorization helpers
+    getBearer(ctx) {
+        const authorization = ctx.get('authorization') || '';
+        return authorization.match(/Bearer (.+)/)?.[1];
+    }
+    // Version helpers
+    isSupportedVersion(version) {
+        return SUPPORTED_VERSIONS.includes(version);
+    }
+}
+class InvalidRequestError extends Error {
+    status = 400;
+    toJSON() {
+        return {
+            jsonrpc: '2.0',
+            error: {
+                code: ERROR_INVALID_REQUEST,
+                message: 'Invalid Request',
+            },
+        };
+    }
+}
+class UnauthorizedError extends Error {
+    status = 401;
+    toJSON() {
+        return {
+            jsonrpc: '2.0',
+            error: {
+                code: ERROR_UNAUTHORIZED,
+                message: 'Unauthorized',
+            },
+        };
+    }
+}
+class InvalidSessionError extends Error {
+    status = 404;
+    toJSON() {
+        return {
+            jsonrpc: '2.0',
+            error: {
+                code: ERROR_INVALID_SESSION,
+                message: 'Invalid Session',
+            },
+        };
+    }
+}

package/dist/esm/index.js

@@ -2,6 +2,7 @@ import { AnthropicClient } from './anthropic.js';
 import { GoogleClient } from './google.js';
 import { OpenAiClient } from './openai.js';
 import { XAiClient } from './xai.js';
+export { default as McpServer } from './McpServer.js';
 export function createClient(options = {}) {
     const { platform } = options;
     if (!platform) {

package/dist/esm/openai.js

@@ -43,7 +43,23 @@ export class OpenAiClient extends BaseClient {
         return response.output_text;
     }
     getStructuredResponse(response) {
-        return JSON.parse(response.output_text);
+        // Note here that certain cases (tool usage etc)
+        // can result in multiple outputs with identical
+        // content. These outputs are simply concatenated
+        // together in output_text which will result in a
+        // JSON parse error, so take the LAST output_text
+        // entry assuming that this is its "final answer".
+        const outputs = response.output
+            .filter((item) => {
+            return item.type === 'message';
+        })
+            .flatMap((item) => {
+            return item.content.filter((c) => {
+                return c.type === 'output_text';
+            });
+        });
+        const last = outputs[outputs.length - 1];
+        return JSON.parse(last.text);
     }
     getMessagesResponse(input, response) {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/ai",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Bedrock wrapper for common AI chatbots.",
   "type": "module",
   "scripts": {
@@ -45,7 +45,7 @@
   "devDependencies": {
     "@bedrockio/eslint-plugin": "^1.2.2",
     "@bedrockio/prettier-config": "^1.0.2",
-    "@bedrockio/yada": "^1.8.0",
+    "@bedrockio/yada": "^1.8.3",
     "eslint": "^9.36.0",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.9.3",

package/types/McpServer.d.ts

@@ -0,0 +1,100 @@
+export default class McpServer {
+    constructor(options?: {});
+    options: {};
+    handleRequest(ctx: any): Promise<{
+        result: {};
+        jsonrpc: string;
+        id: any;
+    } | {
+        error: {
+            code: number;
+            message: string;
+        };
+        jsonrpc: string;
+        id: any;
+    }>;
+    validateOptions(options: any): void;
+    assertValidTransport(body: any): void;
+    assertAuthorization(ctx: any): Promise<void>;
+    assertValidSession(ctx: any): void;
+    initialize(body: any): {
+        error: {
+            code: number;
+            message: string;
+            data: {
+                requested: any;
+                supported: string[];
+            };
+        };
+    } | {
+        result: {
+            protocolVersion: any;
+            serverInfo: {
+                name: any;
+                version: any;
+            };
+            capabilities: {
+                tools: {};
+            };
+        };
+    };
+    ping(): {
+        result: {};
+    };
+    listTools(): {
+        result: {
+            tools: any;
+        };
+    };
+    callTool(body: any, ctx: any, ...args: any[]): Promise<{
+        result: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    } | {
+        error: {
+            code: number;
+            message: string;
+        };
+    }>;
+    callValidTool(name: any, args: any, ctx: any): Promise<{
+        result: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    invalidToolCall(name: any): {
+        error: {
+            code: number;
+            message: string;
+        };
+    };
+    unknownMethod(): {
+        error: {
+            code: number;
+            message: string;
+        };
+    };
+    invalidVersion(request: any): {
+        error: {
+            code: number;
+            message: string;
+            data: {
+                requested: any;
+                supported: string[];
+            };
+        };
+    };
+    getTool(name: any): any;
+    hasTool(name: any): boolean;
+    getSessionId(ctx: any): any;
+    hasValidSessionId(ctx: any): boolean;
+    setNewSessionId(ctx: any): void;
+    getBearer(ctx: any): any;
+    isSupportedVersion(version: any): boolean;
+}
+//# sourceMappingURL=McpServer.d.ts.map

package/types/McpServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"McpServer.d.ts","sourceRoot":"","sources":["../src/McpServer.js"],"names":[],"mappings":"AAQA;IACE,0BAGC;IADC,YAAsB;IAGxB;;;;;;;;;;;OAmCC;IAID,oCAOC;IAED,sCAKC;IAED,6CAUC;IAED,mCAKC;IAID;;;;;;;;;;;;;;;;;;;;MAmBC;IAED;;MAIC;IAED;;;;MAUC;IAED;;;;;;;;;;;;OAOC;IAED;;;;;;;OAaC;IAED;;;;;MAOC;IAID;;;;;MAOC;IAED;;;;;;;;;MAWC;IAID,wBAKC;IAED,4BAEC;IAID,4BAEC;IAED,qCAOC;IAED,gCAKC;IAID,yBAGC;IAID,0CAEC;CACF"}

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export function createClient(options?: {}): AnthropicClient | GoogleClient | OpenAiClient;
+export { default as McpServer } from "./McpServer.js";
 import { AnthropicClient } from './anthropic.js';
 import { GoogleClient } from './google.js';
 import { OpenAiClient } from './openai.js';

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAKA,0FAkBC;gCAvB+B,gBAAgB;6BACnB,aAAa;6BACb,aAAa"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAMA,0FAkBC;;gCAxB+B,gBAAgB;6BACnB,aAAa;6BACb,aAAa"}

package/types/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.js"],"names":[],"mappings":"AAIA;IACE,6BAAoC;IAIlC,eAAiC;IAGnC;;;OAGG;IACH,4BAGC;IAED;;yFA+BC;IAED;;yFAKC;IAED,oCAEC;IAMD;;;MAaC;IAID;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;MAyBC;CACF;uBAnIsB,iBAAiB;mBAFrB,QAAQ"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.js"],"names":[],"mappings":"AAIA;IACE,6BAAoC;IAIlC,eAAiC;IAGnC;;;OAGG;IACH,4BAGC;IAED;;yFA+BC;IAED;;yFAKC;IAED,oCAEC;IAwBD;;;MAaC;IAID;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;MAyBC;CACF;uBArJsB,iBAAiB;mBAFrB,QAAQ"}