poe-code 3.0.231 → 3.0.233

package/packages/tiny-stdio-mcp-server/dist/index.d.ts

@@ -5,5 +5,5 @@ export type { TypedSchema } from "./schema.js";
 export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, } from "./content/index.js";
 export type { ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, } from "./content/index.js";
 export type { ToolReturn } from "./content/index.js";
-export type { ServerOptions, ToolHandler, ToolDefinition, Tool, CallToolResult, HandleResult, ContentItem, JSONSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult, } from "./types.js";
+export type { ServerOptions, ToolHandler, ToolDefinition, Tool, ToolAnnotations, ToolExecution, Icon, ContentAnnotations, ResourceLink, CallToolResult, PromptContentItem, PromptArgument, Prompt, PromptMessage, GetPromptResult, PromptHandler, PromptDefinition, Resource, ResourceTemplate, ResourceContents, ReadResourceResult, ResourceHandler, ResourceDefinition, ResourceTemplateDefinition, HandleResult, ContentItem, JSONSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult, } from "./types.js";
 export { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";

package/packages/tiny-stdio-mcp-server/dist/server.d.ts

@@ -1,11 +1,21 @@
-import type { ServerOptions, ToolHandler, HandleResult, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
+import type { ServerOptions, ToolDefinition, ToolHandler, HandleResult, Prompt, PromptHandler, Resource, ResourceHandler, ResourceTemplate, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
 import type { TypedSchema } from "./schema.js";
 export interface Server {
     tool<T>(name: string, description: string, inputSchema: TypedSchema<T>, handler: ToolHandler<T>): Server;
+    registerTool<T>(definition: Omit<ToolDefinition<T>, "handler">, handler: ToolHandler<T>): Server;
+    prompt(definition: Prompt, handler: PromptHandler): Server;
+    resource(definition: Resource, handler: ResourceHandler): Server;
+    resourceTemplate(definition: ResourceTemplate, handler: ResourceHandler): Server;
     onNotification(listener: (notification: JSONRPCNotification) => void): () => void;
     removeTool(name: string): boolean;
+    removePrompt(name: string): boolean;
+    removeResource(uri: string): boolean;
+    removeResourceTemplate(uriTemplate: string): boolean;
     notifyToolsChanged(): Promise<void>;
-    createMessageSession(): MessageSession;
+    notifyPromptsChanged(): Promise<void>;
+    notifyResourcesChanged(): Promise<void>;
+    notifyResourceUpdated(uri: string): Promise<void>;
+    createMessageSession(listener?: (notification: JSONRPCNotification) => void | Promise<void>): MessageSession;
     handleMessage(method: string, params?: Record<string, unknown>): Promise<HandleResult>;
     listen(): Promise<void>;
     connect(transport: Transport): Promise<void>;

package/packages/tiny-stdio-mcp-server/dist/server.js

@@ -1,4 +1,7 @@
 import * as readline from "readline";
+import AjvModule from "ajv";
+import uriTemplateParser from "uri-template";
+import UriTemplate from "uri-template-lite";
 import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
 import { parseMessage, formatSuccessResponse, formatErrorResponse, } from "./jsonrpc.js";
 import { toContentBlocks } from "./content/convert.js";
@@ -9,12 +12,21 @@ const SUPPORTED_PROTOCOL_VERSIONS = new Set([
     PROTOCOL_VERSION,
 ]);
 export function createServer(options) {
+    const Ajv = "default" in AjvModule ? AjvModule.default : AjvModule;
+    const jsonSchemaValidator = new Ajv({ strict: false });
+    const supportNotifications = options.supportNotifications !== false;
+    const supportResourceSubscriptions = options.supportResourceSubscriptions !== false;
     const tools = new Map();
+    const prompts = new Map();
+    const resources = new Map();
+    const resourceTemplates = new Map();
     const notificationListeners = new Set();
     const connectionNotificationListeners = new Map();
     const defaultLifecycle = {
         initialized: false,
         initializeAccepted: false,
+        notificationReady: false,
+        resourceSubscriptions: new Set(),
     };
     const messageLifecycles = new Set([defaultLifecycle]);
     const handleMessageWithLifecycle = async (method, lifecycle, params) => {
@@ -30,6 +42,7 @@ export function createServer(options) {
             // still enforced by the separate lifecycle object given to each connection.
             lifecycle.initializeAccepted = true;
             lifecycle.initialized = true;
+            lifecycle.notificationReady = false;
             const requestedProtocol = typeof params?.protocolVersion === "string"
                 ? params.protocolVersion
                 : undefined;
@@ -39,7 +52,14 @@ export function createServer(options) {
                     : PROTOCOL_VERSION,
                 capabilities: {
                     tools: {
-                        listChanged: true,
+                        ...(supportNotifications ? { listChanged: true } : {}),
+                    },
+                    prompts: {
+                        ...(supportNotifications ? { listChanged: true } : {}),
+                    },
+                    resources: {
+                        ...(supportNotifications ? { listChanged: true } : {}),
+                        ...(supportResourceSubscriptions ? { subscribe: true } : {}),
                     },
                 },
                 serverInfo: {
@@ -58,6 +78,7 @@ export function createServer(options) {
                     },
                 };
             }
+            lifecycle.notificationReady = true;
             return { result: undefined };
         }
         // All other methods require initialization
@@ -72,10 +93,10 @@ export function createServer(options) {
         if (method === "tools/list") {
             const toolList = [];
             for (const tool of tools.values()) {
+                const descriptor = { ...tool };
+                delete descriptor.handler;
                 toolList.push({
-                    name: tool.name,
-                    description: tool.description,
-                    inputSchema: tool.inputSchema,
+                    ...descriptor,
                 });
             }
             return { result: { tools: toolList } };
@@ -100,7 +121,7 @@ export function createServer(options) {
                 };
             }
             const toolArgs = (params?.arguments ?? {});
-            if (options.validateToolArguments !== false && !areValidToolArguments(tool.inputSchema, toolArgs)) {
+            if (options.validateToolArguments !== false && !jsonSchemaValidator.validate(tool.inputSchema, toolArgs)) {
                 return {
                     error: {
                         code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
@@ -116,6 +137,11 @@ export function createServer(options) {
                 const result = isCallToolResult(handlerResult)
                     ? handlerResult
                     : { content: toContentBlocks(handlerResult) };
+                if (tool.outputSchema !== undefined
+                    && (result.structuredContent === undefined
+                        || !jsonSchemaValidator.validate(tool.outputSchema, result.structuredContent))) {
+                    throw new Error("Invalid structured tool result");
+                }
                 return { result };
             }
             catch (err) {
@@ -135,6 +161,96 @@ export function createServer(options) {
                 return { result };
             }
         }
+        if (method === "prompts/list") {
+            return {
+                result: {
+                    prompts: [...prompts.values()].map(({ handler: _handler, ...prompt }) => prompt),
+                },
+            };
+        }
+        if (method === "prompts/get") {
+            const promptName = typeof params?.name === "string" ? params.name : undefined;
+            if (promptName === undefined) {
+                return invalidParams("Prompt name required");
+            }
+            const prompt = prompts.get(promptName);
+            if (prompt === undefined) {
+                return invalidParams(`Prompt not found: ${promptName}`);
+            }
+            const args = toStringArguments(params?.arguments);
+            if (args === undefined || !hasRequiredPromptArguments(prompt, args)) {
+                return invalidParams("Invalid prompt arguments");
+            }
+            try {
+                const result = await prompt.handler(args);
+                if (!isGetPromptResult(result)) {
+                    return internalError("Invalid prompt result");
+                }
+                return { result };
+            }
+            catch (error) {
+                return internalError(toErrorMessage(error));
+            }
+        }
+        if (method === "resources/list") {
+            return {
+                result: {
+                    resources: [...resources.values()].map(({ handler: _handler, ...resource }) => resource),
+                },
+            };
+        }
+        if (method === "resources/templates/list") {
+            return {
+                result: {
+                    resourceTemplates: [...resourceTemplates.values()].map(({ handler: _handler, ...resourceTemplate }) => resourceTemplate),
+                },
+            };
+        }
+        if (method === "resources/read") {
+            const uri = typeof params?.uri === "string" ? params.uri : undefined;
+            if (uri === undefined || !isValidUri(uri)) {
+                return invalidParams("Resource URI required");
+            }
+            const resource = findReadableResource(uri, resources, resourceTemplates);
+            if (resource === undefined) {
+                return resourceNotFound(uri);
+            }
+            try {
+                const result = await resource.handler(uri);
+                if (!isReadResourceResult(result)) {
+                    return internalError("Invalid resource result");
+                }
+                return { result };
+            }
+            catch (error) {
+                return internalError(toErrorMessage(error));
+            }
+        }
+        if (method === "resources/subscribe" || method === "resources/unsubscribe") {
+            if (!supportResourceSubscriptions) {
+                return {
+                    error: {
+                        code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+                        message: "Method not found",
+                    },
+                };
+            }
+            const uri = typeof params?.uri === "string" ? params.uri : undefined;
+            if (uri === undefined || !isValidUri(uri)) {
+                return invalidParams("Resource URI required");
+            }
+            if (method === "resources/subscribe"
+                && findReadableResource(uri, resources, resourceTemplates) === undefined) {
+                return resourceNotFound(uri);
+            }
+            if (method === "resources/subscribe") {
+                lifecycle.resourceSubscriptions.add(uri);
+            }
+            else {
+                lifecycle.resourceSubscriptions.delete(uri);
+            }
+            return { result: {} };
+        }
         return {
             error: {
                 code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
@@ -142,15 +258,23 @@ export function createServer(options) {
             },
         };
     };
-    const createMessageSession = () => {
+    const createMessageSession = (listener) => {
         const lifecycle = {
             initialized: false,
             initializeAccepted: false,
+            notificationReady: false,
+            resourceSubscriptions: new Set(),
         };
         messageLifecycles.add(lifecycle);
+        if (listener !== undefined) {
+            connectionNotificationListeners.set(listener, lifecycle);
+        }
         return {
             handleMessage: (method, params) => handleMessageWithLifecycle(method, lifecycle, params),
             close: () => {
+                if (listener !== undefined) {
+                    connectionNotificationListeners.delete(listener);
+                }
                 messageLifecycles.delete(lifecycle);
             },
         };
@@ -186,16 +310,17 @@ export function createServer(options) {
             write(formatSuccessResponse(requestWithId.id, result) + "\n");
         }
     };
-    const broadcastNotification = async (method) => {
+    const broadcastNotification = async (method, params, canSend = () => true) => {
         const notification = {
             jsonrpc: "2.0",
             method,
+            ...(params === undefined ? {} : { params }),
         };
         for (const listener of notificationListeners) {
             listener(notification);
         }
         await Promise.all([...connectionNotificationListeners].map(async ([listener, lifecycle]) => {
-            if (lifecycle.initialized) {
+            if (lifecycle.notificationReady && canSend(lifecycle)) {
                 await listener(notification);
             }
         }));
@@ -210,6 +335,30 @@ export function createServer(options) {
             });
             return server;
         },
+        registerTool(definition, handler) {
+            tools.set(definition.name, {
+                ...definition,
+                handler: handler,
+            });
+            return server;
+        },
+        prompt(definition, handler) {
+            prompts.set(definition.name, { ...definition, handler });
+            return server;
+        },
+        resource(definition, handler) {
+            if (!isValidUri(definition.uri)) {
+                throw new Error(`Invalid resource URI: ${definition.uri}`);
+            }
+            resources.set(definition.uri, { ...definition, handler });
+            return server;
+        },
+        resourceTemplate(definition, handler) {
+            uriTemplateParser.parse(definition.uriTemplate);
+            new UriTemplate(definition.uriTemplate);
+            resourceTemplates.set(definition.uriTemplate, { ...definition, handler });
+            return server;
+        },
         onNotification(listener) {
             notificationListeners.add(listener);
             return () => {
@@ -219,11 +368,36 @@ export function createServer(options) {
         removeTool(name) {
             return tools.delete(name);
         },
+        removePrompt(name) {
+            return prompts.delete(name);
+        },
+        removeResource(uri) {
+            return resources.delete(uri);
+        },
+        removeResourceTemplate(uriTemplate) {
+            return resourceTemplates.delete(uriTemplate);
+        },
         async notifyToolsChanged() {
-            if ([...messageLifecycles].some((lifecycle) => lifecycle.initialized)) {
+            if (supportNotifications && [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady)) {
                 await broadcastNotification("notifications/tools/list_changed");
             }
         },
+        async notifyPromptsChanged() {
+            if (supportNotifications && [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady)) {
+                await broadcastNotification("notifications/prompts/list_changed");
+            }
+        },
+        async notifyResourcesChanged() {
+            if (supportNotifications && [...messageLifecycles].some((lifecycle) => lifecycle.notificationReady)) {
+                await broadcastNotification("notifications/resources/list_changed");
+            }
+        },
+        async notifyResourceUpdated(uri) {
+            if (!supportResourceSubscriptions) {
+                return;
+            }
+            await broadcastNotification("notifications/resources/updated", { uri }, (lifecycle) => lifecycle.resourceSubscriptions.has(uri));
+        },
         createMessageSession,
         handleMessage,
         async listen() {
@@ -234,7 +408,7 @@ export function createServer(options) {
         },
         async connect(transport) {
             return new Promise((resolve) => {
-                const lifecycle = { initialized: false, initializeAccepted: false };
+                const lifecycle = { initialized: false, initializeAccepted: false, notificationReady: false, resourceSubscriptions: new Set() };
                 const messageHandler = (method, params) => handleMessageWithLifecycle(method, lifecycle, params);
                 messageLifecycles.add(lifecycle);
                 const listener = (notification) => {
@@ -263,7 +437,7 @@ export function createServer(options) {
         },
         async connectSDK(transport) {
             return new Promise((resolve, reject) => {
-                const lifecycle = { initialized: false, initializeAccepted: false };
+                const lifecycle = { initialized: false, initializeAccepted: false, notificationReady: false, resourceSubscriptions: new Set() };
                 const messageHandler = (method, params) => handleMessageWithLifecycle(method, lifecycle, params);
                 messageLifecycles.add(lifecycle);
                 const listener = (notification) => transport.send(notification);
@@ -326,39 +500,107 @@ export function createServer(options) {
     };
     return server;
 }
-function isCallToolResult(value) {
-    return hasContentArray(value) && value.content.every(isContentItem);
+function invalidParams(message) {
+    return {
+        error: {
+            code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+            message,
+        },
+    };
 }
-function hasContentArray(value) {
-    return typeof value === "object" && value !== null && "content" in value
-        && Array.isArray(value.content);
+function internalError(message) {
+    return {
+        error: {
+            code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+            message,
+        },
+    };
 }
-function areValidToolArguments(schema, value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+function resourceNotFound(uri) {
+    return {
+        error: {
+            code: JSON_RPC_ERROR_CODES.RESOURCE_NOT_FOUND,
+            message: `Resource not found: ${uri}`,
+        },
+    };
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isValidUri(uri) {
+    try {
+        new URL(uri);
+        return true;
+    }
+    catch {
         return false;
     }
-    const argumentsObject = value;
-    for (const key of schema.required ?? []) {
-        if (!Object.hasOwn(argumentsObject, key)) {
-            return false;
-        }
+}
+function toStringArguments(value) {
+    if (value === undefined) {
+        return {};
     }
-    for (const [key, property] of Object.entries(schema.properties)) {
-        if (!Object.hasOwn(argumentsObject, key)) {
-            continue;
-        }
-        const argument = argumentsObject[key];
-        if (argument === null && property.nullable === true) {
-            continue;
-        }
-        if ((property.type === "array" && !Array.isArray(argument))
-            || (property.type === "object" && (typeof argument !== "object" || argument === null || Array.isArray(argument)))
-            || (property.type === "integer" && (!Number.isInteger(argument)))
-            || (property.type !== "array" && property.type !== "object" && property.type !== "integer" && typeof argument !== property.type)) {
-            return false;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const args = {};
+    for (const [name, argument] of Object.entries(value)) {
+        if (typeof argument !== "string") {
+            return undefined;
         }
+        args[name] = argument;
+    }
+    return args;
+}
+function hasRequiredPromptArguments(prompt, args) {
+    return (prompt.arguments ?? []).every((argument) => argument.required !== true || args[argument.name] !== undefined);
+}
+function findReadableResource(uri, resources, resourceTemplates) {
+    const resource = resources.get(uri);
+    if (resource !== undefined) {
+        return resource;
     }
-    return true;
+    return [...resourceTemplates.values()].find((template) => matchesUriTemplate(template.uriTemplate, uri));
+}
+function matchesUriTemplate(template, uri) {
+    try {
+        return new UriTemplate(template).match(uri) !== null;
+    }
+    catch {
+        return false;
+    }
+}
+function isCallToolResult(value) {
+    return hasContentArray(value) && value.content.every(isContentItem);
+}
+function isGetPromptResult(value) {
+    if (typeof value !== "object" || value === null || !("messages" in value)) {
+        return false;
+    }
+    return Array.isArray(value.messages)
+        && value.messages.every((message) => typeof message === "object"
+            && message !== null
+            && "role" in message
+            && (message.role === "user" || message.role === "assistant")
+            && "content" in message
+            && isPromptContentItem(message.content));
+}
+function isReadResourceResult(value) {
+    if (typeof value !== "object" || value === null || !("contents" in value)) {
+        return false;
+    }
+    return Array.isArray(value.contents)
+        && value.contents.every((content) => typeof content === "object"
+            && content !== null
+            && "uri" in content
+            && typeof content.uri === "string"
+            && isValidUri(content.uri)
+            && (("text" in content && typeof content.text === "string")
+                || ("blob" in content && typeof content.blob === "string" && isBase64(content.blob))));
+}
+function hasContentArray(value) {
+    return typeof value === "object" && value !== null && "content" in value
+        && Array.isArray(value.content);
 }
 function isContentItem(value) {
     if (typeof value !== "object" || value === null || !("type" in value)) {
@@ -369,13 +611,41 @@ function isContentItem(value) {
         return typeof block.text === "string";
     }
     if (block.type === "image" || block.type === "audio") {
-        return typeof block.data === "string" && typeof block.mimeType === "string";
+        return typeof block.data === "string" && isBase64(block.data) && typeof block.mimeType === "string";
+    }
+    if (block.type === "resource_link") {
+        return typeof block.uri === "string" && typeof block.name === "string";
     }
     if (block.type !== "resource" || typeof block.resource !== "object" || block.resource === null) {
         return false;
     }
     const resource = block.resource;
     return typeof resource.uri === "string"
-        && typeof resource.mimeType === "string"
-        && (typeof resource.text === "string" || typeof resource.blob === "string");
+        && (resource.mimeType === undefined || typeof resource.mimeType === "string")
+        && (typeof resource.text === "string" || (typeof resource.blob === "string" && isBase64(resource.blob)));
+}
+function isBase64(value) {
+    if (value.length === 0) {
+        return true;
+    }
+    if (value.length % 4 !== 0) {
+        return false;
+    }
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    const paddingStart = value.indexOf("=");
+    const encoded = paddingStart === -1 ? value : value.slice(0, paddingStart);
+    const padding = paddingStart === -1 ? "" : value.slice(paddingStart);
+    if (padding.length > 2 || [...padding].some((character) => character !== "=")) {
+        return false;
+    }
+    if ([...encoded].some((character) => !alphabet.includes(character))) {
+        return false;
+    }
+    return Buffer.from(value, "base64").toString("base64") === value;
+}
+function isPromptContentItem(value) {
+    if (!isContentItem(value)) {
+        return false;
+    }
+    return !(typeof value === "object" && value !== null && "type" in value && value.type === "resource_link");
 }