@outfitter/mcp 0.4.2 → 0.5.0

package/dist/shared/@outfitter/{mcp-hh12tqfg.js → mcp-yf1n85e9.js}

@@ -1,70 +1,33 @@
 // @bun
+import {
+  VALID_MCP_LOG_LEVELS,
+  createDefaultMcpSink,
+  resolveDefaultLogLevel
+} from "./mcp-n9vzcp37.js";
+import {
+  matchUriTemplate
+} from "./mcp-zt2s3r38.js";
+import {
+  createMcpProgressCallback
+} from "./mcp-q70dtfj6.js";
 import {
   shouldEmitLog
 } from "./mcp-fjtxsa0x.js";
-import {
-  zodToJsonSchema
-} from "./mcp-zy7b487d.js";
 import {
   McpError
-} from "./mcp-9m5hs2z0.js";
+} from "./mcp-s2vnhzav.js";
+import {
+  zodToJsonSchema
+} from "./mcp-hw5wz4gb.js";
 
 // packages/mcp/src/server.ts
-import { getEnvironment, getEnvironmentDefaults } from "@outfitter/config";
-import { generateRequestId, Result } from "@outfitter/contracts";
 import {
-  createOutfitterLoggerFactory,
-  createPrettyFormatter
-} from "@outfitter/logging";
-var VALID_MCP_LOG_LEVELS = new Set([
-  "debug",
-  "info",
-  "notice",
-  "warning",
-  "error",
-  "critical",
-  "alert",
-  "emergency"
-]);
-var DEFAULTS_TO_MCP = {
-  debug: "debug",
-  info: "info",
-  warn: "warning",
-  error: "error"
-};
-function createDefaultMcpSink() {
-  const formatter = createPrettyFormatter({ colors: false });
-  return {
-    formatter,
-    write(record, formatted) {
-      const serialized = formatted ?? formatter.format(record);
-      const line = serialized.endsWith(`
-`) ? serialized : `${serialized}
-`;
-      if (typeof process !== "undefined" && process.stderr?.write) {
-        process.stderr.write(line);
-      }
-    }
-  };
-}
-function resolveDefaultLogLevel(options) {
-  const envLogLevel = process.env["OUTFITTER_LOG_LEVEL"];
-  if (envLogLevel !== undefined && VALID_MCP_LOG_LEVELS.has(envLogLevel)) {
-    return envLogLevel;
-  }
-  if (options.defaultLogLevel !== undefined && (options.defaultLogLevel === null || VALID_MCP_LOG_LEVELS.has(options.defaultLogLevel))) {
-    return options.defaultLogLevel;
-  }
-  const env = getEnvironment();
-  const defaults = getEnvironmentDefaults(env);
-  if (defaults.logLevel !== null) {
-    const mapped = DEFAULTS_TO_MCP[defaults.logLevel];
-    if (mapped !== undefined) {
-      return mapped;
-    }
-  }
-  return null;
-}
+  formatZodIssues,
+  generateRequestId,
+  Result,
+  ValidationError
+} from "@outfitter/contracts";
+import { createOutfitterLoggerFactory } from "@outfitter/logging";
 function createMcpServer(options) {
   const { name, version, logger: providedLogger } = options;
   let loggerFactory = null;
@@ -84,10 +47,10 @@ function createMcpServer(options) {
   let sdkServer = null;
   const subscriptions = new Set;
   let clientLogLevel = resolveDefaultLogLevel(options);
-  function createHandlerContext(toolName, requestId, signal, progressToken) {
+  function createHandlerContext(label, requestId, signal, progressToken, loggerMeta) {
     const ctx = {
       requestId,
-      logger: logger.child({ tool: toolName, requestId }),
+      logger: logger.child(loggerMeta ?? { tool: label, requestId }),
       cwd: process.cwd(),
       env: process.env
     };
@@ -95,19 +58,27 @@ function createMcpServer(options) {
       ctx.signal = signal;
     }
     if (progressToken !== undefined && sdkServer) {
-      ctx.progress = {
-        report(progress, total, message) {
-          sdkServer?.notification?.({
-            method: "notifications/progress",
-            params: {
-              progressToken,
-              progress,
-              ...total !== undefined ? { total } : {},
-              ...message ? { message } : {}
-            }
+      const sender = (notification) => {
+        const maybePromise = sdkServer?.notification?.(notification);
+        if (typeof maybePromise === "object" && maybePromise !== null && "then" in maybePromise) {
+          maybePromise.catch((error) => {
+            logger.warn("Failed to send MCP progress notification", {
+              error: error instanceof Error ? error.message : String(error)
+            });
           });
         }
       };
+      const streamProgress = createMcpProgressCallback(progressToken, sender);
+      const progress = streamProgress;
+      progress.report = (value, total, message) => {
+        streamProgress({
+          type: "progress",
+          current: value,
+          total: total ?? value,
+          ...message !== undefined ? { message } : {}
+        });
+      };
+      ctx.progress = progress;
     }
     return ctx;
   }
@@ -125,13 +96,17 @@ function createMcpServer(options) {
       cancelled: -32603
     };
     const code = codeMap[error.category] ?? -32603;
+    const context = {
+      originalTag: error._tag,
+      category: error.category
+    };
+    if (error._tag === "ValidationError" && "field" in error && typeof error.field === "string") {
+      context["field"] = error.field;
+    }
     return new McpError({
       message: error.message,
       code,
-      context: {
-        originalTag: error._tag,
-        category: error.category
-      }
+      context
     });
   }
   const server = {
@@ -322,12 +297,10 @@ function createMcpServer(options) {
           }));
         }
         const requestId = generateRequestId();
-        const ctx = {
-          requestId,
-          logger: logger.child({ resource: uri, requestId }),
-          cwd: process.cwd(),
-          env: process.env
-        };
+        const ctx = createHandlerContext(uri, requestId, undefined, undefined, {
+          resource: uri,
+          requestId
+        });
         try {
           const result = await resource.handler(uri, ctx);
           if (result.isErr()) {
@@ -346,18 +319,15 @@ function createMcpServer(options) {
         const variables = matchUriTemplate(template.uriTemplate, uri);
         if (variables) {
           const templateRequestId = generateRequestId();
-          const templateCtx = {
-            requestId: templateRequestId,
-            logger: logger.child({
-              resource: uri,
-              requestId: templateRequestId
-            }),
-            cwd: process.cwd(),
-            env: process.env
-          };
+          const templateCtx = createHandlerContext(uri, templateRequestId, undefined, undefined, { resource: uri, requestId: templateRequestId });
           try {
             const result = await template.handler(uri, variables, templateCtx);
             if (result.isErr()) {
+              logger.warn("Resource template handler returned error", {
+                uri,
+                requestId: templateRequestId,
+                error: result.error._tag
+              });
               return Result.err(translateError(result.error));
             }
             return Result.ok(result.value);
@@ -390,7 +360,7 @@ function createMcpServer(options) {
       }
       const parseResult = tool.zodSchema.safeParse(input);
       if (!parseResult.success) {
-        const errorMessages = parseResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+        const errorMessages = formatZodIssues(parseResult.error.issues);
         logger.warn("Input validation failed", {
           tool: toolName,
           requestId,
@@ -460,6 +430,10 @@ function createMcpServer(options) {
       sdkServer?.sendPromptListChanged?.();
     },
     setLogLevel(level) {
+      if (!VALID_MCP_LOG_LEVELS.has(level)) {
+        logger.warn("Ignoring invalid client log level", { level });
+        return;
+      }
       clientLogLevel = level;
       logger.debug("Client log level set", { level });
     },
@@ -496,39 +470,25 @@ function createMcpServer(options) {
 function defineTool(definition) {
   return definition;
 }
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function matchUriTemplate(template, uri) {
-  const paramNames = [];
-  const parts = template.split(/(\{[^}]+\})/);
-  const regexSource = parts.map((part) => {
-    const paramMatch = part.match(/^\{([^}]+)\}$/);
-    if (paramMatch?.[1]) {
-      paramNames.push(paramMatch[1]);
-      return "([^/]+)";
-    }
-    return escapeRegex(part);
-  }).join("");
-  const regex = new RegExp(`^${regexSource}$`);
-  const match = uri.match(regex);
-  if (!match) {
-    return null;
-  }
-  const variables = {};
-  for (let i = 0;i < paramNames.length; i++) {
-    const name = paramNames[i];
-    const value = match[i + 1];
-    if (name !== undefined && value !== undefined) {
-      variables[name] = value;
-    }
-  }
-  return variables;
-}
 function defineResource(definition) {
   return definition;
 }
 function defineResourceTemplate(definition) {
+  if ("paramSchema" in definition && definition.paramSchema !== undefined) {
+    const { paramSchema, handler: typedHandler, ...rest } = definition;
+    const wrappedHandler = async (uri, variables, ctx) => {
+      const parseResult = paramSchema.safeParse(variables);
+      if (!parseResult.success) {
+        const errorMessages = formatZodIssues(parseResult.error.issues);
+        return Result.err(new ValidationError({
+          message: `Invalid resource parameters: ${errorMessages}`,
+          field: "params"
+        }));
+      }
+      return typedHandler(uri, parseResult.data, ctx);
+    };
+    return { ...rest, handler: wrappedHandler };
+  }
   return definition;
 }
 function definePrompt(definition) {

package/dist/shared/@outfitter/mcp-zt2s3r38.js

@@ -0,0 +1,33 @@
+// @bun
+// packages/mcp/src/internal/uri-template.ts
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function matchUriTemplate(template, uri) {
+  const paramNames = [];
+  const parts = template.split(/(\{[^}]+\})/);
+  const regexSource = parts.map((part) => {
+    const paramMatch = part.match(/^\{([^}]+)\}$/);
+    if (paramMatch?.[1]) {
+      paramNames.push(paramMatch[1]);
+      return "([^/]+)";
+    }
+    return escapeRegex(part);
+  }).join("");
+  const regex = new RegExp(`^${regexSource}$`);
+  const match = uri.match(regex);
+  if (!match) {
+    return null;
+  }
+  const variables = {};
+  for (let i = 0;i < paramNames.length; i++) {
+    const name = paramNames[i];
+    const value = match[i + 1];
+    if (name !== undefined && value !== undefined) {
+      variables[name] = value;
+    }
+  }
+  return variables;
+}
+
+export { matchUriTemplate };

package/dist/transport.d.ts

@@ -1,4 +1,9 @@
-import { McpToolResponse, connectStdio, createSdkServer, wrapToolError, wrapToolResult } from "./shared/@outfitter/mcp-s3gfhcdk.js";
-import "./shared/@outfitter/mcp-fks4zt1z.js";
+import { McpToolResponse, connectStdio, createSdkServer, wrapToolError, wrapToolResult } from "./shared/@outfitter/mcp-yf0w5cgh.js";
+import "./shared/@outfitter/mcp-qmdmgxa1.js";
+import "./shared/@outfitter/mcp-7btcghjj.js";
+import "./shared/@outfitter/mcp-knc1gq0g.js";
+import "./shared/@outfitter/mcp-9ry52yg3.js";
+import "./shared/@outfitter/mcp-dgwj3jna.js";
+import "./shared/@outfitter/mcp-q5hr7227.js";
 import "./shared/@outfitter/mcp-cqpyer9m.js";
 export { wrapToolResult, wrapToolError, createSdkServer, connectStdio, McpToolResponse };

package/dist/transport.js

@@ -1,10 +1,166 @@
 // @bun
+// packages/mcp/src/transport.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
-  connectStdio,
-  createSdkServer,
-  wrapToolError,
-  wrapToolResult
-} from "./shared/@outfitter/mcp-mzky3ck8.js";
+  CallToolRequestSchema,
+  CompleteRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+  McpError as SdkMcpError,
+  SetLevelRequestSchema,
+  SubscribeRequestSchema,
+  UnsubscribeRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { safeStringify } from "@outfitter/contracts";
+function isMcpToolResponse(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const content = value.content;
+  return Array.isArray(content);
+}
+function toTextPayload(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  return safeStringify(value);
+}
+function serializeError(error) {
+  if (error && typeof error === "object") {
+    const record = error;
+    return {
+      _tag: record._tag ?? "McpError",
+      message: record.message ?? "Unknown error",
+      code: record.code,
+      context: record.context
+    };
+  }
+  return {
+    _tag: "McpError",
+    message: String(error)
+  };
+}
+function wrapToolResult(value) {
+  if (isMcpToolResponse(value)) {
+    return value;
+  }
+  const structuredContent = value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+  return {
+    content: [
+      {
+        type: "text",
+        text: toTextPayload(value)
+      }
+    ],
+    ...structuredContent ? { structuredContent } : {}
+  };
+}
+function wrapToolError(error) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: toTextPayload(serializeError(error))
+      }
+    ],
+    isError: true
+  };
+}
+function toSdkError(error) {
+  return new SdkMcpError(error.code, error.message, error.context);
+}
+function createSdkServer(server) {
+  const capabilities = {
+    tools: { listChanged: true },
+    resources: { listChanged: true, subscribe: true },
+    prompts: { listChanged: true },
+    completions: {},
+    logging: {}
+  };
+  const sdkServer = new Server({ name: server.name, version: server.version }, { capabilities });
+  sdkServer.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: server.getTools()
+  }));
+  sdkServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const progressToken = request.params._meta?.progressToken;
+    const options = progressToken !== undefined ? { progressToken } : undefined;
+    const result = await server.invokeTool(name, args ?? {}, options);
+    if (result.isErr()) {
+      return wrapToolError(result.error);
+    }
+    return wrapToolResult(result.value);
+  });
+  sdkServer.setRequestHandler(ListResourcesRequestSchema, async () => ({
+    resources: server.getResources().map((r) => ({
+      uri: r.uri,
+      name: r.name,
+      ...r.description ? { description: r.description } : {},
+      ...r.mimeType ? { mimeType: r.mimeType } : {}
+    }))
+  }));
+  sdkServer.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates: server.getResourceTemplates().map((t) => ({
+      uriTemplate: t.uriTemplate,
+      name: t.name,
+      ...t.description ? { description: t.description } : {},
+      ...t.mimeType ? { mimeType: t.mimeType } : {}
+    }))
+  }));
+  sdkServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const result = await server.readResource(uri);
+    if (result.isErr()) {
+      throw toSdkError(result.error);
+    }
+    return { contents: result.value };
+  });
+  sdkServer.setRequestHandler(SubscribeRequestSchema, async (request) => {
+    server.subscribe(request.params.uri);
+    return {};
+  });
+  sdkServer.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
+    server.unsubscribe(request.params.uri);
+    return {};
+  });
+  sdkServer.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: server.getPrompts()
+  }));
+  sdkServer.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const result = await server.getPrompt(name, args ?? {});
+    if (result.isErr()) {
+      throw toSdkError(result.error);
+    }
+    return { ...result.value };
+  });
+  sdkServer.setRequestHandler(CompleteRequestSchema, async (request) => {
+    const { ref, argument } = request.params;
+    const completionRef = ref.type === "ref/prompt" ? { type: "ref/prompt", name: ref.name } : { type: "ref/resource", uri: ref.uri };
+    const result = await server.complete(completionRef, argument.name, argument.value);
+    if (result.isErr()) {
+      throw toSdkError(result.error);
+    }
+    return { completion: result.value };
+  });
+  sdkServer.setRequestHandler(SetLevelRequestSchema, async (request) => {
+    const level = request.params.level;
+    server.setLogLevel?.(level);
+    return {};
+  });
+  server.bindSdkServer?.(sdkServer);
+  return sdkServer;
+}
+async function connectStdio(server, transport = new StdioServerTransport) {
+  const sdkServer = createSdkServer(server);
+  await sdkServer.connect(transport);
+  return sdkServer;
+}
 export {
   wrapToolResult,
   wrapToolError,

package/dist/types.d.ts

@@ -1,3 +1,8 @@
-import { BlobResourceContent, CompletionHandler, CompletionRef, CompletionResult, ContentAnnotations, InvokeToolOptions, McpError, McpHandlerContext, McpServer, McpServerOptions, ProgressReporter, PromptArgument, PromptDefinition, PromptHandler, PromptMessage, PromptMessageContent, PromptResult, ResourceContent, ResourceDefinition, ResourceReadHandler, ResourceTemplateDefinition, ResourceTemplateReadHandler, Result, SerializedTool, TOOL_ANNOTATIONS, TaggedError, TextResourceContent, ToolAnnotations, ToolDefinition, adaptHandler } from "./shared/@outfitter/mcp-fks4zt1z.js";
+import "./shared/@outfitter/mcp-qmdmgxa1.js";
+import { InvokeToolOptions, McpError, McpHandlerContext, McpServer, McpServerOptions, ProgressReporter, Result, TaggedError, adaptHandler } from "./shared/@outfitter/mcp-7btcghjj.js";
+import { SerializedTool, TOOL_ANNOTATIONS, ToolAnnotations, ToolDefinition } from "./shared/@outfitter/mcp-knc1gq0g.js";
+import { BlobResourceContent, ResourceContent, ResourceDefinition, ResourceReadHandler, ResourceTemplateDefinition, ResourceTemplateReadHandler, TextResourceContent, TypedResourceTemplateDefinition, TypedResourceTemplateReadHandler } from "./shared/@outfitter/mcp-9ry52yg3.js";
+import { CompletionHandler, CompletionRef, CompletionResult, PromptArgument, PromptDefinition, PromptHandler, PromptMessage, PromptMessageContent, PromptResult } from "./shared/@outfitter/mcp-dgwj3jna.js";
+import { ContentAnnotations } from "./shared/@outfitter/mcp-q5hr7227.js";
 import "./shared/@outfitter/mcp-cqpyer9m.js";
-export { adaptHandler, ToolDefinition, ToolAnnotations, TextResourceContent, TaggedError, TOOL_ANNOTATIONS, SerializedTool, Result, ResourceTemplateReadHandler, ResourceTemplateDefinition, ResourceReadHandler, ResourceDefinition, ResourceContent, PromptResult, PromptMessageContent, PromptMessage, PromptHandler, PromptDefinition, PromptArgument, ProgressReporter, McpServerOptions, McpServer, McpHandlerContext, McpError, InvokeToolOptions, ContentAnnotations, CompletionResult, CompletionRef, CompletionHandler, BlobResourceContent };
+export { adaptHandler, TypedResourceTemplateReadHandler, TypedResourceTemplateDefinition, ToolDefinition, ToolAnnotations, TextResourceContent, TaggedError, TOOL_ANNOTATIONS, SerializedTool, Result, ResourceTemplateReadHandler, ResourceTemplateDefinition, ResourceReadHandler, ResourceDefinition, ResourceContent, PromptResult, PromptMessageContent, PromptMessage, PromptHandler, PromptDefinition, PromptArgument, ProgressReporter, McpServerOptions, McpServer, McpHandlerContext, McpError, InvokeToolOptions, ContentAnnotations, CompletionResult, CompletionRef, CompletionHandler, BlobResourceContent };

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   TOOL_ANNOTATIONS,
   TaggedError,
   adaptHandler
-} from "./shared/@outfitter/mcp-9m5hs2z0.js";
+} from "./shared/@outfitter/mcp-s2vnhzav.js";
 export {
   adaptHandler,
   TaggedError,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@outfitter/mcp",
   "description": "MCP server framework with typed tools for Outfitter",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "type": "module",
   "files": [
     "dist"
@@ -34,6 +34,12 @@
       }
     },
     "./package.json": "./package.json",
