apps 0.0.1-beta.4 → 0.0.1-beta.40

package/js/chunk-6KABJTDO.js

@@ -0,0 +1,255 @@
+import {
+  HostedTool,
+  RouterKey,
+  RouterMeta,
+  reservedRouterKeys
+} from "./chunk-OTCLXFLL.js";
+import {
+  decoderOf,
+  schemaArgument
+} from "./chunk-GHXRRFZA.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-MXDKXAY4.js";
+
+// src/implementation/authoring.ts
+var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
+var fromPromise = (callback) => (...args) => {
+  if (NativeCallback in callback) {
+    const native = callback[NativeCallback];
+    return native(...args);
+  }
+  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error });
+};
+var toPromise = (operation, signal) => {
+  const native = (...args) => Effect_exports.suspend(() => {
+    if (signal === void 0) return operation(...args);
+    if (signal.aborted) return Effect_exports.interrupt;
+    const cancelled = Effect_exports.callback((resume) => {
+      if (signal.aborted) {
+        resume(Effect_exports.interrupt);
+        return;
+      }
+      const abort = () => resume(Effect_exports.interrupt);
+      signal.addEventListener("abort", abort, { once: true });
+      return Effect_exports.sync(() => signal.removeEventListener("abort", abort));
+    });
+    return Effect_exports.raceFirst(
+      cancelled,
+      Effect_exports.suspend(() => operation(...args))
+    );
+  });
+  return Object.assign((...args) => Effect_exports.runPromise(native(...args)), {
+    [NativeCallback]: native
+  });
+};
+
+// src/implementation/operations.ts
+var NativeOperation = /* @__PURE__ */ Symbol("apps.Operation");
+var NativeRouterKey = /* @__PURE__ */ Symbol("apps.Router");
+var operationDeclaration = (operation) => ({
+  kind: operation.kind,
+  [NativeOperation]: operation
+});
+var nativeOperation = (value) => {
+  if (typeof value !== "object" || value === null || !(NativeOperation in value)) return void 0;
+  return value[NativeOperation];
+};
+var operationOptions = (options) => {
+  const approval = options.approval;
+  return {
+    ...options.description === void 0 ? {} : { description: options.description },
+    ...options.title === void 0 ? {} : { title: options.title },
+    ...options.annotations === void 0 ? {} : { annotations: options.annotations },
+    ...options._meta === void 0 ? {} : { _meta: options._meta },
+    input: decoderOf(options.input),
+    ...approval === void 0 ? {} : {
+      approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
+    }
+  };
+};
+var approvedOperation = (operation, approval) => {
+  const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(operation));
+  return Object.defineProperty(copy, "approval", {
+    enumerable: true,
+    value: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
+  });
+};
+var withApproval = (operation, approval) => ({
+  ...operation,
+  [NativeOperation]: approvedOperation(operation[NativeOperation], approval)
+});
+var toolAnnotations = (operation) => nativeOperation(operation)?.annotations;
+var make = (kind, options, run) => operationDeclaration({
+  ...operationOptions({ ...options, input: schemaArgument(options.input, `The ${kind} input`) }),
+  kind,
+  // The host always validates JSON serialization, even without a stronger output declaration.
+  ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, `The ${kind} output`)) },
+  run: (context, input) => Effect_exports.tryPromise({
+    // SAFETY: defineApp checks the handler context against its requirements.
+    // The host validates account bindings and creates the matching storage facade.
+    try: () => run(context, input),
+    catch: (error) => error
+  })
+});
+var query = (options, run) => make("query", options, run);
+var mutation = (options, run) => make("mutation", options, run);
+
+// src/implementation/router.ts
+var routerDeclaration = (node) => ({
+  [NativeRouterKey]: node
+});
+var nativeRouter = (value) => {
+  if (typeof value !== "object" || value === null || !(NativeRouterKey in value)) return void 0;
+  return value[NativeRouterKey];
+};
+var nativeNode = (value) => nativeOperation(value) ?? nativeRouter(value);
+var metaOf = (options) => {
+  if (options === void 0) return void 0;
+  const defined = Object.fromEntries(
+    Object.entries(options).filter(([, value]) => value !== void 0)
+  );
+  return Object.keys(defined).length === 0 ? void 0 : Schema_exports.decodeUnknownSync(RouterMeta)(defined);
+};
+var mergeMeta = (base, override) => base === void 0 ? override : override === void 0 ? base : { ...base, ...override };
+function router(children, options) {
+  const meta = metaOf(options);
+  const existing = nativeRouter(children);
+  if (existing !== void 0)
+    return routerDeclaration(
+      existing.kind === "router" ? { ...existing, ...withMeta(mergeMeta(existing.meta, meta)) } : { ...existing, ...withOverrides(mergeMeta(existing.overrides, meta)) }
+    );
+  const nodes = {};
+  for (const [key, value] of Object.entries(children)) {
+    if (reservedRouterKeys.has(key)) throw new Error(`Router key "${key}" is reserved`);
+    if (!Schema_exports.is(RouterKey)(key))
+      throw new Error(`Router key "${key}" must start with a letter or _ and contain no dots`);
+    const node = nativeNode(value);
+    if (node === void 0)
+      throw new Error(`Router key "${key}" must be a query, mutation or router`);
+    nodes[key] = node;
+  }
+  return routerDeclaration({ kind: "router", ...withMeta(meta), children: nodes });
+}
+var withMeta = (meta) => meta === void 0 ? {} : { meta };
+var withOverrides = (overrides) => overrides === void 0 ? {} : { overrides };
+var dynamicRouter = (source) => {
+  const meta = source.meta;
+  return routerDeclaration({
+    kind: "dynamic",
+    ...meta === void 0 ? {} : {
+      meta: () => fromPromise(async () => meta())().pipe(
+        Effect_exports.flatMap((options) => Schema_exports.decodeUnknownEffect(RouterMeta)(options))
+      )
+    },
+    list: () => fromPromise(async () => source.list())().pipe(
+      Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedTool)))
+    ),
+    resolve: (name) => fromPromise(async () => source.resolve(name))().pipe(
+      Effect_exports.map((value) => {
+        if (value === void 0) return void 0;
+        const operation = nativeOperation(value);
+        if (operation === void 0) throw new Error("Expected an operation declaration");
+        return operation;
+      })
+    )
+  });
+};
+var joinPath = (path, name) => path === "" ? name : `${path}.${name}`;
+var locate = (root, name) => {
+  if (root?.kind === "dynamic") return { kind: "dynamic", source: root, router: "", name };
+  let current = root;
+  let path = "";
+  let rest = name;
+  while (current !== void 0) {
+    const dot = rest.indexOf(".");
+    const key = dot < 0 ? rest : rest.slice(0, dot);
+    const child = Object.hasOwn(current.children, key) ? current.children[key] : void 0;
+    if (child === void 0) return void 0;
+    const remaining = dot < 0 ? void 0 : rest.slice(dot + 1);
+    switch (child.kind) {
+      case "query":
+      case "mutation":
+        return remaining === void 0 ? { kind: "operation", operation: child, router: path } : void 0;
+      case "dynamic":
+        return remaining === void 0 || remaining === "" ? void 0 : { kind: "dynamic", source: child, router: joinPath(path, key), name: remaining };
+      case "router":
+        if (remaining === void 0) return void 0;
+        current = child;
+        path = joinPath(path, key);
+        rest = remaining;
+    }
+  }
+  return void 0;
+};
+var declaredOperations = (root, path = "") => Object.entries(root?.children ?? {}).flatMap(([key, child]) => {
+  const name = joinPath(path, key);
+  switch (child.kind) {
+    case "query":
+    case "mutation":
+      return [{ name, router: path, operation: child }];
+    case "router":
+      return declaredOperations(child, name);
+    case "dynamic":
+      return [];
+  }
+});
+var withApprovals = (source, policy) => {
+  const native = nativeRouter(source);
+  if (native === void 0) throw new Error("withApprovals expects a router");
+  const operation = (node, name) => {
+    const approval = policy(operationDeclaration(node), name);
+    return approval === void 0 ? node : approvedOperation(node, approval);
+  };
+  const child = (node, name) => {
+    switch (node.kind) {
+      case "query":
+      case "mutation":
+        return operation(node, name);
+      case "router":
+      case "dynamic":
+        return walk(node, name);
+    }
+  };
+  const walk = (node, path) => node.kind === "dynamic" ? {
+    ...node,
+    resolve: (name) => node.resolve(name).pipe(
+      Effect_exports.flatMap(
+        (resolved) => resolved === void 0 ? Effect_exports.succeed(void 0) : Effect_exports.try({
+          try: () => operation(resolved, joinPath(path, name)),
+          catch: (error) => error
+        })
+      )
+    )
+  } : {
+    ...node,
+    children: Object.fromEntries(
+      Object.entries(node.children).map(([key, value]) => [
+        key,
+        child(value, joinPath(path, key))
+      ])
+    )
+  };
+  return routerDeclaration(walk(native, ""));
+};
+
+export {
+  fromPromise,
+  toPromise,
+  operationDeclaration,
+  nativeOperation,
+  withApproval,
+  toolAnnotations,
+  query,
+  mutation,
+  routerDeclaration,
+  nativeRouter,
+  mergeMeta,
+  router,
+  dynamicRouter,
+  joinPath,
+  locate,
+  declaredOperations,
+  withApprovals
+};

