@outfitter/mcp 0.4.2 → 0.5.0

package/dist/index.js

@@ -1,959 +1,8 @@
-// src/actions.ts
-import { DEFAULT_REGISTRY_SURFACES } from "@outfitter/contracts";
-
-// src/server.ts
-import { getEnvironment, getEnvironmentDefaults } from "@outfitter/config";
-import { generateRequestId, Result } from "@outfitter/contracts";
-import {
-  createOutfitterLoggerFactory,
-  createPrettyFormatter
-} from "@outfitter/logging";
-
-// src/logging.ts
-var MCP_LEVEL_ORDER = [
-  "debug",
-  "info",
-  "notice",
-  "warning",
-  "error",
-  "critical",
-  "alert",
-  "emergency"
-];
-function mapLogLevelToMcp(level) {
-  switch (level) {
-    case "trace":
-    case "debug":
-      return "debug";
-    case "info":
-      return "info";
-    case "warn":
-      return "warning";
-    case "error":
-      return "error";
-    case "fatal":
-      return "emergency";
-    default: {
-      const _exhaustiveCheck = level;
-      return _exhaustiveCheck;
-    }
-  }
-}
-function shouldEmitLog(messageLevel, threshold) {
-  return MCP_LEVEL_ORDER.indexOf(messageLevel) >= MCP_LEVEL_ORDER.indexOf(threshold);
-}
-
-// src/schema.ts
-import { zodToJsonSchema } from "@outfitter/contracts/schema";
-
-// src/types.ts
-import {
-  TaggedError as TaggedErrorImpl
-} from "@outfitter/contracts";
-import { TaggedError } from "@outfitter/contracts";
-var TaggedError2 = TaggedErrorImpl;
-var TOOL_ANNOTATIONS = {
-  readOnly: {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  write: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: false
-  },
-  writeIdempotent: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  destructive: {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: true,
-    openWorldHint: false
-  },
-  openWorld: {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: true
-  }
-};
-var McpErrorBase = TaggedError2("McpError")();
-
-class McpError extends McpErrorBase {
-  category = "internal";
-}
-function adaptHandler(handler) {
-  return handler;
-}
-
-// src/server.ts
-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;
-}
-function createMcpServer(options) {
-  const { name, version, logger: providedLogger } = options;
-  let loggerFactory = null;
-  const logger = providedLogger ?? (() => {
-    loggerFactory = createOutfitterLoggerFactory({
-      defaults: { sinks: [createDefaultMcpSink()] }
-    });
-    return loggerFactory.createLogger({
-      name: "mcp",
-      context: { serverName: name, serverVersion: version, surface: "mcp" }
-    });
-  })();
-  const tools = new Map;
-  const resources = new Map;
-  const resourceTemplates = new Map;
-  const prompts = new Map;
-  let sdkServer = null;
-  const subscriptions = new Set;
-  let clientLogLevel = resolveDefaultLogLevel(options);
-  function createHandlerContext(toolName, requestId, signal, progressToken) {
-    const ctx = {
-      requestId,
-      logger: logger.child({ tool: toolName, requestId }),
-      cwd: process.cwd(),
-      env: process.env
-    };
-    if (signal !== undefined) {
-      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 } : {}
-            }
-          });
-        }
-      };
-    }
-    return ctx;
-  }
-  function translateError(error) {
-    const codeMap = {
-      validation: -32602,
-      not_found: -32601,
-      permission: -32600,
-      internal: -32603,
-      timeout: -32603,
-      network: -32603,
-      rate_limit: -32603,
-      auth: -32600,
-      conflict: -32603,
-      cancelled: -32603
-    };
-    const code = codeMap[error.category] ?? -32603;
-    return new McpError({
-      message: error.message,
-      code,
-      context: {
-        originalTag: error._tag,
-        category: error.category
-      }
-    });
-  }
-  const server = {
-    name,
-    version,
-    registerTool(tool) {
-      logger.debug("Registering tool", { name: tool.name });
-      const description = tool.description?.trim() ?? "";
-      if (description.length < 8) {
-        logger.warn("Tool description may be too short for search discovery", {
-          name: tool.name,
-          description
-        });
-      }
-      const jsonSchema = zodToJsonSchema(tool.inputSchema);
-      const handler = (input, ctx) => tool.handler(input, ctx);
-      const deferLoading = tool.deferLoading ?? true;
-      const stored = {
-        name: tool.name,
-        description,
-        inputSchema: jsonSchema,
-        deferLoading,
-        handler,
-        zodSchema: tool.inputSchema
-      };
-      if (tool.annotations !== undefined) {
-        stored.annotations = tool.annotations;
-      }
-      tools.set(tool.name, stored);
-      logger.info("Tool registered", { name: tool.name });
-      if (sdkServer) {
-        sdkServer.sendToolListChanged?.();
-      }
-    },
-    registerResource(resource) {
-      logger.debug("Registering resource", {
-        uri: resource.uri,
-        name: resource.name
-      });
-      resources.set(resource.uri, resource);
-      logger.info("Resource registered", { uri: resource.uri });
-      if (sdkServer) {
-        sdkServer.sendResourceListChanged?.();
-      }
-    },
-    registerResourceTemplate(template) {
-      logger.debug("Registering resource template", {
-        uriTemplate: template.uriTemplate,
-        name: template.name
-      });
-      resourceTemplates.set(template.uriTemplate, template);
-      logger.info("Resource template registered", {
-        uriTemplate: template.uriTemplate
-      });
-      if (sdkServer) {
-        sdkServer.sendResourceListChanged?.();
-      }
-    },
-    getTools() {
-      return Array.from(tools.values()).map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        defer_loading: tool.deferLoading,
-        ...tool.annotations ? { annotations: tool.annotations } : {}
-      }));
-    },
-    getResources() {
-      return Array.from(resources.values());
-    },
-    getResourceTemplates() {
-      return Array.from(resourceTemplates.values());
-    },
-    async complete(ref, argumentName, value) {
-      if (ref.type === "ref/prompt") {
-        const prompt = prompts.get(ref.name);
-        if (!prompt) {
-          return Result.err(new McpError({
-            message: `Prompt not found: ${ref.name}`,
-            code: -32601,
-            context: { prompt: ref.name }
-          }));
-        }
-        const arg = prompt.arguments.find((a) => a.name === argumentName);
-        if (!arg?.complete) {
-          return Result.ok({ values: [] });
-        }
-        try {
-          const result = await arg.complete(value);
-          return Result.ok(result);
-        } catch (error) {
-          return Result.err(new McpError({
-            message: error instanceof Error ? error.message : "Unknown error",
-            code: -32603,
-            context: {
-              prompt: ref.name,
-              argument: argumentName,
-              thrown: true
-            }
-          }));
-        }
-      }
-      if (ref.type === "ref/resource") {
-        const template = resourceTemplates.get(ref.uri);
-        if (!template) {
-          return Result.err(new McpError({
-            message: `Resource template not found: ${ref.uri}`,
-            code: -32601,
-            context: { uri: ref.uri }
-          }));
-        }
-        const handler = template.complete?.[argumentName];
-        if (!handler) {
-          return Result.ok({ values: [] });
-        }
-        try {
-          const result = await handler(value);
-          return Result.ok(result);
-        } catch (error) {
-          return Result.err(new McpError({
-            message: error instanceof Error ? error.message : "Unknown error",
-            code: -32603,
-            context: { uri: ref.uri, argument: argumentName, thrown: true }
-          }));
-        }
-      }
-      return Result.err(new McpError({
-        message: "Invalid completion reference type",
-        code: -32602,
-        context: { ref }
-      }));
-    },
-    registerPrompt(prompt) {
-      logger.debug("Registering prompt", { name: prompt.name });
-      prompts.set(prompt.name, prompt);
-      logger.info("Prompt registered", { name: prompt.name });
-      if (sdkServer) {
-        sdkServer.sendPromptListChanged?.();
-      }
-    },
-    getPrompts() {
-      return Array.from(prompts.values()).map((p) => ({
-        name: p.name,
-        ...p.description ? { description: p.description } : {},
-        arguments: p.arguments
-      }));
-    },
-    async getPrompt(promptName, args) {
-      const prompt = prompts.get(promptName);
-      if (!prompt) {
-        return Result.err(new McpError({
-          message: `Prompt not found: ${promptName}`,
-          code: -32601,
-          context: { prompt: promptName }
-        }));
-      }
-      for (const arg of prompt.arguments) {
-        if (arg.required && (args[arg.name] === undefined || args[arg.name] === "")) {
-          return Result.err(new McpError({
-            message: `Missing required argument: ${arg.name}`,
-            code: -32602,
-            context: { prompt: promptName, argument: arg.name }
-          }));
-        }
-      }
-      try {
-        const result = await prompt.handler(args);
-        if (result.isErr()) {
-          return Result.err(translateError(result.error));
-        }
-        return Result.ok(result.value);
-      } catch (error) {
-        return Result.err(new McpError({
-          message: error instanceof Error ? error.message : "Unknown error",
-          code: -32603,
-          context: { prompt: promptName, thrown: true }
-        }));
-      }
-    },
-    async readResource(uri) {
-      const resource = resources.get(uri);
-      if (resource) {
-        if (!resource.handler) {
-          return Result.err(new McpError({
-            message: `Resource not readable: ${uri}`,
-            code: -32002,
-            context: { uri }
-          }));
-        }
-        const requestId = generateRequestId();
-        const ctx = {
-          requestId,
-          logger: logger.child({ resource: uri, requestId }),
-          cwd: process.cwd(),
-          env: process.env
-        };
-        try {
-          const result = await resource.handler(uri, ctx);
-          if (result.isErr()) {
-            return Result.err(translateError(result.error));
-          }
-          return Result.ok(result.value);
-        } catch (error) {
-          return Result.err(new McpError({
-            message: error instanceof Error ? error.message : "Unknown error",
-            code: -32603,
-            context: { uri, thrown: true }
-          }));
-        }
-      }
-      for (const template of resourceTemplates.values()) {
-        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
-          };
-          try {
-            const result = await template.handler(uri, variables, templateCtx);
-            if (result.isErr()) {
-              return Result.err(translateError(result.error));
-            }
-            return Result.ok(result.value);
-          } catch (error) {
-            return Result.err(new McpError({
-              message: error instanceof Error ? error.message : "Unknown error",
-              code: -32603,
-              context: { uri, thrown: true }
-            }));
-          }
-        }
-      }
-      return Result.err(new McpError({
-        message: `Resource not found: ${uri}`,
-        code: -32002,
-        context: { uri }
-      }));
-    },
-    async invokeTool(toolName, input, invokeOptions) {
-      const requestId = invokeOptions?.requestId ?? generateRequestId();
-      logger.debug("Invoking tool", { tool: toolName, requestId });
-      const tool = tools.get(toolName);
-      if (!tool) {
-        logger.warn("Tool not found", { tool: toolName, requestId });
-        return Result.err(new McpError({
-          message: `Tool not found: ${toolName}`,
-          code: -32601,
-          context: { tool: toolName }
-        }));
-      }
-      const parseResult = tool.zodSchema.safeParse(input);
-      if (!parseResult.success) {
-        const errorMessages = parseResult.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
-        logger.warn("Input validation failed", {
-          tool: toolName,
-          requestId,
-          errors: errorMessages
-        });
-        return Result.err(new McpError({
-          message: `Invalid input: ${errorMessages}`,
-          code: -32602,
-          context: {
-            tool: toolName,
-            validationErrors: parseResult.error.issues
-          }
-        }));
-      }
-      const ctx = createHandlerContext(toolName, requestId, invokeOptions?.signal, invokeOptions?.progressToken);
-      try {
-        const result = await tool.handler(parseResult.data, ctx);
-        if (result.isErr()) {
-          logger.debug("Tool returned error", {
-            tool: toolName,
-            requestId,
-            error: result.error._tag
-          });
-          return Result.err(translateError(result.error));
-        }
-        logger.debug("Tool completed successfully", {
-          tool: toolName,
-          requestId
-        });
-        return Result.ok(result.value);
-      } catch (error) {
-        logger.error("Tool threw exception", {
-          tool: toolName,
-          requestId,
-          error: error instanceof Error ? error.message : String(error)
-        });
-        return Result.err(new McpError({
-          message: error instanceof Error ? error.message : "Unknown error",
-          code: -32603,
-          context: {
-            tool: toolName,
-            thrown: true
-          }
-        }));
-      }
-    },
-    subscribe(uri) {
-      subscriptions.add(uri);
-      logger.debug("Resource subscription added", { uri });
-    },
-    unsubscribe(uri) {
-      subscriptions.delete(uri);
-      logger.debug("Resource subscription removed", { uri });
-    },
-    notifyResourceUpdated(uri) {
-      if (subscriptions.has(uri)) {
-        sdkServer?.sendResourceUpdated?.({ uri });
-      }
-    },
-    notifyToolsChanged() {
-      sdkServer?.sendToolListChanged?.();
-    },
-    notifyResourcesChanged() {
-      sdkServer?.sendResourceListChanged?.();
-    },
-    notifyPromptsChanged() {
-      sdkServer?.sendPromptListChanged?.();
-    },
-    setLogLevel(level) {
-      clientLogLevel = level;
-      logger.debug("Client log level set", { level });
-    },
-    sendLogMessage(level, data, loggerName) {
-      if (!sdkServer || clientLogLevel === null || !shouldEmitLog(level, clientLogLevel)) {
-        return;
-      }
-      const params = {
-        level,
-        data
-      };
-      if (loggerName !== undefined) {
-        params.logger = loggerName;
-      }
-      sdkServer.sendLoggingMessage?.(params);
-    },
-    bindSdkServer(server2) {
-      sdkServer = server2;
-      clientLogLevel = resolveDefaultLogLevel(options);
-      logger.debug("SDK server bound for notifications");
-    },
-    async start() {
-      logger.info("MCP server starting", { name, version, tools: tools.size });
-    },
-    async stop() {
-      logger.info("MCP server stopping", { name, version });
-      if (loggerFactory !== null) {
-        await loggerFactory.flush();
-      }
-    }
-  };
-  return server;
-}
-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) {
-  return definition;
-}
-function definePrompt(definition) {
-  return definition;
-}
-
-// src/actions.ts
-function isActionRegistry(source) {
-  return "list" in source;
-}
-function buildMcpTools(source, options = {}) {
-  const actions = isActionRegistry(source) ? source.list() : source;
-  const includeSurfaces = options.includeSurfaces ?? [
-    "mcp"
-  ];
-  return actions.filter((action) => {
-    const surfaces = action.surfaces ?? DEFAULT_REGISTRY_SURFACES;
-    return surfaces.some((surface) => includeSurfaces.includes(surface));
-  }).map((action) => defineTool({
-    name: action.mcp?.tool ?? action.id,
-    description: action.mcp?.description ?? action.description ?? action.id,
-    inputSchema: action.input,
-    handler: async (input, ctx) => action.handler(input, ctx),
-    ...action.mcp?.deferLoading !== undefined ? { deferLoading: action.mcp.deferLoading } : {}
-  }));
-}
-// src/core-tools.ts
-import { Result as Result2, ValidationError } from "@outfitter/contracts";
-import { z } from "zod";
-var DEFAULT_DOCS = {
-  overview: "No documentation configured yet.",
-  tools: [],
-  examples: [],
-  schemas: {}
-};
-var docsSchema = z.object({
-  section: z.enum(["overview", "tools", "examples", "schemas"]).optional()
-});
-function pickDocsSection(payload, section) {
-  if (!section) {
-    return payload;
-  }
-  return {
-    [section]: payload[section]
-  };
-}
-function defineDocsTool(options = {}) {
-  return {
-    name: "docs",
-    description: options.description ?? "Documentation, usage patterns, and examples for this MCP server.",
-    deferLoading: false,
-    inputSchema: docsSchema,
-    handler: async (input) => {
-      const payload = options.getDocs ? await options.getDocs(input.section) : options.docs ?? DEFAULT_DOCS;
-      return Result2.ok(pickDocsSection(payload, input.section));
-    }
-  };
-}
-var configSchema = z.object({
-  action: z.enum(["get", "set", "list"]),
-  key: z.string().optional(),
-  value: z.unknown().optional()
-});
-function createInMemoryStore(initial = {}) {
-  const store = new Map(Object.entries(initial));
-  return {
-    get(key) {
-      return { value: store.get(key), found: store.has(key) };
-    },
-    set(key, value) {
-      store.set(key, value);
-    },
-    list() {
-      return Object.fromEntries(store.entries());
-    }
-  };
-}
-function defineConfigTool(options = {}) {
-  const store = options.store ?? createInMemoryStore(options.initial);
-  return {
-    name: "config",
-    description: options.description ?? "Read or modify server configuration values.",
-    deferLoading: false,
-    inputSchema: configSchema,
-    handler: async (input) => {
-      switch (input.action) {
-        case "list": {
-          const config = await store.list();
-          return Result2.ok({ action: "list", config });
-        }
-        case "get": {
-          if (!input.key) {
-            return Result2.err(new ValidationError({
-              message: "Config key is required for action 'get'.",
-              field: "key"
-            }));
-          }
-          const { value, found } = await store.get(input.key);
-          return Result2.ok({ action: "get", key: input.key, value, found });
-        }
-        case "set": {
-          if (!input.key) {
-            return Result2.err(new ValidationError({
-              message: "Config key is required for action 'set'.",
-              field: "key"
-            }));
-          }
-          await store.set(input.key, input.value);
-          return Result2.ok({
-            action: "set",
-            key: input.key,
-            value: input.value
-          });
-        }
-        default:
-          return Result2.err(new ValidationError({
-            message: `Unknown action: ${input.action}`,
-            field: "action"
-          }));
-      }
-    }
-  };
-}
-var querySchema = z.object({
-  q: z.string().min(1).describe("Search query. Supports natural language or filter syntax.").optional(),
-  query: z.string().min(1).describe("Alias for q. Supports natural language or filter syntax.").optional(),
-  limit: z.number().int().positive().optional(),
-  cursor: z.string().optional(),
-  filters: z.record(z.string(), z.unknown()).optional()
-}).refine((value) => {
-  const queryValue = (value.q ?? value.query)?.trim();
-  return typeof queryValue === "string" && queryValue.length > 0;
-}, {
-  message: "Query is required.",
-  path: ["q"]
-});
-function defineQueryTool(options = {}) {
-  return {
-    name: "query",
-    description: options.description ?? "Search and discover resources with filters and pagination.",
-    deferLoading: false,
-    inputSchema: querySchema,
-    handler: (input, ctx) => {
-      const normalized = {
-        ...input,
-        q: (input.q ?? input.query ?? "").trim()
-      };
-      if (options.handler) {
-        return options.handler(normalized, ctx);
-      }
-      return Promise.resolve(Result2.ok({
-        results: [],
-        _meta: {
-          note: "No query handler configured."
-        }
-      }));
-    }
-  };
-}
-function createCoreTools(options = {}) {
-  return [
-    defineDocsTool(options.docs),
-    defineConfigTool(options.config),
-    defineQueryTool(options.query)
-  ];
-}
-// src/transport.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  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 {
-  zodToJsonSchema,
-  wrapToolResult,
-  wrapToolError,
-  shouldEmitLog,
-  mapLogLevelToMcp,
-  defineTool,
-  defineResourceTemplate,
-  defineResource,
-  defineQueryTool,
-  definePrompt,
-  defineDocsTool,
-  defineConfigTool,
-  createSdkServer,
-  createMcpServer,
-  createCoreTools,
-  connectStdio,
-  buildMcpTools,
-  adaptHandler,
-  TOOL_ANNOTATIONS,
-  McpError
-};
+export { buildMcpTools } from "./actions.js";
+export { createCoreTools, defineConfigTool, defineDocsTool, defineQueryTool } from "./core-tools.js";
+export { mapLogLevelToMcp, shouldEmitLog } from "./logging.js";
+export { createMcpProgressCallback } from "./progress.js";
+export { zodToJsonSchema } from "./schema.js";
+export { createMcpServer, definePrompt, defineResource, defineResourceTemplate, defineTool } from "./server.js";
+export { connectStdio, createSdkServer, wrapToolError, wrapToolResult } from "./transport.js";
+export { adaptHandler, McpError, TOOL_ANNOTATIONS } from "./types.js";