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

package/js/{chunk-KWTCHVLT.js → chunk-CRDWFA74.js}

@@ -1,28 +1,28 @@
 import {
   prepareElicitation
-} from "./chunk-Q2FD5IBM.js";
+} from "./chunk-V5KNQVCT.js";
 import {
   fromPromise
-} from "./chunk-X3YBZCJW.js";
+} from "./chunk-Z5M2LQOZ.js";
 import {
+  ElicitationFailed,
   McpError,
+  McpServerHeader,
   McpToolMetadata,
   McpToolResult,
+  RouterIcon,
   ToolResultObservation,
+  defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-22WRQZT7.js";
-import {
-  ElicitationFailed,
-  defaultElicitationLimits
-} from "./chunk-HP7E42X6.js";
+} from "./chunk-WLE7WX2U.js";
 import {
   compileJsonSchemaDecoder,
   jsonSchemaDecoder
-} from "./chunk-BPEFS4YF.js";
+} from "./chunk-5T57N25Q.js";
 import {
   JsonObject
-} from "./chunk-36DNRFZQ.js";
+} from "./chunk-27F7W2LG.js";
 import {
   Clock_exports,
   Deferred_exports,
@@ -31,54 +31,51 @@ import {
   Option_exports,
   Queue_exports,
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} 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 metadata = yield* client.list;
+  const { tools: 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];
-    })
+    (tool) => adaptMcpTool(client, tool).pipe(Effect_exports.map((adapted) => [tool.name, adapted]))
   );
   return Object.fromEntries(entries);
 });
