apps 0.0.1-beta.1 → 0.0.1-beta.100

package/js/chunk-RBAC33PQ.js

@@ -1,267 +0,0 @@
-import {
-  parseDatabaseSchema,
-  promiseTable
-} from "./chunk-PLCMJREA.js";
-import {
-  fromPromise,
-  nativeOperation
-} from "./chunk-PZ36XMXW.js";
-import {
-  ScheduleTiming
-} from "./chunk-IHQ4ML7K.js";
-import {
-  decoderOf,
-  isSchema,
-  storageFieldOf
-} from "./chunk-2HHMABB6.js";
-import {
-  AppStorageUnavailable
-} from "./chunk-FZJOYIZO.js";
-import {
-  JsonValue
-} from "./chunk-SATWJKN6.js";
-import {
-  Effect_exports,
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// ../app-cache/src/contracts/cache.ts
-var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
-  reason: Schema_exports.Literals(["unavailable", "storage", "invalid", "capacity", "timeout"])
-}) {
-};
-var cacheLimits = {
-  keyBytes: 8192,
-  entryBytes: 2e6,
-  batchBytes: 8e6,
-  batchEntries: 128,
-  totalBytes: 128e6,
-  totalEntries: 1e5,
-  retentionMs: 7 * 24 * 60 * 60 * 1e3,
-  loadTimeoutMs: 9e4,
-  leaseMs: 12e4
-};
-var Key = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/));
-var Time = Schema_exports.Finite.check(Schema_exports.isGreaterThanOrEqualTo(0));
-var CacheEntry = Schema_exports.Struct({
-  value: Schema_exports.Json,
-  version: Schema_exports.String,
-  freshUntil: Time,
-  staleUntil: Time
-});
-var CacheCommand = Schema_exports.Union([
-  Schema_exports.Struct({ operation: Schema_exports.Literal("read"), keys: Schema_exports.Array(Key) }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("claim"),
-    key: Key,
-    version: Schema_exports.NullOr(Schema_exports.String)
-  }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("publish"),
-    key: Key,
-    lease: Schema_exports.String,
-    entry: CacheEntry
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("release"), key: Key, lease: Schema_exports.String }),
-  Schema_exports.Struct({
-    operation: Schema_exports.Literal("write"),
-    entries: Schema_exports.Array(Schema_exports.Struct({ key: Key, entry: CacheEntry }))
-  }),
-  Schema_exports.Struct({ operation: Schema_exports.Literal("invalidate"), key: Key })
-]);
-var CacheReply = Schema_exports.Union([
-  Schema_exports.Struct({ ok: Schema_exports.Literal(true), value: Schema_exports.Json }),
-  Schema_exports.Struct({ ok: Schema_exports.Literal(false), error: CacheError })
-]);
-
-// src/implementation/workflows.ts
-var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
-var workflow = (options, run) => ({
-  [NativeWorkflow]: {
-    input: decoderOf(options.input),
-    ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
-    ...options.description === void 0 ? {} : { description: options.description },
-    run: (context, input) => Effect_exports.tryPromise({
-      // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
-      try: () => run(context, input),
-      catch: (error) => error
-    })
-  }
-});
-var nativeWorkflow = (value) => {
-  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
-  return value[NativeWorkflow];
-};
-
-// src/implementation/app.ts
-var InternalApp = /* @__PURE__ */ Symbol("apps.App");
-var isApp = (value) => typeof value === "object" && value !== null && InternalApp in value;
-var toEffectApp = (app) => app[InternalApp];
-function adaptDefinition(definition) {
-  if ("tools" in definition) throw new Error("Use queries and mutations instead of tools");
-  const webhooks = definition.webhooks === void 0 ? {} : {
-    webhooks: Object.fromEntries(
-      Object.entries(definition.webhooks).map(([name, webhook]) => [
-        name,
-        {
-          ...webhook,
-          ...webhook.register === void 0 ? {} : { register: fromPromise(webhook.register) },
-          handle: fromPromise(webhook.handle),
-          ...webhook.unregister === void 0 ? {} : { unregister: fromPromise(webhook.unregister) },
-          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
-          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
-        }
-      ])
-    )
-  };
-  const operations = (kind, catalog) => Object.fromEntries(
-    Object.entries(catalog).map(([name, value]) => {
-      const operation = nativeOperation(value);
-      if (operation === void 0 || operation.kind !== kind)
-        throw new Error("Invalid app data operation");
-      return [name, operation];
-    })
-  );
-  const workflows = definition.workflows === void 0 ? {} : {
-    workflows: Object.fromEntries(
-      Object.entries(definition.workflows).map(([name, value]) => {
-        const declared = nativeWorkflow(value);
-        if (declared === void 0) throw new Error("Invalid workflow declaration");
-        return [name, declared];
-      })
-    )
-  };
-  const data = {
-    ...definition.queries === void 0 ? {} : { queries: operations("query", definition.queries) },
-    ...definition.mutations === void 0 ? {} : { mutations: operations("mutation", definition.mutations) }
-  };
-  const schedules = definition.schedules === void 0 ? {} : {
-    schedules: Object.fromEntries(
-      Object.entries(definition.schedules).map(([name, schedule]) => {
-        const matches = Object.entries(definition.mutations ?? {}).filter(
-          ([, operation]) => operation === schedule.operation
-        );
-        const match = matches[0];
-        if (match === void 0 || matches.length !== 1)
-          throw new Error("A schedule must reference exactly one named mutation in this app");
-        return [
-          name,
-          {
-            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
-            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
-            tool: `mutations.${match[0]}`
-          }
-        ];
-      })
-    )
-  };
-  return {
-    ...definition,
-    ...webhooks,
-    ...workflows,
-    ...data,
-    ...schedules
-  };
-}
-var defineApp = (requirements, definition) => {
-  const evaluate = typeof definition === "function" ? definition : async () => definition;
-  const factory = fromPromise(evaluate);
-  const native = {
-    accounts: requirements.accounts,
-    ...requirements.database === void 0 ? {} : { database: requirements.database },
-    evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
-  };
-  return {
-    [InternalApp]: native,
-    accounts: native.accounts,
-    evaluate: (context) => Effect_exports.runPromise(factory(context))
-  };
-};
-
-// src/implementation/storage.ts
-var table = (fields) => tableWithIndexes(fields, []);
-var tableWithIndexes = (fields, indexes) => ({
-  fields,
-  indexes,
-  index: (name, fieldsInIndex) => tableWithIndexes(fields, [...indexes, { name, fields: fieldsInIndex }])
-});
-var serialize = (tables) => {
-  const definitions = Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => [
-      name,
-      {
-        fields: Object.fromEntries(
-          Object.entries(table2.fields).map(([fieldName, schema]) => {
-            const field = storageFieldOf(schema);
-            if (field === void 0) throw new Error("Database columns must use a scalar schema");
-            return [fieldName, field];
-          })
-        ),
-        indexes: table2.indexes
-      }
-    ])
-  );
-  return Effect_exports.runSync(parseDatabaseSchema(definitions));
-};
-var authorDatabase = (tables, session, signal, writable) => {
-  return Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => {
-      const api = promiseTable(session, name, signal);
-      const parseFields = (input, partial) => {
-        const values = Schema_exports.decodeUnknownSync(
-          Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-        )(input);
-        const fields = {};
-        for (const [key, value] of Object.entries(values)) {
-          if (value === void 0) continue;
-          const field = Object.hasOwn(table2.fields, key) ? table2.fields[key] : void 0;
-          if (field === void 0) throw new Error("Unknown database column");
-          const definition = storageFieldOf(field);
-          fields[key] = value === null && definition?.optional ? null : field.parse(value);
-        }
-        if (!partial) {
-          for (const [key, field] of Object.entries(table2.fields))
-            if (!Object.hasOwn(fields, key)) {
-              const value = field.parse(void 0);
-              if (value !== void 0) fields[key] = value;
-            }
-        }
-        return fields;
-      };
-      const read = { get: api.get, withIndex: api.withIndex };
-      return [
-        name,
-        writable ? {
-          ...read,
-          insert: (value) => api.insert(parseFields(value, false)),
-          update: (id, value) => api.update(id, parseFields(value, true)),
-          delete: api.delete
-        } : read
-      ];
-    })
-  );
-};
-var defineDatabase = (tables) => ({
-  schema: serialize(tables),
-  tables
-});
-var unavailableStorage = {
-  read: () => Effect_exports.fail(new AppStorageUnavailable()),
-  mutate: () => Effect_exports.fail(new AppStorageUnavailable())
-};
-
-export {
-  CacheError,
-  cacheLimits,
-  CacheEntry,
-  CacheCommand,
-  CacheReply,
-  workflow,
-  isApp,
-  toEffectApp,
-  defineApp,
-  table,
-  authorDatabase,
-  defineDatabase,
-  unavailableStorage
-};

