@fgv/ts-extras-mcp 5.1.0-47 → 5.1.0-49

package/src/packlets/mcp/operations.ts

@@ -1,181 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- *
- * 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.
- */
-
-/**
- * Tool discovery (`listMcpTools`, paginated) and invocation (`callMcpTool`, with `CallToolResult`
- * projection), converting the throwing SDK calls into `Result<T>`.
- * @packageDocumentation
- */
-
-import { Converters as UtilsConverters, type Result, captureAsyncResult, fail, succeed } from '@fgv/ts-utils';
-import { Converters, type JsonObject } from '@fgv/ts-json-base';
-
-import {
-  type IMcpSession,
-  type IMcpToolAnnotations,
-  type IMcpToolCallResult,
-  type IMcpToolDescriptor
-} from './model';
-import { type ISdkContentBlock, type ISdkToolDescriptor } from './sdk';
-import { McpSession } from './session';
-
-/**
- * Validates/normalizes a raw (untrusted) MCP `Tool.annotations` blob into an
- * {@link IMcpToolAnnotations}, keeping only the five known fields that convert cleanly.
- *
- * @remarks
- * Each known field is converted independently with its own Converter, so a present-but-malformed
- * field is dropped (never failing the whole blob) and unknown keys are ignored. Returns
- * `undefined` when the blob is absent, not a JSON object, or normalizes to no usable known
- * fields — so a tool with no (usable) annotations leaves {@link IMcpToolDescriptor.annotations}
- * absent. The raw server value is never propagated verbatim (per the MCP untrusted-server
- * warning).
- */
-function _normalizeAnnotations(raw: unknown): IMcpToolAnnotations | undefined {
-  const objResult = Converters.jsonObject.convert(raw);
-  if (objResult.isFailure()) {
-    return undefined;
-  }
-  const obj = objResult.value;
-  const title = UtilsConverters.string.convert(obj.title).orDefault();
-  const readOnlyHint = UtilsConverters.boolean.convert(obj.readOnlyHint).orDefault();
-  const destructiveHint = UtilsConverters.boolean.convert(obj.destructiveHint).orDefault();
-  const idempotentHint = UtilsConverters.boolean.convert(obj.idempotentHint).orDefault();
-  const openWorldHint = UtilsConverters.boolean.convert(obj.openWorldHint).orDefault();
-
-  const normalized: IMcpToolAnnotations = {
-    ...(title !== undefined ? { title } : {}),
-    ...(readOnlyHint !== undefined ? { readOnlyHint } : {}),
-    ...(destructiveHint !== undefined ? { destructiveHint } : {}),
-    ...(idempotentHint !== undefined ? { idempotentHint } : {}),
-    ...(openWorldHint !== undefined ? { openWorldHint } : {})
-  };
-  return Object.keys(normalized).length > 0 ? normalized : undefined;
-}
-
-/**
- * Projects a single SDK tool descriptor into a public {@link IMcpToolDescriptor}. The
- * `inputSchema` field is validated as a `JsonValue`; an absent/non-JSON schema becomes `null`
- * (which {@link adaptMcpTools} then reports as un-adaptable rather than offering it to the model).
- * The raw `annotations` blob is validated/normalized (never propagated raw) per the MCP
- * untrusted-server warning.
- */
-function _toDescriptor(tool: ISdkToolDescriptor): IMcpToolDescriptor {
-  const annotations = _normalizeAnnotations(tool.annotations);
-  return {
-    name: tool.name,
-    description: tool.description,
-    inputSchema: Converters.jsonValue.convert(tool.inputSchema).orDefault(null),
-    ...(annotations !== undefined ? { annotations } : {})
-  };
-}
-
-/**
- * Projects the SDK `CallToolResult` content blocks to a single string: `text` blocks are
- * concatenated; every other block type becomes a one-line `[<type> block]` summary.
- */
-function _projectContent(blocks: ReadonlyArray<ISdkContentBlock> | undefined): string {
-  if (blocks === undefined || blocks.length === 0) {
-    return '';
-  }
-  return blocks
-    .map((block) =>
-      block.type === 'text' && block.text !== undefined ? block.text : `[${block.type} block]`
-    )
-    .join('\n');
-}
-
-/**
- * Lists every tool a connected MCP server advertises, following the SDK's `nextCursor`
- * pagination until the full catalog is accumulated.
- *
- * @param session - A session from `connectMcpSession`.
- * @returns `Success` with the full tool catalog, or `Failure` on a foreign handle or a
- * transport/protocol error.
- * @public
- */
-export async function listMcpTools(session: IMcpSession): Promise<Result<ReadonlyArray<IMcpToolDescriptor>>> {
-  const sessionResult = McpSession.fromHandle(session);
-  if (sessionResult.isFailure()) {
-    return fail(`listMcpTools: ${sessionResult.message}`);
-  }
-  const { client } = sessionResult.value;
-
-  const all: IMcpToolDescriptor[] = [];
-  let cursor: string | undefined;
-
-  // Cursor-paginated loop: fetch each page, accumulate, advance until nextCursor is absent.
-  do {
-    const pageResult = await captureAsyncResult(() =>
-      client.listTools(cursor !== undefined ? { cursor } : undefined)
-    ).withErrorFormat((msg) => `listMcpTools: ${msg}`);
-    if (pageResult.isFailure()) {
-      return fail(pageResult.message);
-    }
-    for (const tool of pageResult.value.tools) {
-      all.push(_toDescriptor(tool));
-    }
-    cursor = pageResult.value.nextCursor;
-  } while (cursor !== undefined);
-
-  return succeed(all);
-}
-
-/**
- * Calls a named tool on a connected MCP server.
- *
- * @remarks
- * The SDK `CallToolResult` is projected to {@link IMcpToolCallResult} (text-block concatenation;
- * non-text blocks summarized). A result flagged `isError: true` is mapped to `Result.fail` with
- * the projected content — it is never swallowed, so `executeClientToolTurn` routes it back to the
- * model as a provider-native error tool-result.
- *
- * @param session - A session from `connectMcpSession`.
- * @param name - The tool name to invoke.
- * @param args - The tool arguments (a JSON object).
- * @returns `Success` with the projected content, or `Failure` on tool error / transport error /
- * foreign handle.
- * @public
- */
-export async function callMcpTool(
-  session: IMcpSession,
-  name: string,
-  args: JsonObject
-): Promise<Result<IMcpToolCallResult>> {
-  const sessionResult = McpSession.fromHandle(session);
-  if (sessionResult.isFailure()) {
-    return fail(`callMcpTool: ${sessionResult.message}`);
-  }
-  // The `withErrorFormat` wraps only transport/throw failures (it transforms the failure flowing
-  // out of `captureAsyncResult`); the `isError` failure created in the later `onSuccess` is
-  // downstream and stays clean, so the model-facing tool-error text is the server's verbatim
-  // content rather than a doubly-prefixed message.
-  return captureAsyncResult(() => sessionResult.value.client.callTool({ name, arguments: args }))
-    .withErrorFormat((msg) => `callMcpTool '${name}': ${msg}`)
-    .onSuccess((raw): Result<IMcpToolCallResult> => {
-      const content = _projectContent(raw.content);
-      if (raw.isError === true) {
-        return fail(content.length > 0 ? content : `tool '${name}' reported an error`);
-      }
-      return succeed({ content });
-    });
-}