package/js/{chunk-FDNTX5QJ.js → chunk-CQD3WSYH.js}

@@ -5,11 +5,11 @@ import {
   SkillDefinitionInvalid,
   SkillFile,
   SkillFilePath
-} from "./chunk-YEJOQEII.js";
+} from "./chunk-UOZMSUJ2.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/skill-files.ts
 var skillFromFiles = (input, source = {}) => Effect_exports.gen(function* () {

package/js/{chunk-EQB7JMAL.js → chunk-DHX2OI2X.js}

@@ -1,37 +1,52 @@
 import {
   adaptMcpTools,
+  answeredError,
   mcpClient,
   mcpJsonSchemaValidator
-} from "./chunk-2VPJHFOU.js";
+} from "./chunk-MYF7KWUB.js";
+import {
+  failOnNetworkRefusal
+} from "./chunk-KIM5HXNK.js";
 import {
   accountProviderError,
-  httpProviderError
-} from "./chunk-ZJWDMTE3.js";
+  bodyUpstreamError,
+  httpProviderError,
+  providerErrorDetail
+} from "./chunk-EM4UL26F.js";
 import {
+  McpCredentialsUnverified,
   McpError,
+  McpHealthInput,
   McpToolsOptions,
-  defaultMcpClientLimits
-} from "./chunk-3M2MEDNL.js";
+  defaultMcpClientLimits,
+  mcpHealthReserveMs
+} from "./chunk-OTCLXFLL.js";
 import {
+  NetworkRefused,
   ProviderError
-} from "./chunk-W7D7WVSY.js";
+} from "./chunk-P7MGDPFD.js";
 import {
   captureTelemetry
-} from "./chunk-ZCAMUXSG.js";
+} from "./chunk-PNVCCB4L.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-HDJH3RPR.js";
+} from "./chunk-VJQXXOQ3.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-3MMG2H6M.js";
 import {
+  Clock_exports,
   Deferred_exports,
   Effect_exports,
+  Match_exports,
+  Option_exports,
+  Predicate_exports,
   Redacted_exports,
+  Ref_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-MXDKXAY4.js";
 
 // src/implementation/mcp.ts
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
@@ -46,18 +61,45 @@ 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)) 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;
+  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: error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
-    ...status === void 0 ? {} : { status }
+    reason: code !== void 0 || unreadable(error) ? "invalid_response" : error instanceof ProtocolError && error.code === ErrorCode.RequestTimeout ? "timeout" : "request",
+    ...upstream === void 0 ? {} : { upstream }
   });
 };
