apps 0.0.1-beta.11 → 0.0.1-beta.110

package/js/chunk-OIH73VFM.js

@@ -0,0 +1,175 @@
+import {
+  ProviderError,
+  maxUpstreamMessageLength
+} from "./chunk-2RGJMA7N.js";
+import {
+  owned
+} from "./chunk-URKOTNDA.js";
+import {
+  AccountId
+} from "./chunk-7HG422GB.js";
+import {
+  Effect_exports,
+  Option_exports,
+  Schema_exports
+} from "./chunk-ZKDXML77.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 boundStated = (text, maximum) => text.length <= maximum ? text : `${text.slice(0, maximum - 1)}\u2026`;
+var isShortenedStated = (text, maximum) => text.length === maximum && text.endsWith("\u2026");
+var bounded = (message) => boundStated(message, maxUpstreamMessageLength);
+var statedUpstream = (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 statedUpstream(nested.value.error.code, nested.value.error.message);
+  const oauth = Schema_exports.decodeUnknownOption(OAuthError)(json);
+  if (Option_exports.isSome(oauth)) return statedUpstream(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 : statedUpstream(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,
+  boundStated,
+  isShortenedStated,
+  statedUpstream,
+  bodyUpstreamError,
+  providerError,
+  parseProviderError,
+  providerErrorDetail,
+  httpProviderError,
+  accountProviderError,
+  graphqlProviderError
+};

package/js/chunk-OWN3DP2W.js

@@ -0,0 +1,88 @@
+import {
+  Predicate_exports
+} from "./chunk-ZKDXML77.js";
+
+// ../utils/src/recorded-message.ts
+var RecordedMessage = /* @__PURE__ */ Symbol.for("@executor-js/utils/RecordedMessage");
+var recordedMessage = (error) => {
+  if (Predicate_exports.hasProperty(error, RecordedMessage)) {
+    const message = error[RecordedMessage];
+    return typeof message === "string" ? message : void 0;
+  }
+  return protocolErrorMessage(error) ?? sqlErrorMessage(error);
+};
+var jsonRpcMeanings = {
+  [-32700]: "Parse error",
+  [-32600]: "Invalid request",
+  [-32601]: "Method not found",
+  [-32602]: "Invalid params",
+  [-32603]: "Internal error",
+  [-32002]: "Resource not found"
+};
+var protocolErrorMessage = (error) => {
+  if (!Predicate_exports.isTagged(error, "ProtocolError") || !Predicate_exports.hasProperty(error, "code") || typeof error.code !== "number" || !Predicate_exports.hasProperty(error, "message") || !Predicate_exports.isString(error.message))
+    return void 0;
+  const code = error.code;
+  const refusal = /^Tool '.*' not found$/s.test(error.message) ? ": the requested tool does not exist" : error.message.startsWith("Invalid parameters for tool '") ? ": the tool's arguments failed validation" : "";
+  const meaning = jsonRpcMeanings[code];
+  const kind = meaning === void 0 ? "JSON-RPC error with an unlisted code" : `${meaning} (${code})`;
+  return kind + refusal;
+};
+var sqlReasons = /* @__PURE__ */ new Set([
+  "ConnectionError",
+  "AuthenticationError",
+  "AuthorizationError",
+  "SqlSyntaxError",
+  "UniqueViolation",
+  "ConstraintError",
+  "DeadlockError",
+  "SerializationError",
+  "LockTimeoutError",
+  "StatementTimeoutError",
+  "UnknownError"
+]);
+var sqlMessages = new Set(
+  [
+    "A pipelined query completed out of order",
+    "Connection closed",
+    "Connection closed during startup",
+    "Connection is closed",
+    "Connection timed out",
+    "Failed to connect",
+    "Failed to decode row",
+    "Failed to encode query",
+    "Failed to negotiate TLS",
+    "Failed to parse SSLRequest error response",
+    "Failed to parse server messages",
+    "Failed to parse server response",
+    "Failed to write query",
+    "Failed to write query batch",
+    "Invalid SSLRequest response",
+    "MD5 authentication failed",
+    "No password configured",
+    "Protocol desync",
+    "Query cancellation timed out",
+    "Query failed",
+    "SCRAM authentication failed",
+    "SCRAM exchange did not complete",
+    "SCRAM server verification failed",
+    "Server refused TLS",
+    "Socket error",
+    "Stream cancellation timed out",
+    "The server reported an error",
+    "Unsupported authentication method"
+  ].map((message) => `PgConnection: ${message}`)
+);
+var sqlErrorMessage = (error) => {
+  if (!Predicate_exports.isTagged(error, "SqlError") || !Predicate_exports.hasProperty(error, "reason"))
+    return void 0;
+  const reason = error.reason;
+  const kind = Predicate_exports.hasProperty(reason, "_tag") && Predicate_exports.isString(reason._tag) && sqlReasons.has(reason._tag) ? reason._tag : "an unlisted kind";
+  const message = Predicate_exports.hasProperty(reason, "message") && Predicate_exports.isString(reason.message) && sqlMessages.has(reason.message) ? `: ${reason.message}` : "";
+  return `The database failed (${kind})${message}`;
+};
+
+export {
+  RecordedMessage,
+  recordedMessage
+};

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

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

package/js/{chunk-WVVV4TX2.js → chunk-RIV62DRM.js}

@@ -1,11 +1,11 @@
 import {
   fixedRouter
-} from "./chunk-Z2QY3YTF.js";
+} from "./chunk-BKIQCV72.js";
 import {
   nativeOperation,
   operationDeclaration,
   routerDeclaration
-} from "./chunk-GPFVWWDZ.js";
+} from "./chunk-ZXG7RMCB.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {
@@ -18,10 +18,11 @@ var protocolOperations = (operations, kinds = {}) => {
       ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
       ...operation._meta === void 0 ? {} : { _meta: operation._meta },
       input: operation.input,
+      ...operation.output === void 0 ? {} : { output: operation.output },
       run: operation.run
     };
     const output = Object.getOwnPropertyDescriptor(operation, "outputSchema");