package/src/packlets/mcp/sdk.ts

@@ -1,154 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- *
- * 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.
- */
-
-/**
- * **The single `@modelcontextprotocol/sdk` import site for the entire package.**
- *
- * Every other module in `@fgv/ts-extras-mcp` depends only on the minimal local projection
- * exported here (`ISdkClient`, `ISdkTransport`, the three `make*` factories) — never on the SDK
- * directly. This keeps the announced v2 client-package rename a one-file change and lets unit
- * tests mock this module instead of the SDK internals (no live server required).
- *
- * The only `as unknown as` casts in the package live here, at the boundary where the real SDK
- * objects are narrowed to the local projection.
- *
- * @internal
- */
-
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
-
-/**
- * Opaque transport handle. The concrete value is an SDK `Transport`; consumers of this module
- * treat it as opaque and only ever hand it back to {@link makeClient}-produced clients.
- * @internal
- */
-export type ISdkTransport = object;
-
-/**
- * A single content block in an MCP `CallToolResult`. Only `text` blocks carry inline content;
- * all other block types are projected to a structural summary by the operations layer.
- * @internal
- */
-export interface ISdkContentBlock {
-  readonly type: string;
-  readonly text?: string;
-}
-
-/**
- * Projection of the SDK's `CallToolResult`.
- * @internal
- */
-export interface ISdkCallToolResult {
-  readonly content?: ReadonlyArray<ISdkContentBlock>;
-  readonly isError?: boolean;
-}
-
-/**
- * Projection of a single tool descriptor in the SDK's `ListToolsResult`.
- * @internal
- */
-export interface ISdkToolDescriptor {
-  readonly name: string;
-  readonly description?: string;
-  readonly inputSchema?: unknown;
-  /**
-   * Raw MCP `Tool.annotations` (untrusted). Declared as `unknown` so the SDK field survives
-   * narrowing; the operations layer validates/normalizes it (never propagates raw) per the MCP
-   * spec's untrusted-server warning.
-   */
-  readonly annotations?: unknown;
-}
-
-/**
- * Projection of the SDK's `ListToolsResult` (one page).
- * @internal
- */
-export interface ISdkListToolsResult {
-  readonly tools: ReadonlyArray<ISdkToolDescriptor>;
-  readonly nextCursor?: string;
-}
-
-/**
- * Server identity returned by the SDK's `getServerVersion()` after the initialize handshake.
- * @internal
- */
-export interface ISdkImplementation {
-  readonly name: string;
-  readonly version: string;
-}
-
-/**
- * Minimal projection of the SDK `Client` surface the package depends on.
- * @internal
- */
-export interface ISdkClient {
-  connect(transport: ISdkTransport): Promise<void>;
-  getServerVersion(): ISdkImplementation | undefined;
-  listTools(params?: { cursor?: string }): Promise<ISdkListToolsResult>;
-  callTool(params: { name: string; arguments?: Record<string, unknown> }): Promise<ISdkCallToolResult>;
-  close(): Promise<void>;
-}
-
-/**
- * Parameters for the stdio transport factory.
- * @internal
- */
-export interface ISdkStdioParams {
-  readonly command: string;
-  readonly args?: ReadonlyArray<string>;
-  readonly env?: Record<string, string>;
-  readonly cwd?: string;
-}
-
-/**
- * Constructs an MCP client. The `as unknown as` cast is the package's single SDK-type
- * bridge — the runtime object is a real SDK `Client`.
- * @internal
- */
-export function makeClient(name: string, version: string): ISdkClient {
-  return new Client({ name, version }, { capabilities: {} }) as unknown as ISdkClient;
-}
-
-/**
- * Constructs a stdio transport that spawns the given command as a subprocess.
- * @internal
- */
-export function makeStdioTransport(params: ISdkStdioParams): ISdkTransport {
-  return new StdioClientTransport({
-    command: params.command,
-    args: params.args ? [...params.args] : undefined,
-    env: params.env,
-    cwd: params.cwd
-  }) as unknown as ISdkTransport;
-}
-
-/**
- * Constructs a Streamable-HTTP transport for the given URL, with optional static headers.
- * @internal
- */
-export function makeHttpTransport(url: URL, headers?: Record<string, string>): ISdkTransport {
-  return new StreamableHTTPClientTransport(url, {
-    requestInit: headers ? { headers } : undefined
-  }) as unknown as ISdkTransport;
-}

