@outfitter/mcp 0.4.3 → 0.5.0

package/dist/shared/@outfitter/mcp-knc1gq0g.d.ts

@@ -0,0 +1,130 @@
+import { Handler, OutfitterError } from "@outfitter/contracts";
+import { z } from "zod";
+/**
+* Behavioral hints for MCP tools.
+*
+* Annotations help clients understand tool behavior without invoking them.
+* All fields are optional — only include hints that apply.
+*
+* @see https://spec.modelcontextprotocol.io/specification/2025-03-26/server/tools/#annotations
+*/
+interface ToolAnnotations {
+	/** When true, the tool may perform destructive operations (e.g., deleting data). */
+	destructiveHint?: boolean;
+	/** When true, calling the tool multiple times with the same input has the same effect. */
+	idempotentHint?: boolean;
+	/** When true, the tool may interact with external systems beyond the server. */
+	openWorldHint?: boolean;
+	/** When true, the tool does not modify any state. */
+	readOnlyHint?: boolean;
+}
+/**
+* Common annotation presets for MCP tools.
+*
+* Use these as a starting point and spread-override individual hints:
+*
+* ```typescript
+* annotations: { ...TOOL_ANNOTATIONS.readOnly, openWorldHint: true }
+* ```
+*
+* For multi-action tools (e.g., a single tool with read and write actions),
+* use the most conservative union of hints — if any action is destructive,
+* mark the whole tool as destructive. Per-action annotations are an MCP spec
+* limitation; presets + spread cover most edge cases.
+*/
+declare const TOOL_ANNOTATIONS: {
+	readonly destructive: ToolAnnotations;
+	readonly openWorld: ToolAnnotations;
+	readonly readOnly: ToolAnnotations;
+	readonly write: ToolAnnotations;
+	readonly writeIdempotent: ToolAnnotations;
+};
+/**
+* Definition of an MCP tool that can be invoked by clients.
+*
+* Tools are the primary way clients interact with MCP servers.
+* Each tool has a name, description, input schema (for validation),
+* and a handler function that processes requests.
+*
+* @typeParam TInput - The validated input type (inferred from Zod schema)
+* @typeParam TOutput - The success output type
+* @typeParam TError - The error type (must extend OutfitterError)
+*
+* @example
+* ```typescript
+* const getUserTool: ToolDefinition<
+*   { userId: string },
+*   { name: string; email: string },
+*   NotFoundError
+* > = {
+*   name: "get-user",
+*   description: "Retrieve a user by ID",
+*   inputSchema: z.object({ userId: z.string().uuid() }),
+*   handler: async (input, ctx) => {
+*     ctx.logger.debug("Fetching user", { userId: input.userId });
+*     const user = await db.users.find(input.userId);
+*     if (!user) {
+*       return Result.err(new NotFoundError({
+*         message: `User ${input.userId} not found`,
+*         resourceType: "user",
+*         resourceId: input.userId,
+*       }));
+*     }
+*     return Result.ok({ name: user.name, email: user.email });
+*   },
+* };
+* ```
+*/
+interface ToolDefinition<
+	TInput,
+	TOutput,
+	TError extends OutfitterError = OutfitterError
+> {
+	/**
+	* Optional behavioral annotations for the tool.
+	* Helps clients understand tool behavior without invoking it.
+	*/
+	annotations?: ToolAnnotations;
+	/**
+	* Whether the tool should be deferred for tool search.
+	* Defaults to true for domain tools; core tools set this to false.
+	*/
+	deferLoading?: boolean;
+	/**
+	* Human-readable description of what the tool does.
+	* Shown to clients and used by LLMs to understand tool capabilities.
+	*/
+	description: string;
+	/**
+	* Handler function that processes the tool invocation.
+	* Receives validated input and HandlerContext, returns Result.
+	*/
+	handler: Handler<TInput, TOutput, TError>;
+	/**
+	* Zod schema for validating and parsing input.
+	* The schema defines the expected input structure.
+	*/
+	inputSchema: z.ZodType<TInput>;
+	/**
+	* Unique tool name (kebab-case recommended).
+	* Used by clients to invoke the tool.
+	*/
+	name: string;
+}
+/**
+* Serialized tool information for MCP protocol.
+* This is the format sent to clients during tool listing.
+*/
+interface SerializedTool {
+	/** Behavioral annotations for the tool */
+	annotations?: ToolAnnotations;
+	/** MCP tool-search hint: whether tool is deferred */
+	defer_loading?: boolean;
+	/** Tool description */
+	description: string;
+	/** JSON Schema representation of the input schema */
+	inputSchema: Record<string, unknown>;
+	/** Tool name */
+	name: string;
+}
+export { ToolAnnotations, TOOL_ANNOTATIONS, ToolDefinition, SerializedTool };

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

