@adhd/apigen-plugin-mcp 0.1.0

package/lib/generate.d.ts

@@ -0,0 +1,3 @@
+import { PluginInput, PluginOutput } from '@adhd/apigen-core';
+
+export declare function generate(input: PluginInput): PluginOutput;

package/lib/plugin.d.ts

@@ -0,0 +1,4 @@
+import { OutputPlugin } from '@adhd/apigen-core';
+
+export declare const mcpPlugin: OutputPlugin;
+export default mcpPlugin;

package/lib/run.d.ts

@@ -0,0 +1,3 @@
+import { RunInput } from '@adhd/apigen-core';
+
+export declare function run(input: RunInput): Promise<void>;

package/lib/stream.d.ts

@@ -0,0 +1,47 @@
+import { ApiStream } from '@adhd/apigen-runtime';
+
+/** A single MCP content item (text carrier). */
+export interface McpTextContent {
+    type: 'text';
+    text: string;
+}
+/** The MCP CallTool result envelope. */
+export interface McpCallToolResult {
+    content: McpTextContent[];
+    isError?: boolean;
+}
+/**
+ * Drain `stream` and return the accumulated MCP result envelope.
+ *
+ * Chunks are collected in order; a terminal error after the first chunk is
+ * appended as an in-band error notification (`isError: true`).
+ *
+ * Because the MCP SDK's `CallToolRequestSchema` handler is a regular
+ * `async function` (returning a single value, not a generator), we cannot
+ * truly stream chunks over the wire — the SDK serialises the whole response
+ * once returned.  The projection therefore **collects all chunks** and returns
+ * them as an ordered array of `content` items, which is the idiomatic MCP
+ * "progressive results" shape.  Each chunk occupies one `content` slot in
+ * order.
+ *
+ * When the wire transport supports streaming (e.g. MCP over SSE with
+ * server-initiated notifications), a future revision may use
+ * `server.notification()` per chunk.  The current shape is forward-compatible:
+ * the terminal item remains last.
+ *
+ * @param stream - the `ApiStream` returned by the Layer harness for a
+ *   `streaming:true` operation.
+ * @returns a Promise resolving to the MCP `CallToolResult` envelope.
+ */
+export declare function projectStreamMcp(stream: ApiStream<unknown>): Promise<McpCallToolResult>;
+/**
+ * Drain `stream` collecting partial chunks AND the terminal error in-band.
+ *
+ * Unlike `projectStreamMcp`, this variant re-drives the stream manually to
+ * accumulate chunk values even when an error-after-first-chunk occurs, giving
+ * transport adapters the full `[chunk…, errorPayload]` content array.
+ *
+ * This is the **preferred** function for MCP transports that want to expose
+ * all partial data to the client.
+ */
+export declare function projectStreamMcpFull(stream: ApiStream<unknown>): Promise<McpCallToolResult>;

package/lib/templates/server-http.tpl.d.ts

@@ -0,0 +1,2 @@
+/** Generates server.ts content for SSE or streaming-HTTP transport (uses node:http). */
+export declare function generateHttpServer(transport: 'sse' | 'streaming-http', port: number): string;

package/lib/templates/server-stdio.tpl.d.ts

@@ -0,0 +1,2 @@
+/** Generates server.ts content for the stdio transport. */
+export declare function generateStdioServer(): string;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@adhd/apigen-plugin-mcp",
+  "version": "0.1.0",
+  "main": "./index.js",
+  "dependencies": {
+    "@adhd/apigen-core": "^0.1.0",
+    "@adhd/apigen-runtime": "^0.1.0",
+    "@modelcontextprotocol/sdk": "1.29.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "./index.mjs",
+  "types": "./index.d.ts"
+}