apps 0.0.1-beta.0

package/js/chunk-KWTCHVLT.js

@@ -0,0 +1,284 @@
+import {
+  prepareElicitation
+} from "./chunk-Q2FD5IBM.js";
+import {
+  fromPromise
+} from "./chunk-X3YBZCJW.js";
+import {
+  McpError,
+  McpToolMetadata,
+  McpToolResult,
+  ToolResultObservation,
+  defaultMcpClientLimits,
+  mcpSdkTimerCeilingMs
+} from "./chunk-22WRQZT7.js";
+import {
+  ElicitationFailed,
+  defaultElicitationLimits
+} from "./chunk-HP7E42X6.js";
+import {
+  compileJsonSchemaDecoder,
+  jsonSchemaDecoder
+} from "./chunk-BPEFS4YF.js";
+import {
+  JsonObject
+} from "./chunk-36DNRFZQ.js";
+import {
+  Clock_exports,
+  Deferred_exports,
+  Effect_exports,
+  Exit_exports,
+  Option_exports,
+  Queue_exports,
+  Schema_exports
+} from "./chunk-2OTCEKL2.js";
+
+// src/implementation/mcp-tools.ts
+var adaptMcpTools = (client) => Effect_exports.gen(function* () {
+  const metadata = yield* client.list;
+  const entries = yield* Effect_exports.forEach(
+    metadata,
+    (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 [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 {
+  adaptMcpTools,
+  mcpJsonSchemaValidator,
+  mcpClient
+};

package/js/chunk-LOKGDT6B.js

@@ -0,0 +1,28 @@
+import {
+  operationDeclaration
+} from "./chunk-C24KEZXR.js";
+
+// src/implementation/protocol-operations.ts
+var protocolOperations = (operations, kinds = {}) => {
+  const queries = {};
+  const mutations = {};
+  for (const [name, operation] of Object.entries(operations)) {
+    const kind = Object.hasOwn(kinds, name) ? kinds[name] : operation.readOnly === true ? "query" : "mutation";
+    const native = {
+      description: operation.description,
+      ...operation.title === void 0 ? {} : { title: operation.title },
+      ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
+      ...operation._meta === void 0 ? {} : { _meta: operation._meta },
+      input: operation.input,
+      ...operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema },
+      run: operation.run
+    };
+    if (kind === "query") queries[name] = operationDeclaration({ ...native, kind });
+    else mutations[name] = operationDeclaration({ ...native, kind: "mutation" });
+  }
+  return { queries, mutations };
+};
+
+export {
+  protocolOperations
+};

package/js/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};