apps 0.0.1-beta.9 → 0.0.1-beta.91

package/types/telemetry/src/recorded-failure.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Failures as Executor's telemetry records them. Traces and error reports keep an error's text only
+ * when Executor wrote it: a tagged error is recorded by its tag and the fixed sentence it declares
+ * (see `RecordedMessage`), or by its tag alone when it declares none. Its fields, message, stack and
+ * cause are not recorded, so a value an error carries for its caller, an app's text or a service's
+ * reply cannot reach telemetry by an error forgetting to declare. The error itself, and what its
+ * caller receives, are unchanged.
+ */
+import { Cause } from "effect";
+/**
+ * The error a trace or error report records in place of `error`.
+ *
+ * - A tagged error is named by its tag: a field called `name`, such as a requested skill's or an
+ *   app's, replaces the error's own name. Its message is the sentence it declares, or empty. Its
+ *   stack is generated here and names no frames: the error's own stack begins with its message,
+ *   which can span lines that look like frames. Traces still show where it failed through the
+ *   operation's own spans, which Effect appends to a recorded stack.
+ * - Any other value that is not an `Error`, such as a plain object Effect would print as JSON, is
+ *   recorded as `UnrecognizedFailure` with no text.
+ * - An untagged `Error` is a defect or a platform's error: its message and stack come from the
+ *   JavaScript engine or a library and are kept, as they are the only diagnosis of an Executor bug.
+ *   Its cause is recorded by these same rules.
+ */
+export declare const recordedError: (error: unknown) => unknown;
+/**
+ * A failure's cause as traces record it: each failure and defect by `recordedError`. Interruptions
+ * are unchanged, and each reason keeps its annotations, which locate it.
+ */
+export declare const recordedCause: <E>(cause: Cause.Cause<E>) => Cause.Cause<unknown>;

package/types/telemetry/src/relay.d.ts

@@ -2,11 +2,13 @@
 import { Effect, Schema } from "effect";
 /**
  * Forward app telemetry in the host scope without delaying an app result.
- * One export runs at a time, with at most sixteen pending batches. Overload and
- * shutdown loss are reported through the normal safe export-failure signal.
- * Scope release drains for the same three-second budget as the other exporters.
+ * Batches wait in one queue and a single sender exports everything waiting as one request per
+ * signal, so a burst of finished runs costs a few exports instead of one each. The queue holds at
+ * most eight MiB of payload and one export carries at most four. Overload and shutdown loss are
+ * reported through the normal safe export-failure signal. Scope release drains for the same
+ * three-second budget as the other exporters.
  */
-export declare const makeTelemetryForwarder: Effect.Effect<(batch: TelemetryBatch, traceId: string, build?: string) => Effect.Effect<void, never, never>, never, import("effect/Scope").Scope>;
+export declare const makeTelemetryForwarder: Effect.Effect<(batch: TelemetryBatch, traceId: string, source: TelemetrySource) => Effect.Effect<void, never, never>, never, import("effect/Scope").Scope>;
 /** Untrusted isolate batches are bounded before decoding; no endpoint or credential crosses back. */
 export declare const TelemetryBatch: Schema.Struct<{
     readonly traces: Schema.$Array<Schema.String>;
@@ -23,6 +25,14 @@ export declare const collectTelemetry: <A, E, R>(effect: Effect.Effect<A, E, R>)
         logs: string[];
         dropped: number;
     };
-}, E, Exclude<Exclude<R, import("effect/unstable/observability/OtlpExporter").Flusher>, never>>;
+}, E, Exclude<Exclude<R, import("effect/observability/OtlpExporter").Flusher>, never>>;
+/**
+ * What the host knows about the records' source, from its own invocation rather than the records:
+ * the build that ran and, for an app isolate, the app's opaque ID. Both become resource attributes.
+ */
+export interface TelemetrySource {
+    readonly build?: string | undefined;
+    readonly app?: string | undefined;
+}
 /** Validate isolated records and export only this call's trace, using parent-owned credentials/identity. */
