apps 0.0.1-beta.84 → 0.0.1-beta.86

package/types/apps/src/contracts/mcp.d.ts

@@ -14,7 +14,7 @@ export declare const McpClientLimits: Schema.Struct<{
     readonly cleanupTimeoutMs: Schema.Int;
 }>;
 export type McpClientLimits = typeof McpClientLimits.Type;
-/** HTTP and stdio share discovery ceilings and the default provider timeout. */
+/** Discovery ceilings and the default provider timeout. */
 export declare const defaultMcpClientLimits: {
     readonly timeoutMs: number;
     readonly maxTimeoutMs: number;
@@ -170,12 +170,3 @@ declare const McpCredentialsUnverified_base: Schema.Class<McpCredentialsUnverifi
  */
 export declare class McpCredentialsUnverified extends McpCredentialsUnverified_base {
 }
-/** Public process configuration. Credentials arrive through the selected account. */
-export declare const ProcessConfig: Schema.Struct<{
-    readonly command: Schema.NonEmptyString;
-    readonly args: Schema.$Array<Schema.String>;
-    readonly cwd: Schema.optional<Schema.String>;
-    readonly env: Schema.$Record<Schema.String, Schema.String>;
-    readonly timeoutMs: Schema.Int;
-}>;
-export type ProcessConfig = typeof ProcessConfig.Type;

package/types/apps/src/implementation/router-catalog.d.ts

@@ -95,8 +95,8 @@ export declare const operationDescription: (name: string, router: string, operat
     readonly tags?: readonly string[];
 }, HostDeclarationInvalid, never>;
 /**
- * A dynamic router over operations already discovered, such as an eager OpenAPI document or a
- * stdio server. Upstream names can contain dots, which static router keys cannot.
+ * A dynamic router over operations already discovered, such as an eager OpenAPI document.
+ * Upstream names can contain dots, which static router keys cannot.
  */
 export declare const fixedRouter: (operations: Readonly<Record<string, AppOperation>>, meta?: RouterMeta) => DynamicRouter;
 export interface CatalogOptions {

package/js/chunk-BX2S3T2R.js

@@ -1,348 +0,0 @@
-import {
-  adaptMcpTools,
-  answeredError,
-  mcpClient,
-  mcpJsonSchemaValidator
-} from "./chunk-IGOYMUWZ.js";
-import {
-  failOnNetworkRefusal
-} from "./chunk-I6Q7ZPKJ.js";
-import {
-  accountProviderError,
-  bodyUpstreamError,
-  httpProviderError,
-  providerErrorDetail
-} from "./chunk-W6XCQAXP.js";
-import {
-  McpCredentialsUnverified,
-  McpError,
-  McpHealthInput,
-  McpToolsOptions,
-  defaultMcpClientLimits,
-  mcpHealthReserveMs
-} from "./chunk-NG56RPCA.js";
-import {
-  NetworkRefused,
-  ProviderError
-} from "./chunk-Q4IZAUIF.js";
-import {
-  captureTelemetry,
-  owned
-} from "./chunk-QWQM3CLH.js";
-import {
-  FetchHttpClient_exports
-} from "./chunk-PD6I2SDG.js";
-import {
-  HttpClientRequest_exports,
-  HttpClient_exports
-} from "./chunk-EOPQ727L.js";
-import {
-  Clock_exports,
-  Deferred_exports,
-  Effect_exports,
-  Match_exports,
-  Option_exports,
-  Predicate_exports,
-  Redacted_exports,
-  Ref_exports,
-  Schema_exports,
-  Stream_exports
-} from "./chunk-IFJU5SYQ.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,
-  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 unreadable = (error) => error instanceof SyntaxError || error instanceof Error && Predicate_exports.hasProperty(error, "issues") && Array.isArray(error.issues);
-var failure = (phase, error) => {
-  if (Schema_exports.is(ProviderError)(error) || Schema_exports.is(McpError)(error) || Schema_exports.is(NetworkRefused)(error))
-    return error;
-  const code = error instanceof UnauthorizedError ? 401 : error instanceof StreamableHTTPError || error instanceof SseError ? error.code : void 0;
-  if (code !== void 0 && code >= 300 && code <= 599)
-    return httpProviderError(code) ?? new McpError({ phase, reason: "request", status: code });
-  const upstream = answeredError(error);
-  return new McpError({
-    phase,
-    reason: code !== void 0 || unreadable(error) ? "invalid_response" : error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
-    ...upstream === void 0 ? {} : { upstream }
-  });
-};
-var errorBodyLimits = { maxBytes: 65536, readTimeoutMs: 2e3 };
-var errorBody = (response) => Effect_exports.gen(function* () {
-  const json = /^application\/(?:[\w.-]+\+)?json$/i.test(
-    response.headers["content-type"]?.split(";")[0]?.trim() ?? ""
-  );
-  const length = response.headers["content-length"];
-  if (!json || length !== void 0 && Number(length) > errorBodyLimits.maxBytes)
-    return { body: Stream_exports.toReadableStream(response.stream), upstream: void 0 };
-  const unreadable2 = new McpError({ phase: "transport", reason: "invalid_response" });
-  const read = yield* response.stream.pipe(
-    Stream_exports.mapError(() => unreadable2),
-    Stream_exports.limitBytes(errorBodyLimits.maxBytes, () => Stream_exports.fail(unreadable2)),
-    Stream_exports.decodeText,
-    Stream_exports.mkString,
-    Effect_exports.timeout(errorBodyLimits.readTimeoutMs),
-    Effect_exports.option
-  );
-  if (Option_exports.isNone(read)) return { body: null, upstream: void 0 };
-  const parsed = Schema_exports.decodeUnknownOption(Schema_exports.fromJsonString(Schema_exports.Json))(read.value);
-  return {
-    body: read.value,
-    upstream: Option_exports.isSome(parsed) ? bodyUpstreamError(parsed.value) : void 0
-  };
-});
-var transportFetch = (connection, telemetry, rejected, answered) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
-  Effect_exports.gen(function* () {
-    const target = yield* Effect_exports.try({
-      try: () => new URL(url),
-      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* new McpError({ phase: "transport", reason: "invalid_response" });
-    const request = yield* Effect_exports.try({
-      try: () => {
-        const headers = new Headers(Redacted_exports.value(connection.headers));
-        new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
-        if (!headers.has("user-agent")) headers.set("user-agent", "Executor");
-        return HttpClientRequest_exports.fromWeb(new Request(target, { ...init, headers }));
-      },
-      // The provider's headers cannot form an HTTP request, such as a name with a space.
-      catch: () => new McpError({ phase: "transport", reason: "invalid_input" })
-    });
-    const client = yield* HttpClient_exports.HttpClient;
-    const response = yield* client.execute(request);
-    yield* failOnNetworkRefusal(response).pipe(
-      Effect_exports.tapError((refused) => Deferred_exports.fail(rejected, refused))
-    );
-    if (response.status < 400)
-      return new Response(
-        [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
-        {
-          status: response.status,
-          headers: response.headers
-        }
-      );
-    const { body, upstream } = yield* errorBody(response);
-    const provider = httpProviderError(response.status, response.headers);
-    if (provider !== void 0) {
-      const refused = providerErrorDetail(provider, { upstream });
-      yield* Deferred_exports.fail(rejected, refused);
-      return yield* refused;
-    }
-    const session = new Headers(init?.headers).has("mcp-session-id");
-    yield* Ref_exports.update(
-      answered,
-      (responses) => new Map(responses).set(response.status, { upstream, session })
-    );
-    return new Response(body, { status: response.status, headers: response.headers });
-  }).pipe(
-    Effect_exports.provide(FetchHttpClient_exports.layer),
-    Effect_exports.provideService(FetchHttpClient_exports.RequestInit, { redirect: "manual" }),
-    Effect_exports.provideService(
-      FetchHttpClient_exports.Fetch,
-      (url2, options) => globalThis.fetch(url2, {
-        ...options,
-        signal: AbortSignal.any([
-          ...options?.signal ? [options.signal] : [],
-          ...init?.signal ? [init.signal] : []
-        ])
-      })
-    ),
-    Effect_exports.mapError((error) => failure("transport", error))
-  ),
-  init?.signal ? { signal: init.signal } : {}
-);
-var explain = (error, phase, responses) => {
-  if (Schema_exports.is(ProviderError)(error)) return providerErrorDetail(error, { phase });
-  if (phase === "call" && Schema_exports.is(McpError)(error) && error.phase === "transport" && error.reason === "request")
-    return new McpError({
-      phase,
-      reason: error.reason,
-      ...error.status === void 0 ? {} : { status: error.status },
-      ...error.upstream === void 0 ? {} : { upstream: error.upstream }
-    });
-  if (!Schema_exports.is(McpError)(error) || error.status === void 0) return error;
-  const response = responses.get(error.status);
-  if (response === void 0 || (error.upstream !== void 0 || response.upstream === void 0) && !response.session)
-    return error;
-  const upstream = error.upstream ?? response.upstream;
-  return new McpError({
-    phase: error.phase,
-    reason: error.reason,
-    status: error.status,
-    ...upstream === void 0 ? {} : { upstream },
-    ...response.session ? { session: true } : {}
-  });
-};
-var explained = (phase, answered) => (error) => Ref_exports.get(answered).pipe(
-  Effect_exports.flatMap((responses) => Effect_exports.fail(explain(error, phase, responses)))
-);
-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 answered = yield* Ref_exports.make(/* @__PURE__ */ new Map());
-      const pending = /* @__PURE__ */ new Set();
-      const { client, transport } = yield* Effect_exports.acquireRelease(
-        Effect_exports.sync(() => {
-          const fetch = transportFetch(connection, telemetry, rejected, answered);
-          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: client2,
-            transport: kind === "http" ? new StreamableHTTPClientTransport(connection.url, {
-              fetch,
-              reconnectionOptions: {
-                maxRetries: 0,
-                initialReconnectionDelay: 1e3,
-                maxReconnectionDelay: 1e3,
-                reconnectionDelayGrowFactor: 1
-              }
-            }) : new SSEClientTransport(connection.url, { fetch })
-          };
-        }),
-        ({ 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),
-              Effect_exports.ignore
-            );
-          }
-          yield* Effect_exports.tryPromise(() => client2.close()).pipe(
-            Effect_exports.timeout(defaultMcpClientLimits.cleanupTimeoutMs),
-            Effect_exports.ignore
-          );
-        }).pipe(owned("upstream", "provider.mcp.close"))
-      );
-      const wire = transport;
-      yield* Effect_exports.tryPromise({
-        try: (signal) => client.connect(wire, { signal, timeout: connection.timeoutMs }),
-        catch: (error) => failure("connect", error)
-      }).pipe(
-        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
-        Effect_exports.catch(explained("connect", answered)),
-        Effect_exports.timeout(connection.timeoutMs),
-        owned("upstream", "provider.mcp.connect")
-      );
-      return yield* use(client).pipe(
-        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
-        Effect_exports.catch(explained(mode, answered))
-      );
-    })
-  ).pipe(
-    owned("upstream", "provider.mcp.session", {
-      attributes: {
-        "mcp.transport": kind,
-        "mcp.operation": mode,
-        "server.address": connection.url.hostname
-      }
-    })
-  );
-  return attempt("http").pipe(
-    // Fallback is only for negotiation. Tool calls are never automatically replayed.
-    Effect_exports.catch(
-      (error) => Schema_exports.is(McpError)(error) && error.phase === "connect" && (error.status === 404 || error.status === 405) ? attempt("sse") : Effect_exports.fail(error)
-    ),
-    (operation) => mode === "discover" ? operation.pipe(Effect_exports.timeout(connection.timeoutMs)) : operation,
-    Effect_exports.catchTag(
-      "TimeoutError",
-      () => Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
-    )
-  );
-}
-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" }))
-  );
-  const url = new URL(options.url);
-  if (url.username || url.password || url.hash)
-    return yield* new McpError({ phase: "connect", reason: "invalid_input" });
-  const connection = {
-    url,
-    headers: Redacted_exports.make({ ...options.headers }),
-    timeoutMs: options.timeoutMs ?? defaultMcpClientLimits.timeoutMs
-  };
-  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 refusesCredentials = (error) => Schema_exports.is(ProviderError)(error) && Match_exports.value(error.reason).pipe(
-  Match_exports.whenOr("unauthorized", "forbidden", "rejected", () => true),
-  Match_exports.whenOr("rate_limited", "unavailable", () => false),
-  Match_exports.exhaustive
-);
-var mcpHealthEffect = (check, options) => Effect_exports.gen(function* () {
-  const { deadline, timeoutMs, ...parsed } = yield* Schema_exports.decodeUnknownEffect(McpHealthInput)({
-    ...options,
-    accountId: check.account.id,
-    signal: check.signal,
-    deadline: check.deadline
-  }).pipe(Effect_exports.mapError(() => new McpError({ phase: "connect", reason: "invalid_input" })));
-  const end = Math.min(
-    (yield* Clock_exports.currentTimeMillis) + (timeoutMs ?? defaultMcpClientLimits.timeoutMs),
-    deadline === void 0 ? Number.POSITIVE_INFINITY : deadline - mcpHealthReserveMs
-  );
-  const remaining = Effect_exports.flatMap(
-    Clock_exports.currentTimeMillis,
-    (now) => end - now >= 1 ? Effect_exports.succeed(Math.floor(end - now)) : Effect_exports.fail(new McpError({ phase: "transport", reason: "timeout" }))
-  );
-  yield* (yield* mcpClientEffect({ ...parsed, timeoutMs: yield* remaining })).check;
-  return yield* remaining.pipe(
-    Effect_exports.flatMap(
-      (timeoutMs2) => mcpClientEffect({ url: parsed.url, signal: parsed.signal, timeoutMs: timeoutMs2 })
-    ),
-    Effect_exports.flatMap((anonymous) => anonymous.check),
-    Effect_exports.matchEffect({
-      onSuccess: () => Effect_exports.fail(new McpCredentialsUnverified({ anonymous: "answered" })),
-      // Executor's network refused the attempt, so the server never answered it.
-      onFailure: (error) => Schema_exports.is(NetworkRefused)(error) ? Effect_exports.fail(error) : refusesCredentials(error) ? Effect_exports.void : Effect_exports.fail(new McpCredentialsUnverified({ anonymous: error }))
-    }),
-    owned("upstream", "provider.mcp.anonymous")
-  );
-}).pipe(owned("upstream", "provider.mcp.health"));
-var mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
-
-export {
-  mcpClientEffect,
-  mcpHealthEffect,
-  mcpToolsEffect
-};