+    "./progress": {
+      "import": {
+        "types": "./dist/progress.d.ts",
+        "default": "./dist/progress.js"
+      }
+    },
     "./schema": {
       "import": {
         "types": "./dist/schema.d.ts",
@@ -59,11 +65,27 @@
       }
     }
   },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "outfitter",
+    "tools",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/outfitter-dev/outfitter.git",
+    "directory": "packages/mcp"
+  },
   "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build": "bunup --filter @outfitter/mcp",
-    "lint": "biome lint ./src",
-    "lint:fix": "biome lint --write ./src",
+    "build": "cd ../.. && bash ./scripts/run-bunup-with-lock.sh bunup --filter @outfitter/mcp",
+    "lint": "oxlint ./src",
+    "lint:fix": "oxlint --fix ./src",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
@@ -73,32 +95,16 @@
     "@modelcontextprotocol/sdk": "^1.12.1",
     "zod": "^4.3.5"
   },
+  "devDependencies": {
+    "@outfitter/config": "0.4.0",
+    "@outfitter/contracts": "0.5.0",
+    "@outfitter/logging": "0.4.3",
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.9.3"
+  },
   "peerDependencies": {
     "@outfitter/config": ">=0.3.0",
     "@outfitter/contracts": ">=0.2.0",
     "@outfitter/logging": ">=0.3.0"
-  },
-  "devDependencies": {
-    "@outfitter/config": "0.3.3",
-    "@outfitter/contracts": "0.4.1",
-    "@outfitter/logging": "0.4.1",
-    "@types/bun": "latest",
-    "typescript": "^5.8.0"
-  },
-  "keywords": [
-    "outfitter",
-    "mcp",
-    "model-context-protocol",
-    "tools",
-    "typescript"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/outfitter-dev/outfitter.git",
-    "directory": "packages/mcp"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }