apps 0.0.1-beta.0 → 0.0.1-beta.2

package/js/{chunk-EP6AEUZO.js → chunk-FZJOYIZO.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // src/contracts/storage.ts
 var StorageName = Schema_exports.NonEmptyString.check(Schema_exports.isMaxLength(200));

package/js/{chunk-VFUZI3NY.js → chunk-HDJH3RPR.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-W7Q5EOTS.js";
+} from "./chunk-QKHR7BMF.js";
 import {
   Reference,
   Service,
@@ -17,12 +17,12 @@ import {
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/http/FetchHttpClient.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/http/FetchHttpClient.js
 var FetchHttpClient_exports = {};
 __export(FetchHttpClient_exports, {
   Fetch: () => Fetch,

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

@@ -2,54 +2,71 @@ import {
   adaptMcpTools,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-KWTCHVLT.js";
+} from "./chunk-RN2MXB4R.js";
+import {
+  accountProviderError,
+  httpProviderError
+} from "./chunk-ZJWDMTE3.js";
 import {
   McpError,
   McpToolsOptions,
   defaultMcpClientLimits
-} from "./chunk-22WRQZT7.js";
+} from "./chunk-MYYEW3RA.js";
+import {
+  ProviderError
+} from "./chunk-W7D7WVSY.js";
 import {
   captureTelemetry
-} from "./chunk-OWD2YICM.js";
+} from "./chunk-ZCAMUXSG.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-VFUZI3NY.js";
+} from "./chunk-HDJH3RPR.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-W7Q5EOTS.js";
+} from "./chunk-QKHR7BMF.js";
 import {
+  Deferred_exports,
   Effect_exports,
   Redacted_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.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
 };