apps 0.0.1-beta.7 → 0.0.1-beta.73

package/js/{chunk-IPI4MFSN.js → chunk-XBG7HHXC.js}

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

package/js/{chunk-Z5M2LQOZ.js → chunk-ZEJ3IKEC.js}

@@ -1,48 +1,20 @@
+import {
+  fromPromise
+} from "./chunk-ZR7QAG67.js";
 import {
   HostedTool,
   RouterKey,
   RouterMeta,
   reservedRouterKeys
-} from "./chunk-WLE7WX2U.js";
+} from "./chunk-JW5LYSER.js";
 import {
-  decoderOf
-} from "./chunk-5T57N25Q.js";
+  decoderOf,
+  schemaArgument
+} from "./chunk-KGCTYL2S.js";
 import {
   Effect_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.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
-  });
-};
+} from "./chunk-IFJU5SYQ.js";
 
 // src/implementation/operations.ts
 var NativeOperation = /* @__PURE__ */ Symbol("apps.Operation");
@@ -64,28 +36,30 @@ var operationOptions = (options) => {
     ...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 })
+      approval: (context) => fromPromise(async () => approval(context), "approval")()
     }
   };
 };
+var approvedOperation = (operation, approval) => {
+  const copy = Object.defineProperties({}, Object.getOwnPropertyDescriptors(operation));
+  return Object.defineProperty(copy, "approval", {
+    enumerable: true,
+    value: (context) => fromPromise(async () => approval(context), "approval")()
+  });
+};
 var withApproval = (operation, approval) => ({
   ...operation,
-  [NativeOperation]: {
-    ...operation[NativeOperation],
-    approval: (context) => Effect_exports.tryPromise({ try: async () => approval(context), catch: (error) => error })
-  }
+  [NativeOperation]: approvedOperation(operation[NativeOperation], approval)
 });
+var toolAnnotations = (operation) => nativeOperation(operation)?.annotations;
 var make = (kind, options, run) => operationDeclaration({
-  ...operationOptions(options),
+  ...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(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
-  })
+  ...options.output === void 0 ? {} : { output: decoderOf(schemaArgument(options.output, `The ${kind} output`)) },
+  // SAFETY: defineApp checks the handler context against its requirements.
+  // The host validates account bindings and creates the matching storage facade.
+  run: (context, input) => fromPromise(run, "handler")(context, input)
 });
 var query = (options, run) => make("query", options, run);
 var mutation = (options, run) => make("mutation", options, run);