-export declare const forwardTelemetry: (batch: TelemetryBatch, traceId: string | undefined, build: string | undefined, service?: "executor-app" | "executor-web") => Effect.Effect<void, Schema.SchemaError | import("effect/unstable/http/HttpClientError").HttpClientError | import("effect/Cause").TimeoutError, never>;
+export declare const forwardTelemetry: (batch: TelemetryBatch, traceId: string | undefined, source: TelemetrySource, service?: "executor-app" | "executor-web") => Effect.Effect<void, Schema.SchemaError | import("effect/http/HttpClientError").HttpClientError | import("effect/Cause").TimeoutError, never>;

package/types/telemetry/src/span-attributes.d.ts

@@ -18,11 +18,27 @@
  *
  * Attributes outside these namespaces are the product's own and pass through.
  */
-import { Layer } from "effect";
+import { Effect, Layer } from "effect";
 /** Every HTTP attribute an exported span may carry. */
 export declare const httpSpanAttributeAllowlist: ReadonlySet<string>;
 /** Record this attribute? HTTP names must be allowlisted; product names pass through. */
 export declare const spanAttributeAllowed: (key: string) => boolean;
+/**
+ * Record the template of a route whose path an app or its caller chose, in place of the router's
+ * wildcard: an app's own page or asset, or an app's outbound request. Its last parameter stands
+ * for the rest of the path. It annotates the current span, so call it from the request's handler.
+ */
+export declare const recordRoute: (template: `/${string}`) => Effect.Effect<void, never, never>;
+/**
+ * A fixed set of endpoint templates served under one wildcard route, such as Better Auth's
+ * endpoints under `/api/auth/*`. `:name` stands for one segment. `record` names the request's
+ * endpoint by its template and leaves the wildcard for any path the set does not hold, so a span
+ * keeps which endpoint ran without any segment the caller chose.
+ */
+export declare const routeTemplates: (templates: Iterable<`/${string}`>) => {
+    match: (path: string) => `/${string}` | undefined;
+    record: (path: string) => Effect.Effect<void, never, never>;
+};
 /** Wrap whichever tracer is already in scope; provide this above the exporter. */
 export declare const spanAttributes: (clock?: "system" | "cloudflare-io", recordAll?: boolean) => Layer.Layer<never>;
 /** Header and URL filtering without making an unsupported claim about the runtime clock. */

package/types/telemetry/src/transport.d.ts

@@ -1,6 +1,13 @@
 import { Context, Layer } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient, HttpClientError } from "effect/http";
 /** Local collector discovery can resolve its destination when an export runs. */
 export declare const CurrentTelemetryClient: Context.Reference<HttpClient.HttpClient | undefined>;
 /** Telemetry consumers inspect status and headers; release response I/O inside each export scope. */
 export declare const telemetryHttpClient: Layer.Layer<HttpClient.HttpClient, never, never>;
+/**
+ * Resend an export the collector refused for now, as OTLP requires and Effect's own
+ * exporters do: lost connections, 429 and 5xx overload, at most three more times. A
+ * collector shedding load answers 429 or 503 with Retry-After, which sets the wait. A
+ * wait longer than the caller's budget ends with the budget, without sending again.
+ */
+export declare const retryTelemetryExport: (client: HttpClient.HttpClient) => HttpClient.HttpClient.With<HttpClientError.HttpClientError, never>;

package/types/utils/src/api-error.d.ts

