@haikit/mcp 0.0.0-stage → 0.33.0

package/src/text.ts

@@ -0,0 +1,60 @@
+import type { ContentBlock } from "@modelcontextprotocol/client";
+import type { McpResult } from "./index.js";
+
+export interface TextOptions {
+  /** The longest text returned, before the line saying it was cut. Default 8,000 (about 2,000 tokens). */
+  maxChars?: number;
+}
+
+const MAX_CHARS = 8_000;
+
+/**
+ * A result as text, for a tool that decides to pass some of it on. Nothing
+ * calls this for you: what a result becomes is the tool's choice.
+ *
+ * Text blocks, and resources embedded as text, come as they are; anything
+ * else becomes one line saying what it was. With no content, the structured
+ * result as JSON. Longer than `maxChars`, it is cut, and a last line says so:
+ * a cut nobody mentions turns a cost problem into a correctness problem.
+ */
+export function textOf(result: McpResult, options: TextOptions = {}): string {
+  const maxChars = options.maxChars ?? MAX_CHARS;
+  if (!Number.isSafeInteger(maxChars) || maxChars < 0) {
+    throw new RangeError(`maxChars must be a whole number of characters, 0 or more (got ${String(maxChars)})`);
+  }
+  const text =
+    result.content.length === 0
+      ? result.structuredContent === undefined
+        ? ""
+        : JSON.stringify(result.structuredContent)
+      : result.content.map(blockText).join("\n");
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\n[Cut at ${maxChars} of ${text.length} characters.]`;
+}
+
+function blockText(block: ContentBlock): string {
+  switch (block.type) {
+    case "text":
+      return block.text;
+    case "image":
+    case "audio":
+      return `[${block.type}: ${block.mimeType}, ${bytes(block.data)} bytes, not included]`;
+    case "resource_link":
+      return `[resource link: ${block.name} ${block.uri}]`;
+    case "resource": {
+      const r = block.resource;
+      if ("text" in r && typeof r.text === "string") return r.text;
+      const blob = "blob" in r && typeof r.blob === "string" ? r.blob : "";
+      return `[resource: ${r.uri}${r.mimeType ? `, ${r.mimeType}` : ""}, ${bytes(blob)} bytes, not included]`;
+    }
+    default:
+      // a content type from a later protocol revision
+      return `[${String((block as { type?: unknown }).type)} content, not included]`;
+  }
+}
+
+/** The size of what base64 `data` encodes, without decoding it. */
+function bytes(data: string): number {
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor((data.length * 3) / 4) - padding);
+}

package/src/transports.ts

@@ -0,0 +1,56 @@
+import {
+  StreamableHTTPClientTransport,
+  type AuthProvider,
+  type StreamableHTTPClientTransportOptions,
+  type Transport,
+} from "@modelcontextprotocol/client";
+import { StdioClientTransport, type StdioServerParameters } from "@modelcontextprotocol/client/stdio";
+
+export interface HttpOptions extends StreamableHTTPClientTransportOptions {
+  /** Sent on every request, over any of the same name in `requestInit.headers`. */
+  headers?: Record<string, string>;
+}
+
+/** What `mcpServer({ auth })` needs to know of a transport `http()` made. */
+export interface HttpMade {
+  /** It was given an `authProvider` of its own. */
+  authProvider: boolean;
+  /** It sends an `Authorization` header of its own. */
+  authorization: boolean;
+}
+
+/** The factories `http()` made: only these can carry each user's credential. */
+export const madeByHttp = new WeakMap<object, HttpMade>();
+
+/**
+ * A server at `url`, over Streamable HTTP. Everything but `headers` is the
+ * SDK's own `StreamableHTTPClientTransportOptions`, such as an `authProvider`.
+ * The URL is checked now, so a bad one fails at startup. For a server with
+ * `auth`, each user's connection is given that user's `authProvider`.
+ */
+export function http(url: string | URL, options: HttpOptions = {}): (authProvider?: AuthProvider) => Transport {
+  const target = new URL(url);
+  const { headers, ...rest } = options;
+  if (headers) {
+    const merged = new Headers(rest.requestInit?.headers);
+    for (const [name, value] of Object.entries(headers)) merged.set(name, value);
+    rest.requestInit = { ...rest.requestInit, headers: merged };
+  }
+  const make = (authProvider?: AuthProvider) =>
+    new StreamableHTTPClientTransport(target, authProvider ? { ...rest, authProvider } : rest);
+  madeByHttp.set(make, {
+    authProvider: rest.authProvider !== undefined,
+    authorization: new Headers(rest.requestInit?.headers).has("authorization"),
+  });
+  return make;
+}
+
+/**
+ * A server this process starts, and talks to over its stdin and stdout. Each
+ * connection starts a new child; `close()` stops it. Unless `env` is given,
+ * the child gets only the SDK's short list of safe variables (such as `HOME`
+ * and `PATH`), not this process's environment and the secrets in it.
+ */
+export function stdio(params: StdioServerParameters): () => Transport {
+  return () => new StdioClientTransport(params);
+}