@@ -238,7 +235,7 @@ function mcpClient(withClient, timeoutMs, failure) {
       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.
+          // every output validator; mcpRouter validates the selected tool on call.
           try: (signal) => client.request(
             { method: "tools/list", params: cursor === void 0 ? {} : { cursor } },
             ListToolsResultSchema,
@@ -268,7 +265,24 @@ function mcpClient(withClient, timeoutMs, failure) {
           cursors.add(cursor);
         }
       } while (cursor !== void 0);
-      return [...tools.values()];
+      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(
@@ -278,6 +292,7 @@ function mcpClient(withClient, timeoutMs, failure) {
 }
 
 export {
+  adaptMcpTool,
   adaptMcpTools,
   mcpJsonSchemaValidator,
   mcpClient

package/js/chunk-CZ7CSFO4.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/js/{chunk-WIDTG42X.js → chunk-EPT3ZP52.js}

@@ -2,54 +2,71 @@ import {
   adaptMcpTools,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-KWTCHVLT.js";
+} from "./chunk-CRDWFA74.js";
+import {
+  accountProviderError,
+  httpProviderError
+} from "./chunk-MKWZPDR6.js";
 import {
   McpError,
   McpToolsOptions,
   defaultMcpClientLimits
-} from "./chunk-22WRQZT7.js";
+} from "./chunk-WLE7WX2U.js";
+import {
+  ProviderError
+} from "./chunk-R3EV5FTO.js";
 import {
   captureTelemetry
-} from "./chunk-OWD2YICM.js";
+} from "./chunk-ODEIDRGW.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-VFUZI3NY.js";
+} from "./chunk-57RKNWL2.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-W7Q5EOTS.js";
+} from "./chunk-UK573G7W.js";
 import {
+  Deferred_exports,
   Effect_exports,
   Redacted_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/implementation/mcp.ts
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { ErrorCode, McpError as ProtocolError } from "@modelcontextprotocol/sdk/types.js";
+import {
+  ErrorCode,
+  McpError as ProtocolError,
+  ToolListChangedNotificationSchema
+} from "@modelcontextprotocol/sdk/types.js";
 import { SSEClientTransport, SseError } from "@modelcontextprotocol/sdk/client/sse.js";
 import {
   StreamableHTTPClientTransport,
   StreamableHTTPError
 } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 var failure = (phase, error) => {
+  if (Schema_exports.is(ProviderError)(error) || Schema_exports.is(McpError)(error)) return error;
   const status = error instanceof UnauthorizedError ? 401 : error instanceof StreamableHTTPError || error instanceof SseError ? error.code : void 0;
+  const provider = status === void 0 ? void 0 : httpProviderError(status);
+  if (provider !== void 0) return provider;
   return new McpError({
     phase,
-    reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : status === 401 || status === 403 ? "unauthorized" : "request",
+    reason: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
     ...status === void 0 ? {} : { status }
   });
 };
-var transportFetch = (connection, telemetry) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
+var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
   Effect_exports.gen(function* () {
     const target = yield* Effect_exports.try({
       try: () => new URL(url),
-      catch: () => failure("transport", void 0)
+      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* failure("transport", void 0);
+      return yield* new McpError({ phase: "transport", reason: "invalid_response" });
     const headers = new Headers(Redacted_exports.value(connection.headers));
     new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
     const request = yield* Effect_exports.try({
@@ -58,6 +75,11 @@ var transportFetch = (connection, telemetry) => (url, init) => Effect_exports.ru
     });
     const client = yield* HttpClient_exports.HttpClient;
     const response = yield* client.execute(request);
+    const provider = httpProviderError(response.status, response.headers);
+    if (provider !== void 0) {
+      yield* Deferred_exports.fail(rejected, provider);
+      return yield* provider;
+    }
     return new Response(
       [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
       {
@@ -78,25 +100,40 @@ var transportFetch = (connection, telemetry) => (url, init) => Effect_exports.ru
         ])
       })
     ),
-    Effect_exports.mapError(() => failure("transport", void 0))
+    Effect_exports.mapError((error) => failure("transport", error))
   ),
   init?.signal ? { signal: init.signal } : {}
 );
-function withClient(connection, mode, use) {
+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 pending = /* @__PURE__ */ new Set();
       const { client, transport } = yield* Effect_exports.acquireRelease(
         Effect_exports.sync(() => {
-          const fetch = transportFetch(connection, telemetry);
+          const fetch = transportFetch(connection, telemetry, rejected);
+          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: new Client(
-              { name: "executor-apps", version: "0.1.0" },
-              {
-                jsonSchemaValidator: mcpJsonSchemaValidator,
-                capabilities: mode === "call" ? { elicitation: { form: {} } } : {}
-              }
-            ),
+            client: client2,
             transport: kind === "http" ? new StreamableHTTPClientTransport(connection.url, {
               fetch,
               reconnectionOptions: {
@@ -109,6 +146,10 @@ function withClient(connection, mode, use) {
           };
         }),
         ({ 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),
@@ -125,8 +166,12 @@ function withClient(connection, mode, use) {
       yield* Effect_exports.tryPromise({
         try: (signal) => client.connect(wire, { signal, timeout: connection.timeoutMs }),
         catch: (error) => failure("connect", error)
-      }).pipe(Effect_exports.timeout(connection.timeoutMs), Effect_exports.withSpan("provider.mcp.connect"));
-      return yield* use(client);
+      }).pipe(
+        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.timeout(connection.timeoutMs),
+        Effect_exports.withSpan("provider.mcp.connect")
+      );
+      return yield* use(client).pipe(Effect_exports.raceFirst(Deferred_exports.await(rejected)));
     })
   ).pipe(
     Effect_exports.withSpan("provider.mcp.session", {
@@ -149,7 +194,7 @@ function withClient(connection, mode, use) {
     )
   );
 }
-var mcpToolsEffect = (input) => Effect_exports.gen(function* () {
+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" }))
   );
@@ -161,11 +206,19 @@ var mcpToolsEffect = (input) => Effect_exports.gen(function* () {
     headers: Redacted_exports.make({ ...options.headers }),
     timeoutMs: options.timeoutMs ?? defaultMcpClientLimits.timeoutMs
   };
-  return yield* adaptMcpTools(
-    mcpClient((mode, use) => withClient(connection, mode, use), connection.timeoutMs, failure)
+  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 mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
 
 export {
+  mcpClientEffect,
   mcpToolsEffect
 };