@@ -0,0 +1,55 @@
+import { Schema, type Cause } from "effect";
+import "effect/http-api";
+/**
+ * Encode the class's `message` getter as a required wire string. Decoding validates the field,
+ * then omits it, so the class derives its own message from the parsed payload and a supplied
+ * value never replaces it.
+ */
+export declare const MessageField: Schema.decodeTo<Schema.optionalKey<Schema.String>, Schema.String, never, never>;
+/** An expected API error whose response states its cause in a `message` derived from its fields. */
+export interface ApiError extends Cause.YieldableError {
+    readonly _tag: string;
+}
+type Header<Tag extends string> = {
+    readonly tag: Tag;
+    readonly status: number;
+};
+type Definition<Tag extends string, Fields extends Schema.Struct.Fields> = Header<Tag> & {
+    readonly fields: Fields & {
+        readonly [Key in "_tag" | "message"]?: never;
+    };
+    /**
+     * The cause, stated for API and agent callers. It is also the error's `message`, which traces
+     * record, so it never includes credentials, upstream response text or submitted values.
+     */
+    readonly message: string | ((fields: Schema.Struct.Type<Fields>) => string);
+    /**
+     * What traces and error reports record beside the tag. A fixed `message` is recorded as is; a
+     * message derived from fields is recorded only through this, from fixed text and closed fields,
+     * never a value the caller chose, an app's text or a service's reply. Without it the error is
+     * recorded by its tag alone.
+     */
+    readonly recorded?: (fields: Schema.Struct.Type<Fields>) => string;
+};
+type ErrorFields<Tag extends string, Fields extends Schema.Struct.Fields> = Omit<Schema.TaggedStruct<Tag, Fields & {
+    readonly message: typeof MessageField;
+}>, "~type.make.in"> & {
+    readonly "~type.make.in": Schema.TaggedStruct<Tag, Fields>["~type.make.in"];
+};
+type ErrorClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<Schema.Struct.Type<Fields> & ApiError & {
+    readonly _tag: Tag;
+}, ErrorFields<Tag, Fields>, ApiError>;
+/** Define an error with no payload and a fixed message. Its tag is its public error code. */
+declare function define<const Tag extends string>(definition: Header<Tag> & {
+    readonly message: string;
+}): ErrorClass<Tag, {}>;
+/** Define an error whose message can depend on its parsed fields. */
+declare function define<const Tag extends string, const Fields extends Schema.Struct.Fields>(definition: Definition<Tag, Fields>): ErrorClass<Tag, Fields>;
+/**
+ * Define the schema, constructor and API message of an expected error together. Errors that need
+ * a user-facing title and recovery use `UserFacingError`, which carries the same message field.
+ */
+export declare const ApiError: {
+    define: typeof define;
+};
+export {};

package/types/utils/src/connection-failure.d.ts

@@ -0,0 +1,33 @@
+/** Requests the browser could not complete because no response reached it. */
+import { Cause } from "effect";
+import { HttpClientError } from "effect/http";
+import { UserFacingError } from "./user-facing-error.js";
+/**
+ * Fetch rejects with a `TypeError` when no response arrives: the device is offline, the page
+ * navigated away first, the connection was reset before a response, or the browser blocked the
+ * request. The server may still have completed the request and records its own outcome. Failures Executor constructs itself, such as a batch reply
+ * that ended without an answer, carry no such cause and stay unexpected.
+ */
+export declare const isConnectionFailure: (error: unknown) => error is HttpClientError.HttpClientError;
+/** Typed API clients may surface a lost connection as a failure or, after narrowing, a defect. */
+export declare const hasConnectionFailure: (cause: Cause.Cause<unknown>) => boolean;
+/** The browser could not reach Executor. Nothing on the server needs fixing. */
+export declare const ConnectionFailed: import("effect/Schema").Class<{} & UserFacingError & {
+    readonly _tag: "ConnectionFailed";
+}, Omit<import("effect/Schema").TaggedStruct<"ConnectionFailed", {
+    readonly message: typeof import("./api-error.js").MessageField;
+    readonly recovery: import("effect/Schema").decodeTo<import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly action: import("effect/Schema").String;
+        readonly instructions: import("effect/Schema").String;
+    }>>, import("effect/Schema").Struct<{
+        readonly action: import("effect/Schema").String;
+        readonly instructions: import("effect/Schema").String;
+    }>, never, never>;
+}>, "~type.make.in"> & {
+    readonly "~type.make.in": {
+        readonly _tag?: "ConnectionFailed";
+    };
+}, UserFacingError>;
+export type ConnectionFailed = typeof ConnectionFailed.Type;
+/** What to show for a failure no contract declares: a lost connection, or an unexpected error. */
+export declare const undeclaredError: (cause: Cause.Cause<unknown>) => UserFacingError;

