apps 0.0.1-beta.5 → 0.0.1-beta.54

package/js/chunk-7UUHJR2Q.js

@@ -0,0 +1,49 @@
+import {
+  FetchOptionUnsupported,
+  NetworkRefusedHeader,
+  RestrictedFetchOption,
+  networkRefusalHeader,
+  networkRefusalStatus,
+  supportedFetchOptions
+} from "./chunk-MWKHKOTL.js";
+import {
+  invocationFetch
+} from "./chunk-JM7LOD2W.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/network.ts
+var refusalHeader = (status, header) => status === networkRefusalStatus && header !== null && header !== void 0 ? header : void 0;
+var failOnNetworkRefusal = (response) => {
+  const header = refusalHeader(response.status, response.headers[networkRefusalHeader]);
+  return header === void 0 ? Effect_exports.void : Schema_exports.decodeUnknownEffect(NetworkRefusedHeader)(header).pipe(
+    Effect_exports.orDie,
+    Effect_exports.flatMap(Effect_exports.fail)
+  );
+};
+var unsupportedOption = (init) => {
+  for (const option of RestrictedFetchOption.literals) {
+    const value = init?.[option];
+    const supported = supportedFetchOptions[option];
+    if (value !== void 0 && !supported.includes(value))
+      return new FetchOptionUnsupported({ option, value: String(value), supported });
+  }
+  return void 0;
+};
+var appFetch = (fetch) => async (input, init) => {
+  const unsupported = unsupportedOption(init);
+  if (unsupported !== void 0) throw unsupported;
+  const response = await fetch(input, init);
+  const header = refusalHeader(response.status, response.headers.get(networkRefusalHeader));
+  if (header === void 0) return response;
+  await response.body?.cancel();
+  throw Schema_exports.decodeUnknownSync(NetworkRefusedHeader)(header);
+};
+var appInvocationFetch = (signal) => invocationFetch(signal).pipe(Effect_exports.map(appFetch));
+
+export {
+  failOnNetworkRefusal,
+  appInvocationFetch
+};

package/js/{chunk-CYYBFC2K.js → chunk-AQU56EPI.js}