package/src/packlets/mcp/session.ts

@@ -1,137 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- *
- * 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.
- */
-
-/**
- * Session lifecycle — connect / close, converting the throwing SDK calls into `Result<T>`.
- * @packageDocumentation
- */
-
-import { type Result, captureAsyncResult, fail, succeed } from '@fgv/ts-utils';
-
-import { type IConnectMcpSessionParams, type IMcpServerInfo, type IMcpSession } from './model';
-import { type ISdkClient, makeClient } from './sdk';
-import { McpTransport } from './transports';
-
-/** Default client name advertised during the initialize handshake. */
-const DEFAULT_CLIENT_NAME: string = '@fgv/ts-extras-mcp';
-/**
- * Default client version advertised during the initialize handshake.
- *
- * @remarks
- * Keep in sync with this package's `package.json` version on each release. It is informational
- * only — MCP servers use it for logging/telemetry, not for behavior — so a drift is low-impact,
- * but it should be bumped alongside the lockstep version. (Reading it from `package.json` at
- * runtime is avoided to keep the bundle free of a JSON import / `require` of the manifest.)
- */
-const DEFAULT_CLIENT_VERSION: string = '5.1.0';
-
-/**
- * Concrete session handle. Packlet-internal — carries the live SDK client that the operations
- * layer recovers via {@link McpSession.fromHandle}. Not exported from the package barrel.
- * @internal
- */
-export class McpSession implements IMcpSession {
-  public readonly clientName: string;
-  public readonly clientVersion: string;
-  public readonly serverInfo: IMcpServerInfo | undefined;
-  /** The live SDK client. */
-  public readonly client: ISdkClient;
-
-  public constructor(
-    client: ISdkClient,
-    clientName: string,
-    clientVersion: string,
-    serverInfo: IMcpServerInfo | undefined
-  ) {
-    this.client = client;
-    this.clientName = clientName;
-    this.clientVersion = clientVersion;
-    this.serverInfo = serverInfo;
-  }
-
-  /**
-   * Narrows a public {@link IMcpSession} handle back to the concrete {@link McpSession}. Fails
-   * loudly when handed a foreign object that did not originate from {@link connectMcpSession}.
-   */
-  public static fromHandle(handle: IMcpSession): Result<McpSession> {
-    if (handle instanceof McpSession) {
-      return succeed(handle);
-    }
-    return fail('invalid MCP session: expected a handle from connectMcpSession');
-  }
-}
-
-/**
- * Connects to an MCP server over the given transport and performs the initialize handshake.
- *
- * @param params - Transport plus optional client identity and logger.
- * @returns `Success` with an opaque {@link IMcpSession}, or `Failure` if the transport handle is
- * foreign or the connection/handshake fails.
- * @public
- */
-export async function connectMcpSession(params: IConnectMcpSessionParams): Promise<Result<IMcpSession>> {
-  const { transport, clientName, clientVersion, logger } = params;
-
-  const transportResult = McpTransport.fromHandle(transport);
-  if (transportResult.isFailure()) {
-    return fail(`connectMcpSession: ${transportResult.message}`);
-  }
-
-  const name = clientName ?? DEFAULT_CLIENT_NAME;
-  const version = clientVersion ?? DEFAULT_CLIENT_VERSION;
-  const client = makeClient(name, version);
-
-  logger?.info(
-    `mcp: connecting (client ${name}@${version}, transport ${transportResult.value.transportKind})`
-  );
-
-  return captureAsyncResult(() => client.connect(transportResult.value.sdkTransport))
-    .onSuccess(() => {
-      const raw = client.getServerVersion();
-      const serverInfo: IMcpServerInfo | undefined =
-        raw !== undefined ? { name: raw.name, version: raw.version } : undefined;
-      logger?.info(
-        serverInfo !== undefined
-          ? `mcp: connected to server ${serverInfo.name}@${serverInfo.version}`
-          : 'mcp: connected (server did not report identity)'
-      );
-      return succeed<IMcpSession>(new McpSession(client, name, version, serverInfo));
-    })
-    .withErrorFormat((msg) => `connectMcpSession: ${msg}`);
-}
-
-/**
- * Closes an MCP session, tearing down the transport (and any spawned subprocess).
- *
- * @param session - A session from {@link connectMcpSession}.
- * @returns `Success(true)`, or `Failure` if the handle is foreign or the close call throws.
- * @public
- */
-export async function closeMcpSession(session: IMcpSession): Promise<Result<true>> {
-  const sessionResult = McpSession.fromHandle(session);
-  if (sessionResult.isFailure()) {
-    return fail(`closeMcpSession: ${sessionResult.message}`);
-  }
-  return captureAsyncResult(() => sessionResult.value.client.close())
-    .onSuccess(() => succeed(true as const))
-    .withErrorFormat((msg) => `closeMcpSession: ${msg}`);
-}