package/types/utils/src/recorded-message.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The fixed sentence traces and error reports record for a tagged error, beside its tag. Telemetry
+ * records no other text from a tagged error: one that declares no sentence is recorded by its tag
+ * alone (`@executor-js/telemetry/recorded-failure`). Declare one from fixed text and closed fields
+ * only, never from a value the caller supplied (a slug, a name, a tool name, an argument's key),
+ * an app's own text or a service's reply. That text still reaches the caller the error is for.
+ * `ApiError` and `UserFacingError` declare a fixed message for you; a message derived from fields
+ * declares `recorded`.
+ */
+export declare const RecordedMessage: unique symbol;
+/** The fixed sentence an error declares for telemetry, if it declares one. */
+export declare const recordedMessage: (error: unknown) => string | undefined;
+/**
+ * Declare a recorded message on one error that Executor did not define the text of, such as an
+ * error decoded from an app's reply. An error class's own declaration is kept. The error's fields
+ * and wire encoding are unchanged.
+ */
+export declare const recordAs: <E>(error: E, message: string) => E;

package/types/utils/src/user-facing-error.d.ts

@@ -0,0 +1,83 @@
+import { Schema, type Cause } from "effect";
+import "effect/http-api";
+import { MessageField } from "./api-error.js";
+/** Curated explanation and recovery. Never include raw diagnostics, credentials, or form values. */
+export interface ErrorPresentation {
+    readonly title: string;
+    readonly description: string;
+    readonly recovery: {
+        readonly action: string;
+        readonly instructions: string;
+    };
+    /** Repeating the failed operation can help. Configuration changes are not retries. */
+    readonly retryable?: boolean;
+    /** False when the user's agent cannot act on the fix prompt, so hosts do not offer it. */
+    readonly agentFixable?: boolean;
+    /** One safe value the user needs for recovery, such as a URL to send to the service. */
+    readonly detail?: {
+        readonly label: string;
+        readonly value: string;
+    };
+    /**
+     * Present only when the Executor team must fix the problem. Safe evidence for a public
+     * report: fixed codes and statuses, never user data, URLs, or upstream text.
+     */
+    readonly report?: string;
+}
+type PresentationProperties = Required<Omit<ErrorPresentation, "detail" | "report">> & {
+    readonly detail: ErrorPresentation["detail"];
+    readonly report: ErrorPresentation["report"];
+    readonly code: string;
+    readonly fixPrompt: string;
+};
+/** A yieldable error that owns its safe user explanation and agent recovery task. */
+export interface UserFacingError extends Cause.YieldableError, PresentationProperties {
+    readonly _tag: string;
+}
+type Header<Tag extends string> = {
+    readonly tag: Tag;
+    readonly status: number;
+};
+type Definition<Tag extends string, Fields extends Schema.Struct.Fields> = Header<Tag> & {
+    readonly fields: Fields & {
+        readonly [Key in keyof PresentationProperties | "_tag" | "message"]?: never;
+    };
+    /**
+     * What traces and error reports record beside the tag. A fixed description is recorded as is; a
+     * presentation derived from fields is recorded only through this, from fixed text and closed
+     * fields, never a value the caller chose, an app's text or a service's reply. Without it the
+     * error is recorded by its tag alone.
+     */
+    readonly recorded?: (fields: Schema.Struct.Type<Fields>) => string;
+} & (ErrorPresentation | {
+    readonly presentation: (fields: Schema.Struct.Type<Fields>) => ErrorPresentation;
+});
+declare const RecoveryField: Schema.decodeTo<Schema.optionalKey<Schema.Struct<{
+    readonly action: Schema.String;
+    readonly instructions: Schema.String;
+}>>, Schema.Struct<{
+    readonly action: Schema.String;
+    readonly instructions: Schema.String;
+}>, never, never>;
+type DerivedFields = {
+    readonly message: typeof MessageField;
+    readonly recovery: typeof RecoveryField;
+};
+type ErrorFields<Tag extends string, Fields extends Schema.Struct.Fields> = Omit<Schema.TaggedStruct<Tag, Fields & DerivedFields>, "~type.make.in"> & {
+    readonly "~type.make.in": Schema.TaggedStruct<Tag, Fields>["~type.make.in"];
+};
+type ErrorClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<Schema.Struct.Type<Fields> & UserFacingError & {
+    readonly _tag: Tag;
+}, ErrorFields<Tag, Fields>, UserFacingError>;
+/** Define a schema-backed error with no payload. Its tag becomes its public error code. */
+declare function define<const Tag extends string>(definition: Header<Tag> & ErrorPresentation): ErrorClass<Tag, {}>;
+/** Define a schema-backed error whose safe presentation can depend on its parsed fields. */
+declare function define<const Tag extends string, const Fields extends Schema.Struct.Fields>(definition: Definition<Tag, Fields>): ErrorClass<Tag, Fields>;
+/** Define the schema, error constructor, user copy, and agent recovery together. */
+export declare const UserFacingError: {
+    define: typeof define;
+    is: (value: unknown) => value is UserFacingError;
+};
+/** Defects get a safe explanation without exposing an arbitrary cause. */
+export declare const UnexpectedError: ErrorClass<"UnexpectedError", {}>;
+export {};

package/js/chunk-7EK2JDX4.js

@@ -1,299 +0,0 @@
-import {
-  prepareElicitation
-} from "./chunk-SJFZCGXG.js";
-import {
-  fromPromise
-} from "./chunk-Z5M2LQOZ.js";
-import {
-  ElicitationFailed,
-  McpError,
-  McpServerHeader,
-  McpToolMetadata,
-  McpToolResult,
-  RouterIcon,
-  ToolResultObservation,
-  defaultElicitationLimits,
-  defaultMcpClientLimits,
-  mcpSdkTimerCeilingMs
-} from "./chunk-WLE7WX2U.js";
-import {
-  compileJsonSchemaDecoder,
-  jsonSchemaDecoder
-} from "./chunk-5T57N25Q.js";
-import {
-  JsonObject
-} from "./chunk-27F7W2LG.js";
-import {
-  Clock_exports,
-  Deferred_exports,
-  Effect_exports,
-  Exit_exports,
-  Option_exports,
-  Queue_exports,
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/implementation/mcp-tools.ts
-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 = tool.outputSchema === void 0 ? void 0 : yield* Effect_exports.cached(
-    compileJsonSchemaDecoder(tool.outputSchema).pipe(
-      Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
-    )
-  );
-  const adapted = {
-    ...tool,
-    description: tool.description ?? tool.title ?? tool.name,
-    input: 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" }))
-      );
-      const outputDecoder = output === void 0 ? void 0 : yield* output;
-      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"
-        });
-      }
-      if (outputDecoder !== void 0 && !result.isError)
-        yield* Schema_exports.decodeUnknownEffect(outputDecoder)(result.structuredContent).pipe(
-          Effect_exports.mapError(() => new McpError({ phase: "call", reason: "invalid_response" }))
-        );
-      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 { ListToolsResultSchema } 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, failure) => 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) => 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)(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) => failure("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(
-  Effect_exports.withSpan("provider.mcp.request", {
-    kind: "client",
-    attributes: {
-      "rpc.system.name": "jsonrpc",
-      "rpc.method": "tools/call",
-      "mcp.tool.name": name
-    }
-  })
-);
-
-// src/implementation/mcp-client.ts
-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(withClient, timeoutMs, failure) {
-  const list = withClient(
-    "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) => failure("discover", error)
-        }).pipe(
-          Effect_exports.withSpan("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(Effect_exports.withSpan("provider.mcp.discover"));
-  const call = (name, input, context) => withClient("call", (client) => mcpCall(client, name, input, context, timeoutMs, failure)).pipe(
-    Effect_exports.withSpan("provider.mcp.call", { attributes: { "mcp.tool.name": name } })
-  );
-  return { list, call };
-}
-
-export {
-  adaptMcpTool,
-  adaptMcpTools,
-  mcpJsonSchemaValidator,
-  mcpClient
-};