@@ -3,14 +3,14 @@ import {
   CacheEntry,
   CacheError,
   cacheLimits
-} from "./chunk-YEPYT6SD.js";
+} from "./chunk-MWKHKOTL.js";
 import {
   Clock_exports,
   Duration_exports,
   Effect_exports,
   Exit_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // ../app-cache/src/index.ts
 var canonical = (value) => {
@@ -111,13 +111,14 @@ var makeCache = (host, background, scope = "shared", deadline) => {
         yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
         return yield* decode(entry.value);
       }
-      if (!refresh && entry !== null && now < entry.staleUntil) {
+      const kept = !refresh && entry !== null && now < entry.staleUntil;
+      if (kept && options.stale !== "revalidate") {
         yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
         if (lease !== null) yield* background(load(lease).pipe(Effect_exports.asVoid));
         return yield* decode(entry.value);
       }
       if (lease !== null) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "miss");
+        yield* Effect_exports.annotateCurrentSpan("cache.result", kept ? "revalidated" : "miss");
         return yield* load(lease);
       }
       if (now >= waitUntil) {
@@ -159,7 +160,10 @@ var makeCache = (host, background, scope = "shared", deadline) => {
       Effect_exports.flatMap((key2) => transport({ operation: "invalidate", key: key2 })),
       Effect_exports.asVoid
     ),
-    /** Read fresh data, refresh stale data in the background, or wait for the lease owner. */
+    /**
+     * Read fresh data, refresh stale data in the background (or first, with `stale: "revalidate"`),
+     * or wait for the lease owner.
+     */
     get: (options) => get(options, false),
     /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
     revalidate: (options) => get(options, true)

package/js/chunk-CDXQDN7W.js

@@ -0,0 +1,92 @@
+import {
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApiSchema_exports,
+  HttpApi_exports
+} from "./chunk-TUMGL2OC.js";
+import {
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/ui.ts
+var UiContext = Schema_exports.Struct({
+  deployment: Schema_exports.NonEmptyString,
+  profile: Schema_exports.optional(Schema_exports.NonEmptyString),
+  expectedProfileRevision: Schema_exports.optional(Schema_exports.Int)
+});
+var UiOperation = Schema_exports.Struct({
+  ...UiContext.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+});
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiDeploymentChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiDeploymentChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiDeploymentChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};

package/js/{chunk-UDDE5KOR.js → chunk-D45JTD6N.js}

@@ -1,26 +1,33 @@
 import {
   prepareElicitation
-} from "./chunk-LUVSFETN.js";
+} from "./chunk-PO5NPRFT.js";
 import {
+  bodyUpstreamError,
   fromPromise
-} from "./chunk-3XKZDQLM.js";
+} from "./chunk-LTDHQJ2Z.js";
 import {
   ElicitationFailed,
   McpError,
+  McpServerHeader,
   McpToolMetadata,
   McpToolResult,
+  RouterIcon,
   ToolResultObservation,
   defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-DQAZTA4I.js";
+} from "./chunk-JY56GVSV.js";
 import {
-  compileJsonSchemaDecoder,
-  jsonSchemaDecoder
-} from "./chunk-FWQC6I3C.js";
+  jsonSchemaDecoder,
+  nestJsonSchema,
+  preparedJsonSchemaDecoder
+} from "./chunk-KGCTYL2S.js";
+import {
+  owned
+} from "./chunk-JM7LOD2W.js";
 import {
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-H2CJWXA3.js";
 import {
   Clock_exports,
   Deferred_exports,
@@ -29,29 +36,79 @@ import {
   Option_exports,
   Queue_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 
 // src/implementation/mcp-tools.ts
+var resultFields = {
+  content: { type: "array", items: { type: "object" } },
+  structuredContent: { type: "object" },
+  isError: { type: "boolean" },
+  _meta: { type: "object" }
+};
+var definitionReference = /^#\/(?:\$defs|definitions)\/[^/]+$/;
+var locating = /* @__PURE__ */ new Set(["$id", "$anchor", "$dynamicAnchor", "$recursiveAnchor"]);
+var onlyDefinitionReferences = (value) => Array.isArray(value) ? value.every(onlyDefinitionReferences) : value === null || typeof value !== "object" ? true : Object.entries(value).every(
+  ([key, item]) => locating.has(key) || key === "$dynamicRef" || key === "$recursiveRef" ? false : key === "$ref" ? typeof item === "string" && definitionReference.test(item) : onlyDefinitionReferences(item)
+);
+var placed = (structuredContent, pointer) => {
+  if (onlyDefinitionReferences(structuredContent)) {
+    const { $defs, definitions, $schema: _draft, ...schema } = structuredContent;
+    return {
+      schema,
+      root: {
+        ...$defs === void 0 ? {} : { $defs },
+        ...definitions === void 0 ? {} : { definitions }
+      }
+    };
+  }
+  try {
+    return { schema: nestJsonSchema(structuredContent, pointer), root: {} };
+  } catch {
+    return { schema: structuredContent, root: {} };
+  }
+};
+var resultSchema = (structuredContent) => {
+  if (structuredContent === void 0)
+    return { type: "object", properties: resultFields, required: ["content"] };
+  const { schema, root } = placed(structuredContent, "#/anyOf/0/properties/structuredContent");
+  return {
+    // The envelope's keywords mean the same in every draft, so the server's draft applies.
+    ...structuredContent.$schema === void 0 ? {} : { $schema: structuredContent.$schema },
+    ...root,
+    anyOf: [
+      {
+        type: "object",
+        properties: { ...resultFields, structuredContent: schema, isError: { const: false } },
+        required: ["content", "structuredContent"]
+      },
+      {
+        type: "object",
+        properties: { ...resultFields, isError: { const: true } },
+        required: ["content", "isError"]
+      }
+    ]
+  };
+};
 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 output = preparedJsonSchemaDecoder(resultSchema(tool.outputSchema));
+  const { outputSchema: _upstream, ...metadata } = tool;
   const adapted = {
-    ...tool,
+    ...metadata,
     description: tool.description ?? tool.title ?? tool.name,
     input: decoder,
+    output: output.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;
+      yield* output.compile.pipe(
+        Effect_exports.mapError(() => new McpError({ phase: "schema", reason: "invalid_response" }))
+      );
       const result = yield* client.call(tool.name, arguments_, context);
       if (result.isError === true) {
         (yield* ToolResultObservation).failed();
@@ -60,17 +117,13 @@ var adaptMcpTool = (client, tool) => Effect_exports.gen(function* () {
           "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) => adaptMcpTool(client, tool).pipe(Effect_exports.map((adapted) => [tool.name, adapted]))
@@ -79,7 +132,11 @@ var adaptMcpTools = (client) => Effect_exports.gen(function* () {
 });
 
 // src/implementation/mcp-client.ts
-import { ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import {
+  ErrorCode as ErrorCode2,
+  ListToolsResultSchema,
+  McpError as ProtocolError2
+} from "@modelcontextprotocol/sdk/types.js";
 
 // src/implementation/mcp-call.ts
 import {
@@ -131,11 +188,14 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
     const callbacks = /* @__PURE__ */ new Set();
     const lifetime = yield* Effect_exports.acquireRelease(
       Effect_exports.sync(() => new AbortController()),
-      (controller) => Effect_exports.promise(async () => {
-        controller.abort();
-        client.removeRequestHandler("elicitation/create");
-        await Promise.allSettled(callbacks);
-      })
+      (controller) => (
+        // oxlint-disable-next-line executor/authored-code-through-adapter -- the MCP SDK's elicitation callbacks
+        Effect_exports.promise(async () => {
+          controller.abort();
+          client.removeRequestHandler("elicitation/create");
+          await Promise.allSettled(callbacks);
+        })
+      )
     );
     client.setRequestHandler(ElicitRequestSchema, (request, extra) => {
       const signal = AbortSignal.any([lifetime.signal, extra.signal]);
@@ -147,7 +207,10 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
         const deliver = context.elicit;
         if (deliver === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
         const answer = yield* budget.waitForInput(
-          fromPromise(deliver)(form.request).pipe(
+          fromPromise(
+            deliver,
+            "elicitation"
+          )(form.request).pipe(
             Effect_exports.mapError(
               (error) => Option_exports.getOrElse(
                 Schema_exports.decodeUnknownOption(ElicitationFailed)(error),
@@ -197,7 +260,7 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
     );
   })
 ).pipe(
-  Effect_exports.withSpan("provider.mcp.request", {
+  owned("upstream", "provider.mcp.request", {
     kind: "client",
     attributes: {
       "rpc.system.name": "jsonrpc",
@@ -208,6 +271,20 @@ var mcpCall = (client, name, input, context, timeoutMs, failure) => Effect_expor
 );
 
 // src/implementation/mcp-client.ts
+var clientCodes = /* @__PURE__ */ new Set([
+  ErrorCode2.RequestTimeout,
+  ErrorCode2.ConnectionClosed
+]);
+var answeredError = (error) => {
+  if (!(error instanceof ProtocolError2) || clientCodes.has(error.code)) return void 0;
+  const prefix = `MCP error ${error.code}: `;
+  return bodyUpstreamError({
+    error: {
+      code: error.code,
+      message: error.message.startsWith(prefix) ? error.message.slice(prefix.length) : error.message
+    }
+  });
+};
 var mcpJsonSchemaValidator = {
   getValidator(document) {
     const decoder = Effect_exports.runSync(jsonSchemaDecoder(document));
@@ -233,7 +310,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,
@@ -241,7 +318,7 @@ function mcpClient(withClient, timeoutMs, failure) {
           ),
           catch: (error) => failure("discover", error)
         }).pipe(
-          Effect_exports.withSpan("provider.mcp.request", {
+          owned("upstream", "provider.mcp.request", {
             kind: "client",
             attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
           })
@@ -263,18 +340,55 @@ 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"));
+  ).pipe(owned("upstream", "provider.mcp.discover"));
+  const check = withClient(
+    "discover",
+    (client) => (
+      // oxlint-disable-next-line executor/authored-code-through-adapter -- MCP SDK
+      Effect_exports.tryPromise({
+        try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
+          signal,
+          timeout: timeoutMs
+        }),
+        catch: (error) => failure("discover", error)
+      }).pipe(
+        Effect_exports.asVoid,
+        owned("upstream", "provider.mcp.request", {
+          kind: "client",
+          attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
+        })
+      )
+    )
+  ).pipe(owned("upstream", "provider.mcp.check"));
   const call = (name, input, context) => withClient("call", (client) => mcpCall(client, name, input, context, timeoutMs, failure)).pipe(
-    Effect_exports.withSpan("provider.mcp.call", { attributes: { "mcp.tool.name": name } })
+    owned("upstream", "provider.mcp.call", { attributes: { "mcp.tool.name": name } })
   );
-  return { list, call };
+  return { list, check, call };
 }
 
 export {
   adaptMcpTool,
   adaptMcpTools,
+  answeredError,
   mcpJsonSchemaValidator,
   mcpClient
 };