apps 0.0.1-beta.6 → 0.0.1-beta.61

package/js/{chunk-57RKNWL2.js → chunk-PD6I2SDG.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-UK573G7W.js";
+} from "./chunk-EOPQ727L.js";
 import {
   Reference,
   Service,
@@ -13,16 +13,16 @@ import {
   getOrUndefined2 as getOrUndefined,
   map3 as map,
   merge3 as merge,
-  remove3 as remove,
+  remove2 as remove,
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-IFJU5SYQ.js";
 import {
   __export
 } from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/http/FetchHttpClient.js
+// ../../node_modules/.bun/effect@4.0.1/node_modules/effect/dist/http/FetchHttpClient.js
 var FetchHttpClient_exports = {};
 __export(FetchHttpClient_exports, {
   Fetch: () => Fetch,

package/js/{chunk-ITM77QPO.js → chunk-QE4JSN3X.js}

@@ -1,9 +1,10 @@
 import {
   prepareElicitation
-} from "./chunk-SB4HEPNJ.js";
+} from "./chunk-A4RQSTHG.js";
 import {
+  bodyUpstreamError,
   fromPromise
-} from "./chunk-T7GKZBLP.js";
+} from "./chunk-2A26IT3X.js";
 import {
   ElicitationFailed,
   McpError,
@@ -15,14 +16,18 @@ import {
   defaultElicitationLimits,
   defaultMcpClientLimits,
   mcpSdkTimerCeilingMs
-} from "./chunk-B3EOZTK3.js";
+} from "./chunk-TLWLJ7PD.js";
 import {
-  compileJsonSchemaDecoder,
-  jsonSchemaDecoder
-} from "./chunk-5T57N25Q.js";
+  jsonSchemaDecoder,
+  nestJsonSchema,
+  preparedJsonSchemaDecoder
+} from "./chunk-KGCTYL2S.js";
+import {
+  owned
+} from "./chunk-K6P2US3D.js";
 import {
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-H2CJWXA3.js";
 import {
   Clock_exports,
   Deferred_exports,
@@ -31,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();
@@ -62,10 +117,6 @@ 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;
     })
   };
@@ -81,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 {
@@ -133,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]);
@@ -149,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),
@@ -199,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",
@@ -210,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));
@@ -243,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" }
           })
@@ -284,16 +359,36 @@ function mcpClient(withClient, timeoutMs, failure) {
         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
 };

package/js/chunk-S34PXQUC.js

