apps 0.0.1-beta.84 → 0.0.1-beta.86

package/js/chunk-HODA4JY6.js

@@ -0,0 +1,714 @@
+import {
+  prepareElicitation
+} from "./chunk-CJ5F6UDG.js";
+import {
+  failOnNetworkRefusal
+} from "./chunk-I6Q7ZPKJ.js";
+import {
+  accountProviderError,
+  bodyUpstreamError,
+  fromPromise,
+  httpProviderError,
+  providerErrorDetail
+} from "./chunk-W6XCQAXP.js";
+import {
+  ElicitationFailed,
+  McpCredentialsUnverified,
+  McpError,
+  McpHealthInput,
+  McpServerHeader,
+  McpToolMetadata,
+  McpToolResult,
+  McpToolsOptions,
+  RouterIcon,
+  ToolResultObservation,
+  defaultElicitationLimits,
+  defaultMcpClientLimits,
+  mcpHealthReserveMs,
+  mcpSdkTimerCeilingMs
+} from "./chunk-WUPLD4VN.js";
+import {
+  NetworkRefused,
+  ProviderError
+} from "./chunk-Q4IZAUIF.js";
+import {
+  jsonSchemaDecoder,
+  nestJsonSchema,
+  preparedJsonSchemaDecoder
+} from "./chunk-3FHDX4KB.js";
+import {
+  captureTelemetry,
+  owned
+} from "./chunk-QWQM3CLH.js";
+import {
+  FetchHttpClient_exports
+} from "./chunk-PD6I2SDG.js";
+import {
+  JsonObject
+} from "./chunk-H2CJWXA3.js";
+import {
+  HttpClientRequest_exports,
+  HttpClient_exports
+} from "./chunk-EOPQ727L.js";
+import {
+  Clock_exports,
+  Deferred_exports,
+  Effect_exports,
+  Exit_exports,
+  Match_exports,
+  Option_exports,
+  Predicate_exports,
+  Queue_exports,
+  Redacted_exports,
+  Ref_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/mcp.ts
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import {
+  ErrorCode as ErrorCode3,
+  McpError as ProtocolError3,
+  ToolListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { SSEClientTransport, SseError } from "@modelcontextprotocol/sdk/client/sse.js";
+import {
+  StreamableHTTPClientTransport,
+  StreamableHTTPError
+} from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// src/implementation/mcp-tools.ts
+var resultFields = {
+  content: { type: "array", items: { type: "object" } },
+  structuredContent: { type: "object" },
+  isError: { type: "boolean" },
+  _meta: { type: "object" }
+};
+var definitionReference = /^#\/(?:\$defs|definitions)\/[^/]+$/;
+var locating = /* @__PURE__ */ new Set(["$id", "$anchor", "$dynamicAnchor", "$recursiveAnchor"]);
+var onlyDefinitionReferences = (value) => Array.isArray(value) ? value.every(onlyDefinitionReferences) : value === null || typeof value !== "object" ? true : Object.entries(value).every(
+  ([key, item]) => locating.has(key) || key === "$dynamicRef" || key === "$recursiveRef" ? false : key === "$ref" ? typeof item === "string" && definitionReference.test(item) : onlyDefinitionReferences(item)
+);
+var placed = (structuredContent, pointer) => {
+  if (onlyDefinitionReferences(structuredContent)) {
+    const { $defs, definitions, $schema: _draft, ...schema } = structuredContent;
+    return {
+      schema,
+      root: {
+        ...$defs === void 0 ? {} : { $defs },
+        ...definitions === void 0 ? {} : { definitions }
+      }
+    };
+  }
+  try {
+    return { schema: nestJsonSchema(structuredContent, pointer), root: {} };
+  } catch {
+    return { schema: structuredContent, root: {} };
+  }
+};
+var resultSchema = (structuredContent) => {
+  if (structuredContent === void 0)
+    return { type: "object", properties: resultFields, required: ["content"] };
+  const { schema, root } = placed(structuredContent, "#/anyOf/0/properties/structuredContent");
+  return {
+    // The envelope's keywords mean the same in every draft, so the server's draft applies.
+    ...structuredContent.$schema === void 0 ? {} : { $schema: structuredContent.$schema },
+    ...root,
+    anyOf: [
+      {
+        type: "object",
+        properties: { ...resultFields, structuredContent: schema, isError: { const: false } },
+        required: ["content", "structuredContent"]
+      },
+      {
+        type: "object",
+        properties: { ...resultFields, isError: { const: true } },
+        required: ["content", "isError"]
+      }
+    ]
+  };
+};
+var adaptMcpTool = (client, tool) => Effect_exports.gen(function* () {
+  const decoder = yield* jsonSchemaDecoder(tool.inputSchema).pipe(
+    Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
+  );
+  const output = preparedJsonSchemaDecoder(resultSchema(tool.outputSchema));
+  const { outputSchema: _upstream, ...metadata } = tool;
+  const adapted = {
+    ...metadata,
+    description: tool.description ?? tool.title ?? tool.name,
+    input: decoder,
+    output: output.decoder,
+    ...tool.annotations?.readOnlyHint === void 0 ? {} : { readOnly: tool.annotations.readOnlyHint },
+    run: (context, input) => Effect_exports.gen(function* () {
+      const arguments_ = yield* Schema_exports.decodeUnknownEffect(decoder)(input).pipe(
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonObject)),
+        Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_input" }))
+      );
+      yield* output.compile.pipe(
+        Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
+      );
+      const result = yield* client.call(tool.name, arguments_, context);
+      if (result.isError === true) {
+        (yield* ToolResultObservation).failed();
+        yield* Effect_exports.annotateCurrentSpan({
+          "executor.outcome": "failed",
+          "error.type": "McpToolError"
+        });
+      }
+      return result;
+    })
+  };
+  return adapted;
+});
+var adaptMcpTools = (client) => Effect_exports.gen(function* () {
+  const { tools: metadata } = yield* client.list;
+  const entries = yield* Effect_exports.forEach(
+    metadata,
+    (tool) => adaptMcpTool(client, tool).pipe(Effect_exports.map((adapted) => [tool.name, adapted]))
+  );
+  return Object.fromEntries(entries);
+});
+
+// src/implementation/mcp-client.ts
+import {
+  ErrorCode as ErrorCode2,
+  ListToolsResultSchema,
+  McpError as ProtocolError2
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/implementation/mcp-call.ts
+import {
+  ElicitRequestSchema,
+  ElicitResultSchema,
+  ErrorCode,
+  McpError as ProtocolError
+} from "@modelcontextprotocol/sdk/types.js";
+function callBudget(timeoutMs) {
+  return Effect_exports.gen(function* () {
+    const clock = yield* Clock_exports.Clock;
+    const changes = yield* Queue_exports.unbounded();
+    let remaining = timeoutMs, updated = clock.currentTimeMillisUnsafe(), waiting = 0;
+    const account = () => {
+      const now = clock.currentTimeMillisUnsafe();
+      if (waiting === 0) remaining -= Math.max(0, now - updated);
+      updated = now;
+      return remaining;
+    };
+    return {
+      waitForInput: (input) => Effect_exports.acquireUseRelease(
+        Effect_exports.sync(() => {
+          account();
+          waiting++;
+        }).pipe(Effect_exports.andThen(Queue_exports.offer(changes, void 0))),
+        () => input,
+        () => Effect_exports.sync(() => {
+          account();
+          waiting--;
+        }).pipe(Effect_exports.andThen(Queue_exports.offer(changes, void 0)))
+      ),
+      expired: Effect_exports.gen(function* () {
+        while (true) {
+          const left = account();
+          if (waiting === 0 && left <= 0)
+            return yield* new McpError({ phase: "call", reason: "timeout" });
+          if (waiting > 0) yield* Queue_exports.take(changes);
+          else yield* Queue_exports.take(changes).pipe(Effect_exports.raceFirst(Effect_exports.sleep(Math.max(1, left))));
+        }
+      })
+    };
+  });
+}
+var mcpCall = (client, name, input, context, timeoutMs, failure2) => Effect_exports.scoped(
+  Effect_exports.gen(function* () {
+    const budget = yield* callBudget(timeoutMs);
+    const failed = yield* Deferred_exports.make();
+    const runtime = yield* Effect_exports.context();
+    const callbacks = /* @__PURE__ */ new Set();
+    const lifetime = yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(() => new AbortController()),
+      (controller) => (
+        // oxlint-disable-next-line executor/authored-code-through-adapter -- the MCP SDK's elicitation callbacks
+        Effect_exports.promise(async () => {
+          controller.abort();
+          client.removeRequestHandler("elicitation/create");
+          await Promise.allSettled(callbacks);
+        })
+      )
+    );
+    client.setRequestHandler(ElicitRequestSchema, (request, extra) => {
+      const signal = AbortSignal.any([lifetime.signal, extra.signal]);
+      const interaction = Effect_exports.gen(function* () {
+        const form = yield* prepareElicitation({
+          ...request.params,
+          mode: request.params.mode ?? "form"
+        });
+        const deliver = context.elicit;
+        if (deliver === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
+        const answer = yield* budget.waitForInput(
+          fromPromise(
+            deliver,
+            "elicitation"
+          )(form.request).pipe(
+            Effect_exports.mapError(
+              (error) => Option_exports.getOrElse(
+                Schema_exports.decodeUnknownOption(ElicitationFailed)(error),
+                () => new ElicitationFailed({ reason: "transport" })
+              )
+            ),
+            Effect_exports.timeoutOrElse({
+              duration: defaultElicitationLimits.timeoutMs,
+              orElse: () => Effect_exports.fail(new ElicitationFailed({ reason: "expired" }))
+            })
+          )
+        ).pipe(Effect_exports.withSpan("provider.mcp.elicitation"));
+        return yield* form.respond(answer).pipe(
+          Effect_exports.flatMap(
+            (response) => Effect_exports.try({
+              try: () => ElicitResultSchema.parse(response),
+              catch: () => new ElicitationFailed({ reason: "invalid-response" })
+            })
+          )
+        );
+      }).pipe(Effect_exports.tapError((error) => Deferred_exports.fail(failed, error)));
+      const callback = Effect_exports.runPromiseWith(runtime)(interaction, { signal }).catch(() => {
+        if (!lifetime.signal.aborted)
+          Effect_exports.runSync(Deferred_exports.fail(failed, new ElicitationFailed({ reason: "transport" })));
+        throw new ProtocolError(ErrorCode.InternalError, "User input could not be delivered");
+      });
+      callbacks.add(callback);
+      return callback.finally(() => callbacks.delete(callback));
+    });
+    return yield* Effect_exports.tryPromise({
+      try: (signal) => client.callTool({ name, arguments: input }, void 0, {
+        signal: AbortSignal.any([signal, lifetime.signal]),
+        timeout: mcpSdkTimerCeilingMs
+      }),
+      catch: (error) => failure2("call", error)
+    }).pipe(
+      Effect_exports.raceFirst(Deferred_exports.await(failed)),
+      Effect_exports.raceFirst(budget.expired),
+      Effect_exports.flatMap(
+        (result) => Schema_exports.decodeUnknownEffect(McpToolResult)(result).pipe(
+          Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_response" }))
+        )
+      ),
+      Effect_exports.tap(
+        (result) => Effect_exports.annotateCurrentSpan("mcp.tool.is_error", result.isError === true)
+      )
+    );
+  })
+).pipe(
+  owned("upstream", "provider.mcp.request", {
+    kind: "client",
+    attributes: {
+      "rpc.system.name": "jsonrpc",
+      "rpc.method": "tools/call",
+      "mcp.tool.name": name
+    }
+  })
+);
+
+// src/implementation/mcp-client.ts
+var clientCodes = /* @__PURE__ */ new Set([
+  ErrorCode2.RequestTimeout,
+  ErrorCode2.ConnectionClosed
+]);
+var answeredError = (error) => {
+  if (!(error instanceof ProtocolError2) || clientCodes.has(error.code)) return void 0;
+  const prefix = `MCP error ${error.code}: `;
+  return bodyUpstreamError({
+    error: {
+      code: error.code,
+      message: error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message
+    }
+  });
+};
+var mcpJsonSchemaValidator = {
+  getValidator(document) {
+    const decoder = Effect_exports.runSync(jsonSchemaDecoder(document));
+    return (input) => {
+      const result = Effect_exports.runSyncExit(Schema_exports.decodeUnknownEffect(decoder)(input));
+      if (Exit_exports.isFailure(result))
+        return {
+          valid: false,
+          data: void 0,
+          errorMessage: "Value does not match the supported JSON Schema"
+        };
+      return { valid: true, data: result.value, errorMessage: void 0 };
+    };
+  }
+};
+function mcpClient(withClient2, timeoutMs, failure2) {
+  const list = withClient2(
+    "discover",
+    (client) => Effect_exports.gen(function* () {
+      const tools = /* @__PURE__ */ new Map();
+      const cursors = /* @__PURE__ */ new Set();
+      let cursor;
+      do {
+        const page = yield* Effect_exports.tryPromise({
+          // This session only reads metadata. listTools() also eagerly compiles
+          // every output validator; mcpRouter validates the selected tool on call.
+          try: (signal) => client.request(
+            { method: "tools/list", params: cursor === void 0 ? {} : { cursor } },
+            ListToolsResultSchema,
+            { signal, timeout: timeoutMs }
+          ),
+          catch: (error) => failure2("discover", error)
+        }).pipe(
+          owned("upstream", "provider.mcp.request", {
+            kind: "client",
+            attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
+          })
+        );
+        const metadata = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(McpToolMetadata))(
+          page.tools
+        ).pipe(
+          Effect_exports.mapError(() => new McpError({ phase: "discover", reason: "invalid_response" }))
+        );
+        for (const tool of metadata) {
+          if (!tool.name || tools.has(tool.name) || tools.size >= defaultMcpClientLimits.maxTools)
+            return yield* new McpError({ phase: "discover", reason: "invalid_response" });
+          tools.set(tool.name, tool);
+        }
+        cursor = page.nextCursor;
+        if (cursor !== void 0) {
+          if (cursors.has(cursor) || cursors.size >= defaultMcpClientLimits.maxPaginationCursors)
+            return yield* new McpError({ phase: "discover", reason: "invalid_response" });
+          cursors.add(cursor);
+        }
+      } while (cursor !== void 0);
+      const info = client.getServerVersion();
+      const instructions = client.getInstructions();
+      const icons = info?.icons?.flatMap(
+        (icon) => Option_exports.toArray(Schema_exports.decodeUnknownOption(RouterIcon)(icon))
+      );
+      const server = Schema_exports.decodeUnknownOption(McpServerHeader)({
+        ...info?.name === void 0 ? {} : { name: info.name },
+        ...info?.title === void 0 ? {} : { title: info.title },
+        ...info?.version === void 0 ? {} : { version: info.version },
+        ...info?.description === void 0 ? {} : { description: info.description },
+        ...info?.websiteUrl === void 0 ? {} : { websiteUrl: info.websiteUrl },
+        ...icons === void 0 ? {} : { icons },
+        ...instructions === void 0 ? {} : { instructions }
+      });
+      return {
+        tools: [...tools.values()],
+        server: Option_exports.getOrElse(server, () => ({}))
+      };
+    })
+  ).pipe(owned("upstream", "provider.mcp.discover"));
+  const check = withClient2(
+    "discover",
+    (client) => (
+      // oxlint-disable-next-line executor/authored-code-through-adapter -- MCP SDK
+      Effect_exports.tryPromise({
+        try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
+          signal,
+          timeout: timeoutMs
+        }),
+        catch: (error) => failure2("discover", error)
+      }).pipe(
+        Effect_exports.asVoid,
+        owned("upstream", "provider.mcp.request", {
+          kind: "client",
+          attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
+        })
+      )
+    )
+  ).pipe(owned("upstream", "provider.mcp.check"));
+  const call = (name, input, context) => withClient2("call", (client) => mcpCall(client, name, input, context, timeoutMs, failure2)).pipe(
+    owned("upstream", "provider.mcp.call", { attributes: { "mcp.tool.name": name } })
+  );
+  return { list, check, call };
+}
+
+// src/implementation/mcp.ts
+var unreadable = (error) => error instanceof SyntaxError || error instanceof Error && Predicate_exports.hasProperty(error, "issues") && Array.isArray(error.issues);
+var failure = (phase, error) => {
+  if (Schema_exports.is(ProviderError)(error) || Schema_exports.is(McpError)(error) || Schema_exports.is(NetworkRefused)(error))
+    return error;
+  const code = error instanceof UnauthorizedError ? 401 : error instanceof StreamableHTTPError || error instanceof SseError ? error.code : void 0;
+  if (code !== void 0 && code >= 300 && code <= 599)
+    return httpProviderError(code) ?? new McpError({ phase, reason: "request", status: code });
+  const upstream = answeredError(error);
+  return new McpError({
+    phase,
+    reason: code !== void 0 || unreadable(error) ? "invalid_response" : error instanceof ProtocolError3 && error.code === ErrorCode3.RequestTimeout ? "timeout" : "request",
+    ...upstream === void 0 ? {} : { upstream }
+  });
+};
+var errorBodyLimits = { maxBytes: 65536, readTimeoutMs: 2e3 };
+var errorBody = (response) => Effect_exports.gen(function* () {
+  const json = /^application\/(?:[\w.-]+\+)?json$/i.test(
+    response.headers["content-type"]?.split(";")[0]?.trim() ?? ""
+  );
+  const length = response.headers["content-length"];
+  if (!json || length !== void 0 && Number(length) > errorBodyLimits.maxBytes)
+    return { body: Stream_exports.toReadableStream(response.stream), upstream: void 0 };
+  const unreadable2 = new McpError({ phase: "transport", reason: "invalid_response" });
+  const read = yield* response.stream.pipe(
+    Stream_exports.mapError(() => unreadable2),
+    Stream_exports.limitBytes(errorBodyLimits.maxBytes, () => Stream_exports.fail(unreadable2)),
+    Stream_exports.decodeText,
+    Stream_exports.mkString,
+    Effect_exports.timeout(errorBodyLimits.readTimeoutMs),
+    Effect_exports.option
+  );
+  if (Option_exports.isNone(read)) return { body: null, upstream: void 0 };
+  const parsed = Schema_exports.decodeUnknownOption(Schema_exports.fromJsonString(Schema_exports.Json))(read.value);
+  return {
+    body: read.value,
+    upstream: Option_exports.isSome(parsed) ? bodyUpstreamError(parsed.value) : void 0
+  };
+});
+var transportFetch = (connection, telemetry, rejected, answered) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
+  Effect_exports.gen(function* () {
+    const target = yield* Effect_exports.try({
+      try: () => new URL(url),
+      catch: () => new McpError({ phase: "transport", reason: "invalid_response" })
+    });
+    if (connection.url.username || connection.url.password)
+      return yield* new McpError({ phase: "transport", reason: "invalid_input" });
+    if (target.origin !== connection.url.origin || target.username || target.password)
+      return yield* new McpError({ phase: "transport", reason: "invalid_response" });
+    const request = yield* Effect_exports.try({
+      try: () => {
+        const headers = new Headers(Redacted_exports.value(connection.headers));
+        new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+        if (!headers.has("user-agent")) headers.set("user-agent", "Executor");
+        return HttpClientRequest_exports.fromWeb(new Request(target, { ...init, headers }));
+      },
+      // The provider's headers cannot form an HTTP request, such as a name with a space.
+      catch: () => new McpError({ phase: "transport", reason: "invalid_input" })
+    });
+    const client = yield* HttpClient_exports.HttpClient;
+    const response = yield* client.execute(request);
+    yield* failOnNetworkRefusal(response).pipe(
+      Effect_exports.tapError((refused) => Deferred_exports.fail(rejected, refused))
+    );
+    if (response.status < 400)
+      return new Response(
+        [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
+        {
+          status: response.status,
+          headers: response.headers
+        }
+      );
+    const { body, upstream } = yield* errorBody(response);
+    const provider = httpProviderError(response.status, response.headers);
+    if (provider !== void 0) {
+      const refused = providerErrorDetail(provider, { upstream });
+      yield* Deferred_exports.fail(rejected, refused);
+      return yield* refused;
+    }
+    const session = new Headers(init?.headers).has("mcp-session-id");
+    yield* Ref_exports.update(
+      answered,
+      (responses) => new Map(responses).set(response.status, { upstream, session })
+    );
+    return new Response(body, { status: response.status, headers: response.headers });
+  }).pipe(
+    Effect_exports.provide(FetchHttpClient_exports.layer),
+    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
+    Effect_exports.provideService(
+      FetchHttpClient_exports.Fetch,
+      (url2, options) => globalThis.fetch(url2, {
+        ...options,
+        signal: AbortSignal.any([
+          ...options?.signal ? [options.signal] : [],
+          ...init?.signal ? [init.signal] : []
+        ])
+      })
+    ),
+    Effect_exports.mapError((error) => failure("transport", error))
+  ),
+  init?.signal ? { signal: init.signal } : {}
+);
+var explain = (error, phase, responses) => {
+  if (Schema_exports.is(ProviderError)(error)) return providerErrorDetail(error, { phase });
+  if (phase === "call" && Schema_exports.is(McpError)(error) && error.phase === "transport" && error.reason === "request")
+    return new McpError({
+      phase,
+      reason: error.reason,
+      ...error.status === void 0 ? {} : { status: error.status },
+      ...error.upstream === void 0 ? {} : { upstream: error.upstream }
+    });
+  if (!Schema_exports.is(McpError)(error) || error.status === void 0) return error;
+  const response = responses.get(error.status);
+  if (response === void 0 || (error.upstream !== void 0 || response.upstream === void 0) && !response.session)
+    return error;
+  const upstream = error.upstream ?? response.upstream;
+  return new McpError({
+    phase: error.phase,
+    reason: error.reason,
+    status: error.status,
+    ...upstream === void 0 ? {} : { upstream },
+    ...response.session ? { session: true } : {}
+  });
+};
+var explained = (phase, answered) => (error) => Ref_exports.get(answered).pipe(
+  Effect_exports.flatMap((responses) => Effect_exports.fail(explain(error, phase, responses)))
+);
+function withClient(connection, mode, use, changed) {
+  const attempt = (kind) => Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const telemetry = yield* captureTelemetry;
+      const rejected = yield* Deferred_exports.make();
+      const answered = yield* Ref_exports.make(/* @__PURE__ */ new Map());
+      const pending = /* @__PURE__ */ new Set();
+      const { client, transport } = yield* Effect_exports.acquireRelease(
+        Effect_exports.sync(() => {
+          const fetch = transportFetch(connection, telemetry, rejected, answered);
+          const client2 = new Client(
+            { name: "executor-apps", version: "0.1.0" },
+            {
+              jsonSchemaValidator: mcpJsonSchemaValidator,
+              capabilities: mode === "call" ? { elicitation: { form: {} } } : {}
+            }
+          );
+          if (changed !== void 0) {
+            client2.setNotificationHandler(ToolListChangedNotificationSchema, () => {
+              const task = Effect_exports.runPromiseWith(telemetry.context)(
+                changed.pipe(
+                  Effect_exports.timeout("5 seconds"),
+                  Effect_exports.catchCause(() => Effect_exports.logWarning("MCP catalog invalidation failed"))
+                )
+              );
+              pending.add(task);
+              return task.finally(() => pending.delete(task));
+            });
+          }
+          return {
+            client: client2,
+            transport: kind === "http" ? new StreamableHTTPClientTransport(connection.url, {
+              fetch,
+              reconnectionOptions: {
+                maxRetries: 0,
+                initialReconnectionDelay: 1e3,
+                maxReconnectionDelay: 1e3,
+                reconnectionDelayGrowFactor: 1
+              }
+            }) : new SSEClientTransport(connection.url, { fetch })
+          };
+        }),
+        ({ client: client2, transport: transport2 }) => Effect_exports.gen(function* () {
+          client2.removeNotificationHandler("notifications/tools/list_changed");
+          yield* Effect_exports.promise(async () => {
+            await Promise.allSettled(pending);
+          });
+          if (transport2 instanceof StreamableHTTPClientTransport && transport2.sessionId !== void 0) {
+            yield* Effect_exports.tryPromise(() => transport2.terminateSession()).pipe(
+              Effect_exports.timeout(defaultMcpClientLimits.cleanupTimeoutMs),
+              Effect_exports.ignore
+            );
+          }
+          yield* Effect_exports.tryPromise(() => client2.close()).pipe(
+            Effect_exports.timeout(defaultMcpClientLimits.cleanupTimeoutMs),
+            Effect_exports.ignore
+          );
+        }).pipe(owned("upstream", "provider.mcp.close"))
+      );
+      const wire = transport;
+      yield* Effect_exports.tryPromise({
+        try: (signal) => client.connect(wire, { signal, timeout: connection.timeoutMs }),
+        catch: (error) => failure("connect", error)
+      }).pipe(
+        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.catch(explained("connect", answered)),
+        Effect_exports.timeout(connection.timeoutMs),
+        owned("upstream", "provider.mcp.connect")
+      );
+      return yield* use(client).pipe(
+        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.catch(explained(mode, answered))
+      );
+    })
+  ).pipe(
+    owned("upstream", "provider.mcp.session", {
+      attributes: {
+        "mcp.transport": kind,
+        "mcp.operation": mode,
+        "server.address": connection.url.hostname
+      }
+    })
+  );
+  return attempt("http").pipe(
+    // Fallback is only for negotiation. Tool calls are never automatically replayed.
+    Effect_exports.catch(
+      (error) => Schema_exports.is(McpError)(error) && error.phase === "connect" && (error.status === 404 || error.status === 405) ? attempt("sse") : Effect_exports.fail(error)
+    ),
+    (operation) => mode === "discover" ? operation.pipe(Effect_exports.timeout(connection.timeoutMs)) : operation,
+    Effect_exports.catchTag(
+      "TimeoutError",
+      () => Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
+    )
+  );
+}
+var mcpClientEffect = (input, changed) => Effect_exports.gen(function* () {
+  const options = yield* Schema_exports.decodeUnknownEffect(McpToolsOptions)(input).pipe(
+    Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" }))
+  );
+  const url = new URL(options.url);
+  if (url.username || url.password || url.hash)
+    return yield* new McpError({ phase: "connect", reason: "invalid_input" });
+  const connection = {
+    url,
+    headers: Redacted_exports.make({ ...options.headers }),
+    timeoutMs: options.timeoutMs ?? defaultMcpClientLimits.timeoutMs
+  };
+  return mcpClient(
+    (mode, use) => withClient(connection, mode, use, changed).pipe(
+      Effect_exports.mapError(
+        (error) => options.accountId === void 0 ? error : accountProviderError(error, options.accountId)
+      )
+    ),
+    connection.timeoutMs,
+    failure
+  );
+});
+var refusesCredentials = (error) => Schema_exports.is(ProviderError)(error) && Match_exports.value(error.reason).pipe(
+  Match_exports.whenOr("unauthorized", "forbidden", "rejected", () => true),
+  Match_exports.whenOr("rate_limited", "unavailable", () => false),
+  Match_exports.exhaustive
+);
+var mcpHealthEffect = (check, options) => Effect_exports.gen(function* () {
+  const { deadline, timeoutMs, ...parsed } = yield* Schema_exports.decodeUnknownEffect(McpHealthInput)({
+    ...options,
+    accountId: check.account.id,
+    signal: check.signal,
+    deadline: check.deadline
+  }).pipe(Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" })));
+  const end = Math.min(
+    (yield* Clock_exports.currentTimeMillis) + (timeoutMs ?? defaultMcpClientLimits.timeoutMs),
+    deadline === void 0 ? Number.POSITIVE_INFINITY : deadline - mcpHealthReserveMs
+  );
+  const remaining = Effect_exports.flatMap(
+    Clock_exports.currentTimeMillis,
+    (now) => end - now >= 1 ? Effect_exports.succeed(Math.floor(end - now)) : Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
+  );
+  yield* (yield* mcpClientEffect({ ...parsed, timeoutMs: yield* remaining })).check;
+  return yield* remaining.pipe(
+    Effect_exports.flatMap(
+      (timeoutMs2) => mcpClientEffect({ url: parsed.url, signal: parsed.signal, timeoutMs: timeoutMs2 })
+    ),
+    Effect_exports.flatMap((anonymous) => anonymous.check),
+    Effect_exports.matchEffect({
+      onSuccess: () => Effect_exports.fail(new McpCredentialsUnverified({ anonymous: "answered" })),
+      // Executor's network refused the attempt, so the server never answered it.
+      onFailure: (error) => Schema_exports.is(NetworkRefused)(error) ? Effect_exports.fail(error) : refusesCredentials(error) ? Effect_exports.void : Effect_exports.fail(new McpCredentialsUnverified({ anonymous: error }))
+    }),
+    owned("upstream", "provider.mcp.anonymous")
+  );
+}).pipe(owned("upstream", "provider.mcp.health"));
+var mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
+
+export {
+  adaptMcpTool,
+  mcpClientEffect,
+  mcpHealthEffect,
+  mcpToolsEffect
+};