@haikit/mcp 0.0.0-stage → 0.32.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hai contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,64 @@
-# Temporary Holding Version
+# @haikit/mcp
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Call an MCP server's tools from inside your own HaiKIT tools.
+
+The model never sees an MCP tool. You declare the server tools your app may
+call, typed by schemas you own, and call them from a tool's `run` or an action
+handler, as you would a database. Your tool decides what the model hears of
+the result and what the browser shows. Nothing a third-party server says
+reaches the model unless your code puts it there: not its tools' names or
+descriptions, not its instructions, and not its results.
+
+```ts
+import { mcpServer, http } from "@haikit/mcp";
+import { defineTool } from "@haikit/core";
+import { z } from "zod";
+
+const github = mcpServer({
+  name: "github",
+  transport: http("https://api.example.com/mcp", { headers: { Authorization: `Bearer ${token}` } }),
+});
+
+// each server tool the app may call, checked both ways by your schemas
+const searchIssues = github.tool("search_issues", {
+  args: z.object({ q: z.string(), per_page: z.number() }),
+  result: z.object({ items: z.array(Issue) }),
+});
+
+// what the model sees is yours: the name, the description, the schema
+export const findIssues = defineTool({
+  name: "find_issues",
+  description: "Search this project's issues.",
+  input: z.object({ query: z.string() }),
+  inputJsonSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
+  async run({ query }, ctx) {
+    const { items } = await searchIssues.call({ q: `repo:acme/app ${query}`, per_page: 50 }, ctx);
+    return ctx.render(issueList, { issues: items }); // rows to the browser, the digest to the model
+  },
+});
+
+await github.connect(); // at startup: stops here if a declared tool isn't on the server
+```
+
+- `stdio({ command, args })` starts a local server as a child process instead.
+  The child gets only a short list of safe environment variables, not yours.
+- A call throws `McpToolError` when the tool reports an error, and `McpError`
+  when there's no result: bad args, a result your schema refuses, a timeout,
+  a lost connection, a refusal. The message names only the server and the
+  tool. What the server said is on `err.text`, so a tool that lets the error
+  through doesn't pass the server's words to the model.
+- Progress from the server reaches `ctx.progress`, and keeps a long call alive.
+  A call times out after 30 s without word from the server, and after 90 s in
+  all, connecting included, inside the 120 s turn lease.
+- `textOf(result)` turns a result into text, for a tool that decides to pass
+  some of it on. A cut is always marked in the text.
+
+`McpTool` isn't a HaiKIT `Tool`, so it can't be passed to
+`createHai({ tools })`: `npm run typetest` checks that.
+
+Imports only `@haikit/core`, never `@haikit/server`. Built on
+[`@modelcontextprotocol/client`](https://www.npmjs.com/package/@modelcontextprotocol/client),
+the official TypeScript SDK's client.
+
+Everything it does, with every default and message:
+[the reference manual](https://github.com/wfoxd/haikit/blob/main/docs/reference/mcp.md).

package/dist/errors.d.ts

@@ -0,0 +1,60 @@
+import type { ContentBlock } from "@modelcontextprotocol/client";
+/**
+ * Why a call failed:
+ *
+ * - `args`: the args didn't match the tool's `args` schema, so nothing was sent.
+ * - `result`: the result didn't match its `result` schema.
+ * - `timeout`: the server didn't answer within `timeoutMs` or `maxTotalMs`.
+ * - `connection`: the server couldn't be reached, or the connection dropped.
+ * - `protocol`: the server refused the call, such as for a tool it doesn't
+ *   have, or asked for something this client doesn't do.
+ * - `closed`: `close()` was called.
+ */
+export type McpErrorReason = "args" | "result" | "timeout" | "connection" | "protocol" | "closed";
+/**
+ * A call that didn't get a result. The message names only the server and the
+ * tool, never what the server said: a HaiKIT tool that lets this go reaches the
+ * model as `<name> failed: <message>`, and the server's words aren't the app's
+ * to pass on unread. Its words are on `text`, for logs and for code that
+ * decides.
+ *
+ * Detected by `name` rather than `instanceof`, as in @haikit/core: a duplicated
+ * install would give two distinct classes.
+ */
+export declare class McpError extends Error {
+    readonly name = "McpError";
+    /** The server's `name`. */
+    readonly server: string;
+    /** The tool called. Absent when `connect()` failed. */
+    readonly tool: string | undefined;
+    readonly reason: McpErrorReason;
+    /** What the server said about it, when it said anything: a JSON-RPC error's message. */
+    readonly text: string | undefined;
+    /** A JSON-RPC error's code. */
+    readonly code: number | undefined;
+    constructor(reason: McpErrorReason, message: string, detail: {
+        server: string;
+        tool?: string;
+        text?: string;
+        code?: number;
+        cause?: unknown;
+    });
+}
+/**
+ * The tool ran and reported an error (`isError` in its result). Its message
+ * says only that, for the reason `McpError`'s does; what the server said is on
+ * `text` and `content`.
+ */
+export declare class McpToolError extends Error {
+    readonly name = "McpToolError";
+    readonly server: string;
+    readonly tool: string;
+    /** The result's text blocks, joined by newlines. */
+    readonly text: string;
+    /** The result's content blocks, as the server sent them. */
+    readonly content: ContentBlock[];
+    constructor(server: string, tool: string, content: ContentBlock[]);
+}
+export declare const isMcpError: (err: unknown) => err is McpError;
+export declare const isMcpToolError: (err: unknown) => err is McpToolError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,YAAY,GAAG,UAAU,GAAG,QAAQ,CAAC;AAElG;;;;;;;;;GASG;AACH,qBAAa,QAAS,SAAQ,KAAK;IACjC,QAAQ,CAAC,IAAI,cAAc;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,wFAAwF;IACxF,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;gBAGhC,MAAM,EAAE,cAAc,EACtB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAS3F;AAED;;;;GAIG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,kBAAkB;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC;gBAErB,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE;CAOlE;AAED,eAAO,MAAM,UAAU,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,QAA2D,CAAC;AAE7G,eAAO,MAAM,cAAc,GAAI,KAAK,OAAO,KAAG,GAAG,IAAI,YACA,CAAC"}

package/dist/errors.js

@@ -0,0 +1,54 @@
+/**
+ * A call that didn't get a result. The message names only the server and the
+ * tool, never what the server said: a HaiKIT tool that lets this go reaches the
+ * model as `<name> failed: <message>`, and the server's words aren't the app's
+ * to pass on unread. Its words are on `text`, for logs and for code that
+ * decides.
+ *
+ * Detected by `name` rather than `instanceof`, as in @haikit/core: a duplicated
+ * install would give two distinct classes.
+ */
+export class McpError extends Error {
+    name = "McpError";
+    /** The server's `name`. */
+    server;
+    /** The tool called. Absent when `connect()` failed. */
+    tool;
+    reason;
+    /** What the server said about it, when it said anything: a JSON-RPC error's message. */
+    text;
+    /** A JSON-RPC error's code. */
+    code;
+    constructor(reason, message, detail) {
+        super(message, detail.cause === undefined ? undefined : { cause: detail.cause });
+        this.reason = reason;
+        this.server = detail.server;
+        this.tool = detail.tool;
+        this.text = detail.text;
+        this.code = detail.code;
+    }
+}
+/**
+ * The tool ran and reported an error (`isError` in its result). Its message
+ * says only that, for the reason `McpError`'s does; what the server said is on
+ * `text` and `content`.
+ */
+export class McpToolError extends Error {
+    name = "McpToolError";
+    server;
+    tool;
+    /** The result's text blocks, joined by newlines. */
+    text;
+    /** The result's content blocks, as the server sent them. */
+    content;
+    constructor(server, tool, content) {
+        super(`${server}/${tool} reported an error`);
+        this.server = server;
+        this.tool = tool;
+        this.content = content;
+        this.text = content.flatMap((b) => (b.type === "text" ? [b.text] : [])).join("\n");
+    }
+}
+export const isMcpError = (err) => err instanceof Error && err.name === "McpError";
+export const isMcpToolError = (err) => err instanceof Error && err.name === "McpToolError";
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,MAAM,OAAO,QAAS,SAAQ,KAAK;IACxB,IAAI,GAAG,UAAU,CAAC;IAC3B,2BAA2B;IAClB,MAAM,CAAS;IACxB,uDAAuD;IAC9C,IAAI,CAAqB;IACzB,MAAM,CAAiB;IAChC,wFAAwF;IAC/E,IAAI,CAAqB;IAClC,+BAA+B;IACtB,IAAI,CAAqB;IAElC,YACE,MAAsB,EACtB,OAAe,EACf,MAAwF;QAExF,KAAK,CAAC,OAAO,EAAE,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;QACjF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IAC1B,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,OAAO,YAAa,SAAQ,KAAK;IAC5B,IAAI,GAAG,cAAc,CAAC;IACtB,MAAM,CAAS;IACf,IAAI,CAAS;IACtB,oDAAoD;IAC3C,IAAI,CAAS;IACtB,4DAA4D;IACnD,OAAO,CAAiB;IAEjC,YAAY,MAAc,EAAE,IAAY,EAAE,OAAuB;QAC/D,KAAK,CAAC,GAAG,MAAM,IAAI,IAAI,oBAAoB,CAAC,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrF,CAAC;CACF;AAED,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,GAAY,EAAmB,EAAE,CAAC,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,CAAC;AAE7G,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,GAAY,EAAuB,EAAE,CAClE,GAAG,YAAY,KAAK,IAAI,GAAG,CAAC,IAAI,KAAK,cAAc,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @haikit/mcp — call MCP servers' tools from inside your own tools.
+ *
+ * The model never sees an MCP tool. An app declares the server tools it calls,
+ * typed by schemas it owns, and calls them from a HaiKIT tool's `run` or an
+ * action handler, the way it would call a database: that code decides what the
+ * model hears of a result and what the browser shows. So nothing a third-party
+ * server says — its tools' names and descriptions, its instructions, its
+ * results — reaches the model unless app code puts it there.
+ *
+ * There is no way to make a HaiKIT `Tool` from an MCP tool here, on purpose:
+ * an `McpTool` has no `run`, so `createHai({ tools })` won't take one.
+ *
+ * Imports only @haikit/core, like the model adapters.
+ */
+import type { Progress, Schema } from "@haikit/core";
+import { type ContentBlock, type Transport, type VersionNegotiationMode } from "@modelcontextprotocol/client";
+export { McpError, McpToolError, isMcpError, isMcpToolError, type McpErrorReason } from "./errors.js";
+export { textOf, type TextOptions } from "./text.js";
+export { http, stdio, type HttpOptions } from "./transports.js";
+export type { ContentBlock, Transport } from "@modelcontextprotocol/client";
+export interface McpServerOptions {
+    /** Names the server in errors and warnings, as in `github/search_issues`. */
+    name: string;
+    /**
+     * Makes a connection: called by the first `connect()` or call, and again
+     * for each reconnect. `http(url)` and `stdio({ command })` make one.
+     */
+    transport: () => Transport | Promise<Transport>;
+    /**
+     * How long the server may go without answering a call or reporting progress
+     * on it, in milliseconds. Also bounds making the transport, connecting and
+     * listing tools. Default 30,000.
+     */
+    timeoutMs?: number;
+    /**
+     * The longest a call may take, progress or not, connecting included, in
+     * milliseconds. Default 90,000.
+     */
+    maxTotalMs?: number;
+    /**
+     * A declared tool was removed from the server, or its schema changed: seen
+     * when the server says its tools changed, and on a reconnect. Calls go on
+     * as before; one to a removed tool fails. Default: a `console.warn`. If it
+     * throws, the error is logged with `console.error`.
+     */
+    onChange?: (change: McpToolChange) => void;
+    /** The SDK's protocol version negotiation. Default `"legacy"`, the SDK's own: the 2025 handshake. */
+    versionNegotiation?: VersionNegotiationMode;
+}
+export interface McpToolChange {
+    server: string;
+    /** Declared tools the server no longer has. */
+    removed: string[];
+    /** Declared tools whose input or output schema, or task support, changed. */
+    changed: string[];
+}
+export interface McpToolDef<A, R> {
+    /** Checks the args before anything is sent. They must come out an object. */
+    args: Schema<A>;
+    /**
+     * Checks the result, which `call` then resolves to: the server's structured
+     * result, or, without one, the JSON in its one text block. Without this,
+     * `call` resolves to the result's content as the server sent it.
+     */
+    result?: Schema<R>;
+    /** Overrides the server's `timeoutMs` for this tool. */
+    timeoutMs?: number;
+    /** Overrides the server's `maxTotalMs` for this tool. */
+    maxTotalMs?: number;
+}
+/** A result with no `result` schema: what the server sent, unchecked. */
+export interface McpResult {
+    /** The content blocks, as the server sent them. */
+    content: ContentBlock[];
+    /** The server's structured result, when it sent one. */
+    structuredContent?: unknown;
+}
+/**
+ * What a call is made for. A HaiKIT tool's `ctx` or an action handler's can
+ * be passed as it is.
+ */
+export interface McpCallCtx {
+    /**
+     * The conversation the call is for. Nothing reads it yet: it is here so a
+     * later version can pick a connection per user without calls changing.
+     */
+    readonly conversationId?: string;
+    /** Hears the server's progress notifications, as `ToolCtx.progress` does. */
+    progress?(progress: Progress): void;
+}
+/** One of the server's tools, as the app declared it. Not a HaiKIT `Tool`: the model never sees it. */
+export interface McpTool<A, R> {
+    readonly server: string;
+    readonly name: string;
+    /**
+     * Calls the tool. Throws `McpToolError` when the tool reports an error, and
+     * `McpError` when the call gets no result, or one its schema refuses.
+     */
+    call(args: A, ctx?: McpCallCtx): Promise<R>;
+}
+/** The connection to one MCP server, and the tools the app may call on it. */
+export interface McpConnection {
+    readonly name: string;
+    /**
+     * Declares one of the server's tools: the only way to call it. Declared
+     * after `connect()`, it is checked against the server's tools at once.
+     */
+    tool<A, R>(name: string, def: McpToolDef<A, R> & {
+        result: Schema<R>;
+    }): McpTool<A, R>;
+    tool<A>(name: string, def: McpToolDef<A, unknown> & {
+        result?: undefined;
+    }): McpTool<A, McpResult>;
+    /**
+     * Connects, and checks every declared tool: it throws if the server has no
+     * tool of that name, or one that can only run as an MCP task. Call it at
+     * startup, so a mistake stops the app there; the first call connects
+     * otherwise, and fails with the same error.
+     */
+    connect(): Promise<void>;
+    /** Closes the connection, and stops a `stdio` server. Final: a later call fails with reason `closed`. */
+    close(): Promise<void>;
+}
+/** The connection to an MCP server. Nothing connects until `connect()` or the first call. */
+export declare function mcpServer(options: McpServerOptions): McpConnection;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}