package/js/chunk-SATWJKN6.js

@@ -1,34 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/contracts/schema.ts
-var JsonValue = Schema_exports.Json;
-var JsonObject = Schema_exports.Record(Schema_exports.String, JsonValue);
-var AccountId = Schema_exports.String.pipe(
-  Schema_exports.check(Schema_exports.isStartsWith("acc_"), Schema_exports.isMinLength(5)),
-  Schema_exports.brand("acc")
-);
-var HttpUrl = Schema_exports.String.check(
-  Schema_exports.makeFilter((value) => {
-    try {
-      const url = new URL(value);
-      return url.protocol === "https:" || url.protocol === "http:";
-    } catch {
-      return false;
-    }
-  })
-);
-var ValidationError = class extends Schema_exports.TaggedError()("ValidationError", {}) {
-  get message() {
-    return "Value did not match the schema";
-  }
-};
-
-export {
-  JsonValue,
-  JsonObject,
-  AccountId,
-  HttpUrl,
-  ValidationError
-};

package/js/chunk-SWPD52J7.js

@@ -1,35 +0,0 @@
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/contracts/api-response-error.ts
-var ApiErrorRecovery = Schema_exports.Struct({
-  action: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(1024)),
-  instructions: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(4096))
-});
-var ApiErrorResponse = Schema_exports.Struct({
-  code: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(128)),
-  status: Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 400, maximum: 599 })),
-  message: Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(4096)),
-  recovery: Schema_exports.optionalKey(ApiErrorRecovery)
-});
-var OpenapiResponseError = class extends Schema_exports.TaggedError()(
-  "OpenapiResponseError",
-  ApiErrorResponse.fields
-) {
-};
-var OpenapiErrorLimits = Schema_exports.Struct({
-  maxBodyBytes: Schema_exports.Int.check(Schema_exports.isGreaterThan(0)),
-  readTimeoutMs: Schema_exports.Int.check(Schema_exports.isGreaterThan(0))
-});
-var defaultOpenapiErrorLimits = OpenapiErrorLimits.make({
-  maxBodyBytes: 65536,
-  readTimeoutMs: 2e3
-});
-
-export {
-  ApiErrorRecovery,
-  ApiErrorResponse,
-  OpenapiResponseError,
-  defaultOpenapiErrorLimits
-};