@@ -0,0 +1,266 @@
+import {
+  declaredOperations,
+  nativeOperation,
+  nativeRouter
+} from "./chunk-ANN7H2FL.js";
+import {
+  fromPromise,
+  method
+} from "./chunk-2A26IT3X.js";
+import {
+  EmittedEvent,
+  EventName,
+  ScheduleTiming,
+  defaultEventLimits
+} from "./chunk-TLWLJ7PD.js";
+import {
+  decoderOf,
+  isSchema,
+  jsonSchemaDocument,
+  schemaArgument
+} from "./chunk-KGCTYL2S.js";
+import {
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  Effect_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/contracts/http.ts
+var ResponseStatusError = class extends Schema_exports.TaggedError()(
+  "ResponseStatusError",
+  { status: Schema_exports.Number }
+) {
+  get message() {
+    return `Request failed with status ${this.status}`;
+  }
+};
+var ResponseDecodeError = class extends Schema_exports.TaggedError()(
+  "ResponseDecodeError",
+  {}
+) {
+  get message() {
+    return "Response body did not match the expected schema";
+  }
+};
+
+// src/implementation/workflows.ts
+var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
+var workflow = (options, run) => ({
+  [NativeWorkflow]: {
+    input: decoderOf(schemaArgument(options.input, "The workflow input")),
+    ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, "The workflow output")) },
+    ...options.description === void 0 ? {} : { description: options.description },
+    // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
+    run: (context, input) => fromPromise(run, "workflow")(context, input)
+  }
+});
+var nativeWorkflow = (value) => {
+  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
+  return value[NativeWorkflow];
+};
+
+// src/implementation/events.ts
+var Native = /* @__PURE__ */ Symbol("apps.Event");
+var scalarTypes = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+var isScalarSchema = (document) => {
+  const type = document.type;
+  if (typeof type === "string") return scalarTypes.has(type);
+  const choices = Array.isArray(document.enum) ? document.enum : "const" in document ? [document.const] : void 0;
+  return choices !== void 0 && choices.length > 0 && choices.every((value) => ["string", "number", "boolean"].includes(typeof value));
+};
+var event = (options) => {
+  const filters = options.filters ?? {};
+  const fieldDecoders = Object.fromEntries(
+    Object.entries(filters).map(([key, field]) => [
+      key,
+      decoderOf(schemaArgument(field, `The event filter ${JSON.stringify(key)}`))
+    ])
+  );
+  for (const [key, decoder] of Object.entries(fieldDecoders)) {
+    const document = Effect_exports.runSync(jsonSchemaDocument(decoder));
+    if (!isScalarSchema(document))
+      throw new TypeError(
+        `The event filter ${JSON.stringify(key)} must be a string, number, boolean or literal`
+      );
+  }
+  return {
+    [Native]: {
+      description: options.description,
+      filters: fieldDecoders,
+      payload: decoderOf(schemaArgument(options.payload, "The event payload"))
+    },
+    description: options.description,
+    filters,
+    payload: options.payload
+  };
+};
+var nativeEvent = (declaration) => typeof declaration === "object" && declaration !== null && Native in declaration ? declaration[Native] : void 0;
+var declaredEvents = (events) => Effect_exports.forEach(
+  Object.entries(events),
+  ([name, declared]) => Effect_exports.gen(function* () {
+    const filters = yield* jsonSchemaDocument(Schema_exports.Struct(declared.filters));
+    const payload = yield* jsonSchemaDocument(declared.payload);
+    return [name, { description: declared.description, filters, payload }];
+  })
+).pipe(Effect_exports.map((entries) => Object.fromEntries(entries)));
+var makeEmitter = (input) => ({
+  emit: (name, data, ...rest) => {
+    const options = rest[0] ?? {};
+    const declared = Object.hasOwn(input.events, name) ? input.events[name] : void 0;
+    if (declared === void 0) throw new TypeError(`This app declares no event named "${name}"`);
+    if (input.emitted.length >= defaultEventLimits.maxEventsPerInvocation)
+      throw new RangeError(
+        `An invocation can emit at most ${defaultEventLimits.maxEventsPerInvocation} events`
+      );
+    const payload = Schema_exports.decodeUnknownSync(declared.payload)(data);
+    const filters = Schema_exports.decodeUnknownSync(Schema_exports.Struct(declared.filters))(
+      options.filters ?? {}
+    );
+    const account = options.account ?? input.sourceAccount ?? (input.accounts.length === 1 ? input.accounts[0] : void 0) ?? null;
+    if (account === null && input.accounts.length > 1)
+      throw new TypeError(
+        "This invocation has several accounts; name the one the event came from with { account }"
+      );
+    if (account !== null && !input.accounts.includes(account))
+      throw new TypeError("The event's account is not one of this invocation's accounts");
+    const occurredAt = options.occurredAt === void 0 ? Date.now() : options.occurredAt instanceof Date ? options.occurredAt.getTime() : options.occurredAt;
+    const occurrence = Schema_exports.decodeUnknownSync(EmittedEvent)({
+      name: Schema_exports.decodeUnknownSync(EventName)(name),
+      id: options.id ?? crypto.randomUUID(),
+      occurredAt,
+      data: payload,
+      filters,
+      account
+    });
+    if (new TextEncoder().encode(JSON.stringify(occurrence.data)).byteLength > defaultEventLimits.maxDataBytes)
+      throw new RangeError(
+        `An event's data can be at most ${defaultEventLimits.maxDataBytes} bytes of JSON; send a summary and a tool to read the rest`
+      );
+    input.emitted.push(occurrence);
+  }
+});
+
+// src/implementation/app.ts
+var InternalApp = /* @__PURE__ */ Symbol("apps.App");
+var isApp = (value) => typeof value === "object" && value !== null && InternalApp in value;
+var toEffectApp = (app) => app[InternalApp];
+function rejectCatalogs(definition) {
+  if ("queries" in definition || "mutations" in definition)
+    throw new Error("Put queries and mutations in a router under tools");
+}
+function adaptDefinition(definition) {
+  rejectCatalogs(definition);
+  const webhooks = definition.webhooks === void 0 ? {} : {
+    // SAFETY: `Required` only where the optional method was just checked to be present.
+    webhooks: Object.fromEntries(
+      Object.entries(definition.webhooks).map(([name, webhook]) => [
+        name,
+        {
+          ...webhook,
+          ...webhook.register === void 0 ? {} : {
+            register: fromPromise(
+              method(webhook, "register"),
+              "webhook"
+            )
+          },
+          handle: fromPromise(method(webhook, "handle"), "webhook"),
+          ...webhook.unregister === void 0 ? {} : {
+            unregister: fromPromise(
+              method(webhook, "unregister"),
+              "webhook"
+            )
+          },
+          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
+          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
+        }
+      ])
+    )
+  };
+  const workflows = definition.workflows === void 0 ? {} : {
+    workflows: Object.fromEntries(
+      Object.entries(definition.workflows).map(([name, value]) => {
+        const declared2 = nativeWorkflow(value);
+        if (declared2 === void 0) throw new Error("Invalid workflow declaration");
+        return [name, declared2];
+      })
+    )
+  };
+  const root = definition.tools === void 0 ? void 0 : nativeRouter(definition.tools);
+  if (definition.tools !== void 0 && root === void 0)
+    throw new Error("tools must be a router");
+  const data = root === void 0 ? {} : { tools: root };
+  const declared = root?.kind === "router" ? declaredOperations(root) : [];
+  const mutations = /* @__PURE__ */ new Set();
+  for (const { operation } of declared) {
+    if (operation.kind !== "mutation") continue;
+    if (mutations.has(operation))
+      throw new Error("A mutation can be mounted at only one path in tools");
+    mutations.add(operation);
+  }
+  const schedules = definition.schedules === void 0 ? {} : {
+    schedules: Object.fromEntries(
+      Object.entries(definition.schedules).map(([name, schedule]) => {
+        const target = nativeOperation(schedule.operation);
+        const match = declared.find(
+          ({ operation }) => operation === target && operation.kind === "mutation"
+        );
+        if (match === void 0)
+          throw new Error("A schedule must reference a mutation in this app's tools");
+        return [
+          name,
+          {
+            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
+            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
+            tool: match.name
+          }
+        ];
+      })
+    )
+  };
+  return {
+    ...definition,
+    ...webhooks,
+    ...workflows,
+    ...data,
+    ...schedules
+  };
+}
+var defineApp = (requirements, definition) => {
+  if (typeof definition !== "function") rejectCatalogs(definition);
+  const evaluate = typeof definition === "function" ? definition : async () => definition;
+  const factory = fromPromise(evaluate, "factory");
+  const events = requirements.events === void 0 ? void 0 : Object.fromEntries(
+    Object.entries(requirements.events).map(([name, declared]) => {
+      const native2 = nativeEvent(declared);
+      if (native2 === void 0)
+        throw new TypeError(
+          `The event ${JSON.stringify(name)} must be declared with event()`
+        );
+      return [name, native2];
+    })
+  );
+  const native = {
+    accounts: requirements.accounts,
+    ...events === void 0 ? {} : { events },
+    evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
+  };
+  return {
+    [InternalApp]: native,
+    accounts: native.accounts,
+    evaluate: (context) => Effect_exports.runPromise(factory(context))
+  };
+};
+
+export {
+  ResponseStatusError,
+  ResponseDecodeError,
+  workflow,
+  event,
+  declaredEvents,
+  makeEmitter,
+  isApp,
+  toEffectApp,
+  defineApp
+};