apps 0.0.1-beta.0 → 0.0.1-beta.10

package/js/mcp.js

@@ -1,37 +1,138 @@
 import {
-  mcpToolsEffect
-} from "./chunk-WIDTG42X.js";
-import "./chunk-KWTCHVLT.js";
+  mcpClientEffect
+} from "./chunk-EPT3ZP52.js";
+import {
+  catalogCache
+} from "./chunk-RFVIONFX.js";
+import {
+  adaptMcpTool
+} from "./chunk-CRDWFA74.js";
 import {
   protocolOperations
-} from "./chunk-LOKGDT6B.js";
+} from "./chunk-72JNVHPK.js";
 import "./chunk-BCSNKUAC.js";
-import "./chunk-Q2FD5IBM.js";
-import "./chunk-X3YBZCJW.js";
-import "./chunk-R6JMJSVT.js";
-import "./chunk-C24KEZXR.js";
-import {
-  McpError
-} from "./chunk-22WRQZT7.js";
-import "./chunk-HP7E42X6.js";
-import "./chunk-7JXHF5IF.js";
-import "./chunk-OWD2YICM.js";
-import "./chunk-VFUZI3NY.js";
-import "./chunk-W7Q5EOTS.js";
-import "./chunk-BPEFS4YF.js";
-import "./chunk-EP6AEUZO.js";
-import "./chunk-36DNRFZQ.js";
-import {
-  Effect_exports
-} from "./chunk-2OTCEKL2.js";
-import "./chunk-MLKGABMK.js";
+import "./chunk-V5KNQVCT.js";
+import {
+  cacheKey
+} from "./chunk-NKLWZJLE.js";
+import "./chunk-FL2QR3XW.js";
+import "./chunk-IPI4MFSN.js";
+import "./chunk-YXQHV65J.js";
+import "./chunk-ZQINWV4W.js";
+import {
+  nativeOperation,
+  routerDeclaration
+} from "./chunk-Z5M2LQOZ.js";
+import "./chunk-MKWZPDR6.js";
+import {
+  McpError,
+  McpServerHeader,
+  McpToolMetadata,
+  McpToolsOptions
+} from "./chunk-WLE7WX2U.js";
+import "./chunk-N7YDVXYJ.js";
+import "./chunk-R3EV5FTO.js";
+import "./chunk-JU7VHODU.js";
+import "./chunk-ODEIDRGW.js";
+import "./chunk-57RKNWL2.js";
+import "./chunk-UK573G7W.js";
+import "./chunk-5T57N25Q.js";
+import "./chunk-PZB6T6KU.js";
+import "./chunk-27F7W2LG.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-CDL5PM2Q.js";
+import "./chunk-CZ7CSFO4.js";
+
+// src/implementation/mcp-catalog.ts
+var McpToolSummary = McpToolMetadata.mapFields(
+  ({ inputSchema: _input, outputSchema: _output, _meta, ...fields }) => fields
+);
+var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
+var serverMeta = (server) => {
+  const title = server.title ?? server.name;
+  return {
+    ...title === void 0 ? {} : { title },
+    ...server.description === void 0 ? {} : { description: server.description },
+    ...server.instructions === void 0 ? {} : { instructions: server.instructions },
+    ...server.icons === void 0 ? {} : { icons: server.icons }
+  };
+};
+var mcpCatalog = (options, kinds) => Effect_exports.gen(function* () {
+  const parsed = yield* Schema_exports.decodeUnknownEffect(McpToolsOptions)(options).pipe(
+    Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" }))
+  );
+  const headers = {};
+  new Headers(parsed.headers).forEach((value, name) => {
+    headers[name] = value;
+  });
+  const id = yield* cacheKey({ url: parsed.url, headers, accountId: parsed.accountId ?? null });
+  const key = ["mcp-catalog-v3", id, "current"];
+  const cache = options.cache;
+  const changed = cache === void 0 ? void 0 : invoke(() => cache.invalidate(key));
+  const client = yield* mcpClientEffect(options, changed);
+  const catalog = yield* catalogCache({
+    ...options,
+    prefix: ["mcp-catalog-v3", id],
+    schema: McpToolMetadata,
+    summary: {
+      schema: McpToolSummary,
+      of: ({ inputSchema: _input, outputSchema: _output, _meta, ...summary }) => summary
+    },
+    load: (context) => (context === void 0 ? client.list : mcpClientEffect(
+      { ...parsed, signal: context.signal },
+      invoke(() => context.cache.invalidate(key))
+    ).pipe(Effect_exports.flatMap((source) => source.list))).pipe(
+      Effect_exports.flatMap(
+        ({ tools, server }) => Schema_exports.encodeEffect(McpServerHeader)(server).pipe(
+          Effect_exports.map((header) => ({ tools, header }))
+        )
+      )
+    )
+  });
+  const kindOf = (tool) => Object.hasOwn(kinds, tool.name) ? kinds[tool.name] ?? "mutation" : tool.annotations?.readOnlyHint === true ? "query" : "mutation";
+  const summarize = (tool) => ({
+    name: tool.name,
+    description: tool.description ?? tool.title ?? tool.name,
+    readOnly: kindOf(tool) === "query",
+    ...tool.title === void 0 ? {} : { title: tool.title },
+    annotations: { ...tool.annotations, readOnlyHint: kindOf(tool) === "query" }
+  });
+  const describe = (tool) => ({
+    ...summarize(tool),
+    inputSchema: tool.inputSchema,
+    ...tool.outputSchema === void 0 ? {} : { outputSchema: tool.outputSchema },
+    ...tool._meta === void 0 ? {} : { _meta: tool._meta }
+  });
+  const router = {
+    kind: "dynamic",
+    meta: () => catalog.header().pipe(
+      Effect_exports.flatMap(
+        (header) => header === void 0 ? Effect_exports.succeed({}) : Schema_exports.decodeUnknownEffect(McpServerHeader)(header)
+      ),
+      Effect_exports.map(serverMeta)
+    ),
+    list: () => catalog.list().pipe(Effect_exports.map((tools) => tools.map(describe))),
+    summaries: () => catalog.summaries().pipe(Effect_exports.map((tools) => tools.map(summarize))),
+    describe: (name) => catalog.resolve(name).pipe(Effect_exports.map((tool) => tool === void 0 ? void 0 : describe(tool))),
+    resolve: (name) => Effect_exports.gen(function* () {
+      const tool = yield* catalog.resolve(name);
+      if (tool === void 0) return void 0;
+      const adapted = yield* adaptMcpTool(client, tool);
+      const operations = protocolOperations({ selected: adapted }, { selected: kindOf(tool) });
+      return nativeOperation(operations.selected);
+    })
+  };
+  return routerDeclaration(router);
+});
 
 // src/mcp.ts
-var mcpOperations = (options, kinds = {}) => Effect_exports.runPromise(
-  mcpToolsEffect(options).pipe(Effect_exports.map((operations) => protocolOperations(operations, kinds))),
+var mcpRouter = (options, kinds = {}) => Effect_exports.runPromise(
+  mcpCatalog(options, kinds),
   options.signal === void 0 ? {} : { signal: options.signal }
 );
 export {
   McpError,
-  mcpOperations
+  mcpRouter
 };