-var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_exports.runPromiseWith(telemetry.context)(
+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),
@@ -67,26 +109,41 @@ var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_
       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 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({
-      try: () => HttpClientRequest_exports.fromWeb(new Request(target, { ...init, headers })),
-      catch: () => failure("transport", void 0)
+      try: () => {
+        const headers = new Headers(Redacted_exports.value(connection.headers));
+        new Headers(init?.headers).forEach((value, name) => headers.set(name, value));
+        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) {
-      yield* Deferred_exports.fail(rejected, provider);
-      return yield* provider;
+      const refused = providerErrorDetail(provider, { upstream });
+      yield* Deferred_exports.fail(rejected, refused);
+      return yield* refused;
     }
-    return new Response(
-      [204, 205, 304].includes(response.status) ? null : Stream_exports.toReadableStream(response.stream),
-      {
-        status: response.status,
-        headers: response.headers
-      }
+    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" }),
@@ -104,15 +161,34 @@ var transportFetch = (connection, telemetry, rejected) => (url, init) => Effect_
   ),
   init?.signal ? { signal: init.signal } : {}
 );
+var explain = (error, phase, responses) => {
+  if (Schema_exports.is(ProviderError)(error)) return providerErrorDetail(error, { phase });
+  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);
+          const fetch = transportFetch(connection, telemetry, rejected, answered);
           const client2 = new Client(
             { name: "executor-apps", version: "0.1.0" },
             {
@@ -168,10 +244,14 @@ function withClient(connection, mode, use, changed) {
         catch: (error) => failure("connect", error)
       }).pipe(
         Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.catch(explained("connect", answered)),
         Effect_exports.timeout(connection.timeoutMs),
         Effect_exports.withSpan("provider.mcp.connect")
       );
-      return yield* use(client).pipe(Effect_exports.raceFirst(Deferred_exports.await(rejected)));
+      return yield* use(client).pipe(
+        Effect_exports.raceFirst(Deferred_exports.await(rejected)),
+        Effect_exports.catch(explained(mode, answered))
+      );
     })
   ).pipe(
     Effect_exports.withSpan("provider.mcp.session", {
@@ -216,9 +296,44 @@ var mcpClientEffect = (input, changed) => Effect_exports.gen(function* () {
     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 }))
+    }),
+    Effect_exports.withSpan("provider.mcp.anonymous")
+  );
+}).pipe(Effect_exports.withSpan("provider.mcp.health"));
 var mcpToolsEffect = (input) => mcpClientEffect(input).pipe(Effect_exports.flatMap(adaptMcpTools));
 
 export {
   mcpClientEffect,
+  mcpHealthEffect,
   mcpToolsEffect
 };