package/js/chunk-TE4KO4HI.js

@@ -1,47 +0,0 @@
-import {
-  HttpServerResponse_exports
-} from "./chunk-QKHR7BMF.js";
-
-// src/implementation/ui-auth.ts
-var appPrivateHeaders = {
-  "cache-control": "no-store",
-  "referrer-policy": "no-referrer",
-  "x-content-type-options": "nosniff",
-  "content-security-policy": "frame-ancestors 'none'"
-};
-var appSignInPage = () => HttpServerResponse_exports.text(
-  `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Opening app</title></head><body><p>Opening app\u2026</p><a href="/" hidden>Try again</a><script src="/_executor/auth/browser.js"></script></body></html>`,
-  {
-    contentType: "text/html",
-    headers: {
-      ...appPrivateHeaders,
-      "content-security-policy": "default-src 'none'; script-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'"
-    }
-  }
-);
-var appSignInScript = () => HttpServerResponse_exports.text(
-  `
-const callback = location.pathname === "/_executor/auth/callback";
-const parameters = new URLSearchParams(location.hash.slice(1));
-const body = callback
-  ? {request: parameters.get("request"), code: parameters.get("code")}
-  : {returnTo: location.pathname + location.search + location.hash};
-if (callback) history.replaceState(null, "", location.pathname);
-fetch(callback ? "/_executor/auth/complete" : "/_executor/auth/start", {
-  method: "POST", headers: {"content-type":"application/json"}, body: JSON.stringify(body)
-}).then(async response => {
-  if (!response.ok) throw new Error();
-  const result = await response.json();
-  location.replace(callback ? result.returnTo : result.url);
-}).catch(() => {
-  document.querySelector("p").textContent = "Could not sign in to this app. Try opening it again.";
-  document.querySelector("a").hidden = false;
-});`,
-  { contentType: "text/javascript", headers: appPrivateHeaders }
-);
-
-export {
-  appPrivateHeaders,
-  appSignInPage,
-  appSignInScript
-};

package/js/chunk-W7D7WVSY.js

@@ -1,18 +0,0 @@
-import {
-  AccountId
-} from "./chunk-SATWJKN6.js";
-import {
-  Schema_exports
-} from "./chunk-FW5HBOIK.js";
-
-// src/contracts/provider-error.ts
-var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
-  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
-  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
-  accountId: Schema_exports.optional(AccountId)
-}) {
-};
-
-export {
-  ProviderError
-};

package/js/chunk-X7SFGU4Q.js

@@ -1,280 +0,0 @@
-import {
-  prepareElicitation
-} from "./chunk-KOXMLKTM.js";
-import {
-  fromPromise
-} from "./chunk-PZ36XMXW.js";
-import {
-  ElicitationFailed,
-  McpError,
-  McpToolMetadata,
-  McpToolResult,
-  ToolResultObservation,
-  defaultElicitationLimits,
-  defaultMcpClientLimits,
-  mcpSdkTimerCeilingMs
-} from "./chunk-IHQ4ML7K.js";
-import {
-  compileJsonSchemaDecoder,
-  jsonSchemaDecoder
-} from "./chunk-2HHMABB6.js";
-import {
-  JsonObject
-} from "./chunk-SATWJKN6.js";
-import {
-  Clock_exports,
-  Deferred_exports,
-  Effect_exports,
-  Exit_exports,
-  Option_exports,
-  Queue_exports,
-  Schema_exports
-} from "./chunk-FW5HBOIK.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 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; mcpOperations 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);
-      return [...tools.values()];
-    })
-  ).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
-};