apps 0.0.1-beta.3 → 0.0.1-beta.30

package/js/chunk-6VWYEQ4X.js

@@ -0,0 +1,254 @@
+import {
+  HostedTool,
+  RouterKey,
+  RouterMeta,
+  reservedRouterKeys
+} from "./chunk-BSRU52RU.js";
+import {
+  decoderOf
+} from "./chunk-YML53Z7H.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-NXTXZ635.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),
+  kind,
+  // The host always validates JSON serialization, even without a stronger output declaration.
+  ...options.output === void 0 ? {} : { output: decoderOf(options.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-RN2MXB4R.js → chunk-AE4FWJQU.js}

@@ -1,26 +1,32 @@
 import {
   prepareElicitation
-} from "./chunk-J7O55ZV7.js";
+} from "./chunk-6NK26ONC.js";
 import {
   fromPromise
-} from "./chunk-PYUYJRSK.js";
+} from "./chunk-6VWYEQ4X.js";
+import {
+  bodyUpstreamError
+} from "./chunk-KQCMHI3K.js";
 import {
   ElicitationFailed,
   McpError,
+  McpServerHeader,
   McpToolMetadata,
   McpToolResult,
+  RouterIcon,
   ToolResultObservation,
   defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-MYYEW3RA.js";
+} from "./chunk-BSRU52RU.js";
 import {
-  compileJsonSchemaDecoder,
-  jsonSchemaDecoder
-} from "./chunk-WFSQXYUT.js";
+  jsonSchemaDecoder,
+  nestJsonSchema,
+  preparedJsonSchemaDecoder
+} from "./chunk-YML53Z7H.js";
 import {
   JsonObject
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-PWF2DRJ3.js";
 import {
   Clock_exports,
   Deferred_exports,
@@ -29,29 +35,79 @@ import {
   Option_exports,
   Queue_exports,
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-NXTXZ635.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 +116,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 +131,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 {
@@ -208,6 +264,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 +303,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,
@@ -263,18 +333,52 @@ 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 check = withClient(
+    "discover",
+    (client) => Effect_exports.tryPromise({
+      try: (signal) => client.request({ method: "tools/list", params: {} }, ListToolsResultSchema, {
+        signal,
+        timeout: timeoutMs
+      }),
+      catch: (error) => failure("discover", error)
+    }).pipe(
+      Effect_exports.asVoid,
+      Effect_exports.withSpan("provider.mcp.request", {
+        kind: "client",
+        attributes: { "rpc.system.name": "jsonrpc", "rpc.method": "tools/list" }
+      })
+    )
+  ).pipe(Effect_exports.withSpan("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 } })
   );
-  return { list, call };
+  return { list, check, call };
 }
 
 export {
   adaptMcpTool,
   adaptMcpTools,
+  answeredError,
   mcpJsonSchemaValidator,
   mcpClient
 };

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

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-QKHR7BMF.js";
+} from "./chunk-XGN5IFOZ.js";
 import {
   Reference,
   Service,
@@ -17,7 +17,7 @@ import {
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-NXTXZ635.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";

package/js/{chunk-LGIYBDWA.js → chunk-BRGF7VFN.js}

@@ -1,6 +1,55 @@
+import {
+  AccountId
+} from "./chunk-PWF2DRJ3.js";
 import {
   Schema_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-NXTXZ635.js";
+
+// src/contracts/failure.ts
+var maxFailureMessageLength = 2048;
+var FailureSource = Schema_exports.Literals(["app", "storage", "service"]);
+var FailureName = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureCode = Schema_exports.String.check(Schema_exports.isMaxLength(128));
+var FailureMessage = Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureMessageLength));
+var maxFailureFields = 8;
+var maxFailureFieldLength = 256;
+var FailureFieldName = Schema_exports.String.check(
+  Schema_exports.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]{0,63}$/)
+);
+var FailureFieldValue = Schema_exports.Union([
+  Schema_exports.String.check(Schema_exports.isMaxLength(maxFailureFieldLength)),
+  Schema_exports.Finite,
+  Schema_exports.Boolean
+]);
+var FailureFields = Schema_exports.Record(FailureFieldName, FailureFieldValue).check(
+  Schema_exports.isMaxProperties(maxFailureFields)
+);
+var FailureDetail = {
+  source: Schema_exports.optionalKey(FailureSource),
+  errorName: Schema_exports.optionalKey(FailureName),
+  code: Schema_exports.optionalKey(FailureCode),
+  message: Schema_exports.optionalKey(FailureMessage),
+  fields: Schema_exports.optionalKey(FailureFields)
+};
+var maxUpstreamMessageLength = 1024;
+var UpstreamError = Schema_exports.Struct({
+  code: Schema_exports.Union([
+    Schema_exports.Int,
+    Schema_exports.String.check(Schema_exports.isMinLength(1), Schema_exports.isMaxLength(128))
+  ]),
+  message: Schema_exports.optionalKey(Schema_exports.String.check(Schema_exports.isMaxLength(maxUpstreamMessageLength)))
+});
+var FailurePhase = Schema_exports.Literals(["connect", "discover", "call"]);
+
+// src/contracts/provider-error.ts
+var ProviderError = class extends Schema_exports.TaggedError()("ProviderError", {
+  reason: Schema_exports.Literals(["unauthorized", "forbidden", "rate_limited", "unavailable", "rejected"]),
+  status: Schema_exports.optional(Schema_exports.Int.check(Schema_exports.isBetween({ minimum: 100, maximum: 599 }))),
+  accountId: Schema_exports.optional(AccountId),
+  phase: Schema_exports.optional(FailurePhase),
+  upstream: Schema_exports.optional(UpstreamError)
+}) {
+};
 
 // ../app-cache/src/contracts/cache.ts
 var CacheError = class extends Schema_exports.TaggedError()("CacheError", {
@@ -76,6 +125,21 @@ var CacheReply = Schema_exports.Union([
 ]);
 
 export {
+  maxFailureMessageLength,
+  FailureSource,
+  FailureName,
+  FailureCode,
+  FailureMessage,
+  maxFailureFields,
+  maxFailureFieldLength,
+  FailureFieldName,
+  FailureFieldValue,
+  FailureFields,
+  FailureDetail,
+  maxUpstreamMessageLength,
+  UpstreamError,
+  FailurePhase,
+  ProviderError,
   CacheError,
   cacheLimits,
   CacheEntry,