@@ -0,0 +1,55 @@
+// @bun
+// packages/mcp/src/internal/log-config.ts
+import { getEnvironment, getEnvironmentDefaults } from "@outfitter/config";
+import { 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;
+}
+
+export { VALID_MCP_LOG_LEVELS, DEFAULTS_TO_MCP, createDefaultMcpSink, resolveDefaultLogLevel };

package/dist/shared/@outfitter/mcp-q5hr7227.d.ts

@@ -0,0 +1,24 @@
+/**
+* Shared content type definitions used across prompt and resource types.
+*
+* @internal
+*/
+/**
+* Annotations for content items (resource content, prompt messages).
+*
+* Provides hints about content audience and priority.
+*
+* @see https://spec.modelcontextprotocol.io/specification/2025-03-26/server/utilities/annotations/
+*/
+interface ContentAnnotations {
+	/**
+	* Who the content is intended for.
+	* Can include "user", "assistant", or both.
+	*/
+	audience?: Array<"user" | "assistant">;
+	/**
+	* Priority level from 0.0 (least) to 1.0 (most important).
+	*/
+	priority?: number;
+}
+export { ContentAnnotations };

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

@@ -0,0 +1,53 @@
+// @bun
+// packages/mcp/src/progress.ts
+function mapStreamEventToNotification(token, event, latestProgress) {
+  switch (event.type) {
+    case "start": {
+      return {
+        method: "notifications/progress",
+        params: {
+          progressToken: token,
+          progress: latestProgress,
+          message: `[start] ${event.command}`
+        }
+      };
+    }
+    case "step": {
+      const durationSuffix = event.duration_ms !== undefined ? ` (${event.duration_ms}ms)` : "";
+      return {
+        method: "notifications/progress",
+        params: {
+          progressToken: token,
+          progress: latestProgress,
+          message: `[step] ${event.name}: ${event.status}${durationSuffix}`
+        }
+      };
+    }
+    case "progress": {
+      const params = {
+        progressToken: token,
+        progress: event.current,
+        total: event.total
+      };
+      if (event.message !== undefined) {
+        params.message = event.message;
+      }
+      return {
+        method: "notifications/progress",
+        params
+      };
+    }
+  }
+}
+function createMcpProgressCallback(progressToken, send) {
+  let latestProgress = 0;
+  return (event) => {
+    if (event.type === "progress") {
+      latestProgress = event.current;
+    }
+    const notification = mapStreamEventToNotification(progressToken, event, latestProgress);
+    send(notification);
+  };
+}
+
+export { createMcpProgressCallback };

package/dist/shared/@outfitter/mcp-r27vbpc1.d.ts

@@ -0,0 +1,45 @@
+import { ProgressCallback } from "@outfitter/contracts/stream";
+/**
+* Function signature for sending a raw MCP notification.
+*
+* Matches the `sdkServer.notification()` method shape from the MCP SDK.
+*/
+type McpNotificationSender = (notification: unknown) => void;
+/**
+* MCP progress notification payload matching the MCP specification.
+*
+* @see https://spec.modelcontextprotocol.io/specification/2025-03-26/server/utilities/progress/
+*/
+interface McpProgressNotification {
+	method: "notifications/progress";
+	params: {
+		progressToken: string | number;
+		progress: number;
+		total?: number;
+		message?: string;
+	};
+}
+/**
+* Create a {@link ProgressCallback} that emits MCP `notifications/progress`.
+*
+* Each call to the returned callback translates a {@link StreamEvent} into
+* an MCP progress notification and sends it via the provided sender function.
+*
+* @param progressToken - The progress token from the MCP client request
+* @param send - Function to send the raw MCP notification (typically `sdkServer.notification`)
+* @returns A `ProgressCallback` compatible with `ctx.progress`
+*
+* @example
+* ```typescript
+* const progress = createMcpProgressCallback(
+*   "tok-123",
+*   (n) => sdkServer.notification(n)
+* );
+*
+* // In handler:
+* ctx.progress?.({ type: "start", command: "deploy", ts: new Date().toISOString() });
+* ctx.progress?.({ type: "progress", current: 5, total: 10 });
+* ```
+*/
+declare function createMcpProgressCallback(progressToken: string | number, send: McpNotificationSender): ProgressCallback;
+export { McpNotificationSender, McpProgressNotification, createMcpProgressCallback };

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

@@ -0,0 +1,2 @@
+export { adaptHandler, McpError, TaggedError } from "../../internal/server-types.js";
+export { TOOL_ANNOTATIONS } from "../../internal/tool-types.js";

package/dist/shared/@outfitter/{mcp-7kcw2814.d.ts → mcp-yf0w5cgh.d.ts}

@@ -1,4 +1,4 @@
-import { McpServer } from "./mcp-gqjg15f5.js";
+import { McpServer } from "./mcp-7btcghjj.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";

package/dist/shared/@outfitter/{mcp-b502y16n.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 {
   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-7kcw2814.js";
-import "./shared/@outfitter/mcp-gqjg15f5.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/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-gqjg15f5.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,