package/src/packlets/mcp/transports.ts

@@ -1,111 +0,0 @@
-/*
- * Copyright (c) 2026 Erik Fortune
- *
- * 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.
- */
-
-/**
- * Transport factories — convert the throwing SDK transport constructors into `Result<T>`.
- * @packageDocumentation
- */
-
-import { type Result, captureResult, fail, succeed } from '@fgv/ts-utils';
-
-import { type IMcpHttpTransportParams, type IMcpStdioTransportParams, type IMcpTransport } from './model';
-import { type ISdkTransport, makeHttpTransport, makeStdioTransport } from './sdk';
-
-/**
- * Concrete transport handle. Packlet-internal — carries the SDK transport that
- * {@link McpTransport.fromHandle} recovers inside {@link connectMcpSession}. Not exported from
- * the package barrel, so it does not appear in the public API surface.
- * @internal
- */
-export class McpTransport implements IMcpTransport {
-  public readonly transportKind: 'stdio' | 'http';
-  /** The wrapped SDK transport. */
-  public readonly sdkTransport: ISdkTransport;
-
-  public constructor(transportKind: 'stdio' | 'http', sdkTransport: ISdkTransport) {
-    this.transportKind = transportKind;
-    this.sdkTransport = sdkTransport;
-  }
-
-  /**
-   * Narrows a public {@link IMcpTransport} handle back to the concrete {@link McpTransport}.
-   * Fails loudly when handed a foreign object that did not originate from one of this
-   * package's transport factories.
-   */
-  public static fromHandle(handle: IMcpTransport): Result<McpTransport> {
-    if (handle instanceof McpTransport) {
-      return succeed(handle);
-    }
-    return fail('invalid MCP transport: expected a handle from createStdioTransport / createHttpTransport');
-  }
-}
-
-/**
- * Creates a stdio MCP transport that speaks MCP over the stdin/stdout of a spawned subprocess.
- *
- * @remarks
- * **Security — trust boundary.** The transport spawns `params.command` (with `params.args`) as a
- * child process. Never source the command or arguments from untrusted input; treat them with the
- * same care as any shell-out. See the package README's security note.
- *
- * @param params - The command, arguments, environment, and working directory.
- * @returns `Success` with an opaque transport handle, or `Failure` if the SDK constructor throws
- * (e.g. an empty command).
- * @public
- */
-export function createStdioTransport(params: IMcpStdioTransportParams): Result<IMcpTransport> {
-  if (params.command.trim().length === 0) {
-    return fail('createStdioTransport: command must be a non-empty string');
-  }
-  return captureResult(() =>
-    makeStdioTransport({
-      command: params.command,
-      args: params.args,
-      env: params.env,
-      cwd: params.cwd
-    })
-  )
-    .onSuccess((sdkTransport) => succeed<IMcpTransport>(new McpTransport('stdio', sdkTransport)))
-    .withErrorFormat((msg) => `createStdioTransport: ${msg}`);
-}
-
-/**
- * Creates a Streamable-HTTP MCP transport for the given endpoint URL.
- *
- * @param params - The endpoint URL and optional static headers.
- * @returns `Success` with an opaque transport handle, or `Failure` if the URL is invalid or the
- * SDK constructor throws.
- * @public
- */
-export function createHttpTransport(params: IMcpHttpTransportParams): Result<IMcpTransport> {
-  return captureResult(() => new URL(params.url))
-    .withErrorFormat(() => `invalid url '${params.url}'`)
-    .onSuccess((url): Result<IMcpTransport> => {
-      if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-        return fail(`url must use http or https protocol (got '${url.protocol}')`);
-      }
-      return captureResult(() => makeHttpTransport(url, params.headers)).onSuccess((sdkTransport) =>
-        succeed<IMcpTransport>(new McpTransport('http', sdkTransport))
-      );
-    })
-    .withErrorFormat((msg) => `createHttpTransport: ${msg}`);
-}