@outfitter/mcp 0.2.0 → 0.4.0

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

@@ -0,0 +1,165 @@
+// @bun
+// packages/mcp/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 { wrapToolResult, wrapToolError, createSdkServer, connectStdio };

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+/**
+* JSON Schema representation.
+*/
+interface JsonSchema {
+	type?: string;
+	properties?: Record<string, JsonSchema>;
+	required?: string[];
+	items?: JsonSchema | JsonSchema[];
+	description?: string;
+	default?: unknown;
+	minimum?: number;
+	maximum?: number;
+	exclusiveMinimum?: number;
+	exclusiveMaximum?: number;
+	minLength?: number;
+	maxLength?: number;
+	pattern?: string;
+	format?: string;
+	enum?: unknown[];
+	const?: unknown;
+	anyOf?: JsonSchema[];
+	oneOf?: JsonSchema[];
+	allOf?: JsonSchema[];
+	not?: JsonSchema | Record<string, never>;
+	$ref?: string;
+	$schema?: string;
+	$defs?: Record<string, JsonSchema>;
+	definitions?: Record<string, JsonSchema>;
+	additionalProperties?: boolean | JsonSchema;
+}
+/**
+* Convert a Zod schema to JSON Schema format.
+*
+* This is a simplified converter that handles common Zod types.
+* For complex schemas, consider using a full zod-to-json-schema library.
+*
+* @param schema - Zod schema to convert
+* @returns JSON Schema representation
+*
+* @example
+* ```typescript
+* const zodSchema = z.object({
+*   name: z.string(),
+*   age: z.number().optional(),
+* });
+*
+* const jsonSchema = zodToJsonSchema(zodSchema);
+* // {
+* //   type: "object",
+* //   properties: {
+* //     name: { type: "string" },
+* //     age: { type: "number" },
+* //   },
+* //   required: ["name"],
+* // }
+* ```
+*/
+declare function zodToJsonSchema(schema: z.ZodType<unknown>): JsonSchema;
+export { JsonSchema, zodToJsonSchema };

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

@@ -0,0 +1,143 @@
+// @bun
+// packages/mcp/src/core-tools.ts
+import { Result, 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 Result.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 Result.ok({ action: "list", config });
+        }
+        case "get": {
+          if (!input.key) {
+            return Result.err(new ValidationError({
+              message: "Config key is required for action 'get'.",
+              field: "key"
+            }));
+          }
+          const { value, found } = await store.get(input.key);
+          return Result.ok({ action: "get", key: input.key, value, found });
+        }
+        case "set": {
+          if (!input.key) {
+            return Result.err(new ValidationError({
+              message: "Config key is required for action 'set'.",
+              field: "key"
+            }));
+          }
+          await store.set(input.key, input.value);
+          return Result.ok({
+            action: "set",
+            key: input.key,
+            value: input.value
+          });
+        }
+        default:
+          return Result.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(Result.ok({
+        results: [],
+        _meta: {
+          note: "No query handler configured."
+        }
+      }));
+    }
+  };
+}
+function createCoreTools(options = {}) {
+  return [
+    defineDocsTool(options.docs),
+    defineConfigTool(options.config),
+    defineQueryTool(options.query)
+  ];
+}
+
+export { defineDocsTool, defineConfigTool, defineQueryTool, createCoreTools };

package/dist/transport.d.ts

@@ -0,0 +1,4 @@
+import { McpToolResponse, connectStdio, createSdkServer, wrapToolError, wrapToolResult } from "./shared/@outfitter/mcp-jk0ka9hw";
+import "./shared/@outfitter/mcp-h2twz77x";
+import "./shared/@outfitter/mcp-cqpyer9m";
+export { wrapToolResult, wrapToolError, createSdkServer, connectStdio, McpToolResponse };

package/dist/transport.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  connectStdio,
+  createSdkServer,
+  wrapToolError,
+  wrapToolResult
+} from "./shared/@outfitter/mcp-mzky3ck8.js";
+export {
+  wrapToolResult,
+  wrapToolError,
+  createSdkServer,
+  connectStdio
+};

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+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-h2twz77x";
+import "./shared/@outfitter/mcp-cqpyer9m";
+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 };

package/dist/types.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  McpError,
+  TOOL_ANNOTATIONS,
+  TaggedError,
+  adaptHandler
+} from "./shared/@outfitter/mcp-9m5hs2z0.js";
+export {
+  adaptHandler,
+  TaggedError,
+  TOOL_ANNOTATIONS,
+  McpError
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@outfitter/mcp",
   "description": "MCP server framework with typed tools for Outfitter",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
   "files": [
     "dist"
@@ -15,10 +15,29 @@
         "default": "./dist/index.js"
       }
     },
-    "./types": {
+    "./actions": {
       "import": {
-        "types": "./dist/types.d.ts",
-        "default": "./dist/types.js"
+        "types": "./dist/actions.d.ts",
+        "default": "./dist/actions.js"
+      }
+    },
+    "./core-tools": {
+      "import": {
+        "types": "./dist/core-tools.d.ts",
+        "default": "./dist/core-tools.js"
+      }
+    },
+    "./logging": {
+      "import": {
+        "types": "./dist/logging.d.ts",
+        "default": "./dist/logging.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./schema": {
+      "import": {
+        "types": "./dist/schema.d.ts",
+        "default": "./dist/schema.js"
       }
     },
     "./server": {
@@ -27,7 +46,18 @@
         "default": "./dist/server.js"
       }
     },
-    "./package.json": "./package.json"
+    "./transport": {
+      "import": {
+        "types": "./dist/transport.d.ts",
+        "default": "./dist/transport.js"
+      }
+    },
+    "./types": {
+      "import": {
+        "types": "./dist/types.d.ts",
+        "default": "./dist/types.js"
+      }
+    }
   },
   "sideEffects": false,
   "scripts": {
@@ -40,11 +70,17 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@outfitter/contracts": "0.2.0",
-    "@outfitter/logging": "0.2.0",
     "zod": "^4.3.5"
   },
+  "peerDependencies": {
+    "@outfitter/config": ">=0.3.0",
+    "@outfitter/contracts": ">=0.2.0",
+    "@outfitter/logging": ">=0.3.0"
+  },
   "devDependencies": {
+    "@outfitter/config": "0.3.1",
+    "@outfitter/contracts": "0.3.0",
+    "@outfitter/logging": "0.4.0",
     "@types/bun": "latest",
     "typescript": "^5.8.0"
   },