@@ -133,14 +107,14 @@ var dynamicRouter = (source) => {
   return routerDeclaration({
     kind: "dynamic",
     ...meta === void 0 ? {} : {
-      meta: () => fromPromise(async () => meta())().pipe(
+      meta: () => fromPromise(async () => meta(), "router")().pipe(
         Effect_exports.flatMap((options) => Schema_exports.decodeUnknownEffect(RouterMeta)(options))
       )
     },
-    list: () => fromPromise(async () => source.list())().pipe(
+    list: () => fromPromise(async () => source.list(), "router")().pipe(
       Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedTool)))
     ),
-    resolve: (name) => fromPromise(async () => source.resolve(name))().pipe(
+    resolve: (name) => fromPromise(async () => source.resolve(name), "router")().pipe(
       Effect_exports.map((value) => {
         if (value === void 0) return void 0;
         const operation = nativeOperation(value);
@@ -189,13 +163,50 @@ var declaredOperations = (root, path = "") => Object.entries(root?.children ?? {
       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,
@@ -205,5 +216,6 @@ export {
   dynamicRouter,
   joinPath,
   locate,
-  declaredOperations
+  declaredOperations,
+  withApprovals
 };

package/js/chunk-ZR7QAG67.js

@@ -0,0 +1,171 @@
+import {
+  ProviderError,
+  maxUpstreamMessageLength
+} from "./chunk-7LMU3ER3.js";
+import {
+  owned
+} from "./chunk-3CVQ3VPP.js";
+import {
+  AccountId
+} from "./chunk-H2CJWXA3.js";
+import {
+  Effect_exports,
+  Option_exports,
+  Schema_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/authoring.ts
+var NativeCallback = /* @__PURE__ */ Symbol("apps.NativeCallback");
+var appCode = (code) => owned("app", "app.code", { attributes: { "executor.app.code": code } });
+var fromPromise = (callback, code) => (...args) => {
+  if (NativeCallback in callback) {
+    const native = callback[NativeCallback];
+    return native(...args);
+  }
+  return Effect_exports.tryPromise({ try: () => callback(...args), catch: (error) => error }).pipe(
+    appCode(code)
+  );
+};
+var method = (target, key) => {
+  const value = target[key];
+  const call = (...args) => Reflect.apply(value, target, args);
+  if (NativeCallback in value) Object.assign(call, { [NativeCallback]: value[NativeCallback] });
+  return call;
+};
+var toPromise = (operation, signalOf, services) => {
+  const native = (...args) => Effect_exports.suspend(() => {
+    const signal = typeof signalOf === "function" ? signalOf(...args) : signalOf;
+    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) => services === void 0 ? Effect_exports.runPromise(native(...args)) : Effect_exports.runPromiseWith(services)(native(...args)),
+    {
+      [NativeCallback]: native
+    }
+  );
+};
+
+// src/implementation/upstream-error.ts
+var ErrorToken = Schema_exports.String.check(Schema_exports.isPattern(/^[A-Za-z0-9._-]{1,128}$/u));
+var NestedError = Schema_exports.Struct({
+  error: Schema_exports.Struct({ code: Schema_exports.Union([Schema_exports.Int, ErrorToken]), message: Schema_exports.String })
+});
+var OAuthError = Schema_exports.Struct({
+  error: ErrorToken,
+  error_description: Schema_exports.optional(Schema_exports.String)
+});
+var bounded = (message) => message.length <= maxUpstreamMessageLength ? message : `${message.slice(0, maxUpstreamMessageLength - 1)}\u2026`;
+var isShortenedUpstream = (message) => message.length === maxUpstreamMessageLength && message.endsWith("\u2026");
+var stated = (code, message) => ({
+  code,
+  ...message === void 0 || message === "" ? {} : { message: bounded(message) }
+});
+var bodyUpstreamError = (json) => {
+  const nested = Schema_exports.decodeUnknownOption(NestedError)(json);
+  if (Option_exports.isSome(nested)) return stated(nested.value.error.code, nested.value.error.message);
+  const oauth = Schema_exports.decodeUnknownOption(OAuthError)(json);
+  if (Option_exports.isSome(oauth)) return stated(oauth.value.error, oauth.value.error_description);
+  return void 0;
+};
+var authParam = /([A-Za-z][A-Za-z0-9_-]*)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|([^\s,"]+))/g;
+var challengeUpstreamError = (header) => {
+  const bearer = header === void 0 ? -1 : header.search(/\bBearer\b/i);
+  if (header === void 0 || bearer === -1) return void 0;
+  const params = /* @__PURE__ */ new Map();
+  for (const [, name, quoted, token] of header.slice(bearer + "Bearer".length).matchAll(authParam))
+    if (name !== void 0 && !params.has(name.toLowerCase()))
+      params.set(name.toLowerCase(), quoted?.replace(/\\(.)/g, "$1") ?? token ?? "");
+  const code = Schema_exports.decodeUnknownOption(ErrorToken)(params.get("error"));
+  return Option_exports.isNone(code) ? void 0 : stated(code.value, params.get("error_description"));
+};
+
+// src/implementation/provider-error.ts
+var providerError = ({
+  reason,
+  status,
+  accountId,
+  phase,
+  upstream
+}) => new ProviderError({
+  reason,
+  ...status === void 0 ? {} : { status },
+  ...accountId === void 0 ? {} : { accountId },
+  ...phase === void 0 ? {} : { phase },
+  ...upstream === void 0 ? {} : { upstream }
+});
+function parseProviderError(error) {
+  return Schema_exports.decodeUnknownOption(ProviderError)(error).pipe(Option_exports.map(providerError));
+}
+function providerErrorDetail(error, detail) {
+  return providerError({
+    ...error,
+    phase: error.phase ?? detail.phase,
+    upstream: error.upstream ?? detail.upstream
+  });
+}
+function httpProviderError(status, headers = {}) {
+  const upstream = challengeUpstreamError(headers["www-authenticate"]);
+  if (status >= 500 && status <= 599)
+    return providerError({ reason: "unavailable", status, upstream });
+  if (status === 401) return providerError({ reason: "unauthorized", status, upstream });
+  if (status === 429) return providerError({ reason: "rate_limited", status, upstream });
+  if (status !== 403) return void 0;
+  const retry = headers["retry-after"];
+  if (headers["x-ratelimit-remaining"] === "0" || retry !== void 0 && (/^\d+$/.test(retry) || Number.isFinite(Date.parse(retry))))
+    return providerError({ reason: "rate_limited", status, upstream });
+  if (typeof upstream?.code === "string" && upstream.code.toLowerCase() === "insufficient_scope")
+    return providerError({ reason: "forbidden", status, upstream });
+  return providerError({ reason: "rejected", status, upstream });
+}
+function accountProviderError(error, accountId) {
+  const parsed = parseProviderError(error);
+  const account = Schema_exports.decodeUnknownOption(AccountId)(accountId);
+  if (Option_exports.isNone(parsed) || Option_exports.isNone(account)) return error;
+  return providerError({ ...parsed.value, accountId: account.value });
+}
+function graphqlProviderError(errors, status) {
+  const codes = errors.flatMap((error) => {
+    const parsed = Schema_exports.decodeUnknownOption(
+      Schema_exports.Struct({
+        type: Schema_exports.optional(Schema_exports.String),
+        extensions: Schema_exports.optional(Schema_exports.Struct({ code: Schema_exports.optional(Schema_exports.String) }))
+      })
+    )(error);
+    return Option_exports.isSome(parsed) ? [parsed.value.type, parsed.value.extensions?.code] : [];
+  });
+  if (codes.includes("RATE_LIMITED") || codes.includes("TOO_MANY_REQUESTS"))
+    return new ProviderError({ reason: "rate_limited", status });
+  if (codes.includes("UNAUTHENTICATED"))
+    return new ProviderError({ reason: "unauthorized", status });
+  if (codes.includes("FORBIDDEN")) return new ProviderError({ reason: "forbidden", status });
+  return void 0;
+}
+
+export {
+  appCode,
+  fromPromise,
+  method,
+  toPromise,
+  isShortenedUpstream,
+  bodyUpstreamError,
+  providerError,
+  parseProviderError,
+  providerErrorDetail,
+  httpProviderError,
+  accountProviderError,
+  graphqlProviderError
+};