-    const withOutput = (target) => output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
+    const withOutput = (target) => operation.output !== void 0 || output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
     declared[name] = operationDeclaration(withOutput({ ...native, kind }));
   }
   return declared;

package/js/{chunk-RFVIONFX.js → chunk-SXQVVXJE.js}

@@ -1,27 +1,56 @@
+import {
+  getWithReads
+} from "./chunk-UPTAFF6L.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-OIH73VFM.js";
 import {
   CacheError
-} from "./chunk-R3EV5FTO.js";
+} from "./chunk-2RGJMA7N.js";
 import {
   wrap
-} from "./chunk-5T57N25Q.js";
+} from "./chunk-VAI3EVCS.js";
 import {
   JsonObject
-} from "./chunk-27F7W2LG.js";
+} from "./chunk-7HG422GB.js";
 import {
+  Deferred_exports,
   Duration_exports,
   Effect_exports,
+  Exit_exports,
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-ZKDXML77.js";
 
 // src/implementation/catalog-cache.ts
+var catalogScope = (options, credential, invalid) => {
+  const { account, cache } = options;
+  if (account === void 0)
+    return credential === void 0 ? Effect_exports.succeed(cache) : Effect_exports.fail(invalid("missing-account"));
+  if (cache === void 0) return Effect_exports.succeed(void 0);
+  return Effect_exports.try({
+    try: () => cache.forAccount(account),
+    catch: () => invalid("unselected-account")
+  });
+};
 var schema = (decoder) => wrap(decoder, false);
+var seenRevisions = /* @__PURE__ */ new Map();
+var seenLimit = 256;
+var seen = (key, revision) => {
+  seenRevisions.delete(key);
+  seenRevisions.set(key, revision);
+  if (seenRevisions.size > seenLimit) {
+    const oldest = seenRevisions.keys().next();
+    if (oldest.done !== true) seenRevisions.delete(oldest.value);
+  }
+};
 var Manifest = Schema_exports.Struct({
   revision: Schema_exports.String,
   pages: Schema_exports.Int,
   summaries: Schema_exports.Int,
   header: Schema_exports.optionalKey(JsonObject)
 });
-var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
 var catalogCache = (options) => Effect_exports.gen(function* () {
   const cache = options.cache;
   const key = [...options.prefix, "current"];
@@ -35,14 +64,42 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
   const staleFor = options.staleFor ?? "1 day";
   const retention = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)) + Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor)) + 3e5;
   const local = yield* Effect_exports.cached(options.load());
+  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
+    const batches = yield* Effect_exports.forEach(
+      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
+      (offset) => fromPromise(method(cache2, "readMany"), "cache")(
+        Array.from(
+          { length: Math.min(4, count - offset) },
+          (_, index) => part(revision, kind, offset + index)
+        ),
+        schema(Schema_exports.Array(decoder))
+      ),
+      { concurrency: "unbounded" }
+    );
+    const values = [];
+    for (const page of batches.flat()) {
+      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
+      values.push(...page);
+    }
+    return values;
+  });
+  const kept = (cache2) => fromPromise(method(cache2, "read"), "cache")(key, schema(Manifest)).pipe(
+    Effect_exports.map(
+      (manifest) => manifest === void 0 ? void 0 : {
+        header: manifest.header,
+        tools: pages(cache2, manifest.revision, "page", manifest.pages, options.schema)
+      }
+    )
+  );
   const refresh = (context) => Effect_exports.gen(function* () {
-    const { tools, header } = yield* options.load(context);
-    const digest = yield* invoke(
-      () => crypto.subtle.digest(
+    const { tools, header } = yield* options.load(context, kept(context.cache));
+    const digest = yield* Effect_exports.tryPromise({
+      try: () => crypto.subtle.digest(
         "SHA-256",
         new TextEncoder().encode(JSON.stringify({ tools, header: header ?? null }))
-      )
-    );
+      ),
+      catch: (error) => error
+    });
     const revision = Array.from(
       new Uint8Array(digest),
       (byte) => byte.toString(16).padStart(2, "0")
@@ -62,7 +119,7 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
       batch = [];
       batchBytes = 0;
       if (!entries.length) return Effect_exports.void;
-      return invoke(() => context.cache.write(entries, retention)).pipe(
+      return fromPromise(method(context.cache, "write"), "cache")(entries, retention).pipe(
         Effect_exports.withSpan("app.cache.flush", {
           attributes: {
             "cache.flush.index": flushes++,
@@ -120,39 +177,54 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
     schema: schema(Manifest),
     freshFor,
     staleFor,
-    load: (context) => Effect_exports.runPromise(refresh(context), { signal: context.signal })
+    ...options.stale === void 0 ? {} : { stale: options.stale },
+    // A cache may call the loader as a Promise; its own signal cancels that load.
+    load: toPromise(refresh, (context) => context.signal)
   };
   let reading;
-  const current = () => cache === void 0 ? Effect_exports.fail(new CacheError({ reason: "unavailable" })) : invoke(
-    () => reading ??= cache.get(getOptions).finally(() => {
-      reading = void 0;
-    })
+  const read = (tool) => Effect_exports.suspend(
+    () => {
+      if (cache === void 0) return Effect_exports.fail(new CacheError({ reason: "unavailable" }));
+      const shared = reading;
+      if (shared !== void 0)
+        return Deferred_exports.await(shared).pipe(Effect_exports.map((manifest) => ({ manifest })));
+      const deferred = Deferred_exports.makeUnsafe();
+      reading = deferred;
+      const together = Object.hasOwn(cache, getWithReads) ? cache[getWithReads] : void 0;
+      let hinted;
+      const fetched = together === void 0 ? fromPromise(
+        method(cache, "get"),
+        "cache"
+      )(getOptions).pipe(Effect_exports.map((manifest) => ({ manifest }))) : fromPromise(method({ together }, "together"), "cache")(getOptions, (stored) => {
+        hinted = tool === void 0 ? void 0 : seenRevisions.get(stored);
+        return hinted === void 0 || tool === void 0 ? [] : [part(hinted, "tool", tool)];
+      }).pipe(
+        Effect_exports.map(({ value: manifest, key: stored, reads }) => {
+          seen(stored, manifest.revision);
+          return manifest.revision === hinted && reads !== void 0 ? { manifest, part: { value: reads[0] } } : { manifest };
+        })
+      );
+      return fetched.pipe(
+        Effect_exports.onExit(
+          (exit) => Effect_exports.sync(() => {
+            if (reading === deferred) reading = void 0;
+          }).pipe(
+            Effect_exports.andThen(
+              Deferred_exports.done(
+                deferred,
+                Exit_exports.map(exit, ({ manifest }) => manifest)
+              )
+            )
+          )
+        )
+      );
+    }
   );
+  const current = () => read().pipe(Effect_exports.map(({ manifest }) => manifest));
   if (options.revalidate) {
     if (cache === void 0) yield* local;
-    else yield* invoke(() => cache.revalidate(getOptions));
+    else yield* fromPromise(method(cache, "revalidate"), "cache")(getOptions);
   }
-  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
-    const batches = yield* Effect_exports.forEach(
-      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
-      (offset) => invoke(
-        () => cache2.readMany(
-          Array.from(
-            { length: Math.min(4, count - offset) },
-            (_, index) => part(revision, kind, offset + index)
-          ),
-          schema(Schema_exports.Array(decoder))
-        )
-      ),
-      { concurrency: "unbounded" }
-    );
-    const values = [];
-    for (const page of batches.flat()) {
-      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
-      values.push(...page);
-    }
-    return values;
-  });
   const metadata = () => Effect_exports.gen(function* () {
     if (cache === void 0) return (yield* local).tools;
     const manifest = yield* current();
@@ -174,16 +246,23 @@ var catalogCache = (options) => Effect_exports.gen(function* () {
         options.summary.schema
       );
     }),
-    resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map(({ tools }) => tools.find((tool) => tool.name === name))) : current().pipe(
-      Effect_exports.flatMap(
-        (manifest) => invoke(
-          () => cache.read(part(manifest.revision, "tool", name), schema(options.schema))
-        )
-      )
+    resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map(({ tools }) => tools.find((tool) => tool.name === name))) : read(name).pipe(
+      Effect_exports.flatMap(({ manifest, part: found }) => {
+        const separately = fromPromise(method(cache, "read"), "cache")(
+          part(manifest.revision, "tool", name),
+          schema(options.schema)
+        );
+        if (found === void 0) return separately;
+        if (found.value === void 0) return Effect_exports.succeed(void 0);
+        return Schema_exports.decodeUnknownEffect(options.schema)(found.value).pipe(
+          Effect_exports.catch(() => separately)
+        );
+      })
     )
   };
 });
 
 export {
+  catalogScope,
   catalogCache
 };