apps 0.0.1-beta.1 → 0.0.1-beta.10

package/js/{chunk-KOXMLKTM.js → chunk-V5KNQVCT.js}

@@ -1,24 +1,41 @@
+import {
+  makeCache
+} from "./chunk-NKLWZJLE.js";
+import {
+  accountSecrets,
+  boundFailureMessage,
+  describeFailure,
+  failureDetail,
+  readCatalog,
+  routerSkills
+} from "./chunk-FL2QR3XW.js";
 import {
   folderSkillsEffect
-} from "./chunk-ZTFQHGEB.js";
+} from "./chunk-IPI4MFSN.js";
 import {
-  CacheEntry,
-  CacheError,
+  ResponseStatusError,
   authorDatabase,
-  cacheLimits,
   isApp,
   toEffectApp,
   unavailableStorage
-} from "./chunk-RBAC33PQ.js";
+} from "./chunk-YXQHV65J.js";
 import {
+  parseDatabaseSchema
+} from "./chunk-ZQINWV4W.js";
+import {
+  declaredOperations,
   fromPromise,
+  locate,
   nativeOperation,
   toPromise
-} from "./chunk-PZ36XMXW.js";
+} from "./chunk-Z5M2LQOZ.js";
 import {
+  accountProviderError,
+  httpProviderError,
   parseProviderError
-} from "./chunk-ZJWDMTE3.js";
+} from "./chunk-MKWZPDR6.js";
 import {
+  AccountCheckResult,
   DeclaredProvider,
   DeclaredRequirements,
   ElicitationFailed,
@@ -29,6 +46,7 @@ import {
   HostError,
   HostEvaluationFailed,
   HostInputInvalid,
+  HostKindMismatch,
   HostOperationFailed,
   HostOperationNotFound,
   HostOutputInvalid,
@@ -38,6 +56,7 @@ import {
   HostToolBlocked,
   HostToolNotFound,
   HostToolPolicyFailed,
+  HostedRouter,
   HostedTool,
   HostedToolSummary,
   HostedWebhook,
@@ -47,7 +66,7 @@ import {
   ManyAccounts,
   McpError,
   NonRetryableError,
-  OperationToolPrefixes,
+  OpenapiResponseError,
   ResolvedAccounts,
   ToolResultObservation,
   TrustedToolApproval,
@@ -62,32 +81,32 @@ import {
   defaultWebhookTransportLimits,
   maxInputProblems,
   workflowDurationMillis
-} from "./chunk-IHQ4ML7K.js";
+} from "./chunk-WLE7WX2U.js";
+import {
+  CacheError
+} from "./chunk-R3EV5FTO.js";
 import {
   AppSkills,
   SkillFile,
   SkillLoadFailed
-} from "./chunk-YEJOQEII.js";
-import {
-  OpenapiResponseError
-} from "./chunk-SWPD52J7.js";
+} from "./chunk-JU7VHODU.js";
 import {
   captureTelemetry,
   invocationFetch
-} from "./chunk-ZCAMUXSG.js";
+} from "./chunk-ODEIDRGW.js";
 import {
   decoderOf,
   importedJsonSchema,
-  jsonSchemaDecoder
-} from "./chunk-2HHMABB6.js";
+  jsonSchemaDecoder,
+  jsonSchemaDocument
+} from "./chunk-5T57N25Q.js";
 import {
   JsonObject,
   JsonValue
-} from "./chunk-SATWJKN6.js";
+} from "./chunk-27F7W2LG.js";
 import {
   Cause_exports,
   Clock_exports,
-  Duration_exports,
   Effect_exports,
   Encoding_exports,
   Match_exports,
@@ -96,7 +115,7 @@ import {
   SchemaIssue_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-FW5HBOIK.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
@@ -137,19 +156,29 @@ var makeElicit = (handler, signal) => toPromise(
 var ApprovalDecision = Schema_exports.Literals(["approved", "denied", "user-approval"]);
 
 // src/implementation/workflow-context.ts
-var workflowSafe = (work) => work.pipe(
+var workflowSafe = (work, secrets) => work.pipe(
   Effect_exports.catchCause((cause) => {
     if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
     const error = Cause_exports.squash(cause);
     if (Schema_exports.is(WorkflowFailure)(error)) return Effect_exports.fail(error);
+    const { errorName, message } = failureDetail(error, secrets);
     return Effect_exports.fail(
       new WorkflowFailure({
         reason: "execution",
-        retryable: !(error instanceof NonRetryableError)
+        retryable: !(error instanceof NonRetryableError),
+        ...errorName === void 0 ? {} : { errorName },
+        ...message === void 0 ? {} : { message }
       })
     );
   })
 );
+var inStep = (step) => (failure) => failure.step === void 0 ? new WorkflowFailure({
+  reason: failure.reason,
+  retryable: failure.retryable,
+  step: step.slice(0, 200),
+  ...failure.errorName === void 0 ? {} : { errorName: failure.errorName },
+  ...failure.message.length === 0 ? {} : { message: failure.message }
+}) : failure;
 var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_exports.gen(function* () {
   const services = yield* Effect_exports.context();
   const counts = /* @__PURE__ */ new Map();
@@ -204,25 +233,33 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
               Effect_exports.sync(() => new AbortController()),
               (controller2) => Effect_exports.sync(() => controller2.abort())
             );
-            const ctx = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
+            const step2 = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
             const result = yield* workflowSafe(
-              Effect_exports.tryPromise({ try: () => callback(ctx), catch: (error) => error })
+              Effect_exports.tryPromise({
+                try: () => callback(step2.context),
+                catch: (error) => error
+              }),
+              step2.secrets
             );
             return yield* Schema_exports.decodeUnknownEffect(WorkflowValue)(result).pipe(
               Effect_exports.mapError(
-                () => new WorkflowFailure({ reason: "output", retryable: false })
+                () => new WorkflowFailure({
+                  reason: "output",
+                  retryable: false,
+                  message: "The step returned a value that is not JSON, such as undefined, or is larger than 1 MiB. Return null for no result."
+                })
               )
             );
           })
         ).pipe(Effect_exports.provideContext(services))
       )
-    );
+    ).pipe(Effect_exports.mapError(inStep(name)));
   });
   const operationStep = (kind, name, operation, input, options) => Effect_exports.gen(function* () {
     const target = nativeOperation(operation);
-    const catalog = kind === "query" ? definition.queries : definition.mutations;
-    const match = Object.entries(catalog ?? {}).find(
-      ([, value]) => value === target && value.kind === kind
+    const root = definition.tools?.kind === "router" ? definition.tools : void 0;
+    const match = declaredOperations(root).find(
+      (entry) => entry.operation === target && entry.operation.kind === kind
     );
     if (target === void 0 || match === void 0)
       return yield* new WorkflowFailure({ reason: "operation", retryable: false });
@@ -241,9 +278,9 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
       parsed,
       () => attempt(
         parsed,
-        execution.invoke({ kind, name: match[0], input: args, stepId, timeout }).pipe(Effect_exports.provideContext(services))
+        execution.invoke({ kind, name: match.name, input: args, stepId, timeout }).pipe(Effect_exports.provideContext(services))
       )
-    );
+    ).pipe(Effect_exports.mapError(inStep(name)));
   });
   const invoke = (effect) => toPromise(() => effect.pipe(Effect_exports.provideContext(services)), signal)();
   const step = {
@@ -452,144 +489,14 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
   );
 });
 
-// ../app-cache/src/index.ts
-var canonical = (value) => {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value !== null && typeof value === "object")
-    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
-  return JSON.stringify(value);
-};
-var cacheKey = (key) => Effect_exports.gen(function* () {
-  const parsed = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(key).pipe(
-    Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
-  );
-  const bytes = new TextEncoder().encode(canonical(parsed));
-  if (bytes.byteLength > cacheLimits.keyBytes)
-    return yield* new CacheError({ reason: "capacity" });
-  const hash = yield* Effect_exports.tryPromise({
-    try: () => crypto.subtle.digest("SHA-256", bytes),
-    catch: () => new CacheError({ reason: "invalid" })
-  });
-  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-});
-var makeCache = (transport, background, scope = "shared") => {
-  const keyOf = (key) => cacheKey([scope, key]);
-  const readKeys = (keys) => transport({ operation: "read", keys }).pipe(
-    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))),
-    Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
-  );
-  const durations = (freshFor, staleFor = 0) => Effect_exports.try({
-    try: () => {
-      const fresh = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor));
-      const stale = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor));
-      if (![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) || fresh + stale > cacheLimits.retentionMs)
-        throw new CacheError({ reason: "invalid" });
-      return { fresh, stale };
-    },
-    catch: () => new CacheError({ reason: "invalid" })
-  });
-  const get = (options, refresh) => Effect_exports.gen(function* () {
-    const key = yield* keyOf(options.key);
-    const { fresh, stale } = yield* durations(options.freshFor, options.staleFor);
-    const decode = (value) => Schema_exports.decodeUnknownEffect(options.schema)(value);
-    const load = (lease) => Effect_exports.gen(function* () {
-      const value = yield* options.load.pipe(Effect_exports.flatMap(decode));
-      const json = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(value).pipe(
-        Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
-      );
-      const now = yield* Clock_exports.currentTimeMillis;
-      const published = yield* transport({
-        operation: "publish",
-        key,
-        lease,
-        entry: {
-          value: json,
-          version: crypto.randomUUID(),
-          freshUntil: now + fresh,
-          staleUntil: now + fresh + stale
-        }
-      });
-      if (published !== true) return yield* new CacheError({ reason: "unavailable" });
-      return value;
-    }).pipe(
-      Effect_exports.withSpan("app.cache.load"),
-      Effect_exports.timeout(cacheLimits.loadTimeoutMs),
-      Effect_exports.ensuring(
-        transport({ operation: "release", key, lease }).pipe(Effect_exports.catch(() => Effect_exports.void))
-      )
-    );
-    const deadline = (yield* Clock_exports.currentTimeMillis) + cacheLimits.leaseMs;
-    let initialVersion;
-    while (true) {
-      const entry = (yield* readKeys([key]))[0] ?? null;
-      const now = yield* Clock_exports.currentTimeMillis;
-      if (initialVersion === void 0) initialVersion = entry?.version ?? null;
-      const refreshed = refresh && entry !== null && entry.version !== initialVersion;
-      if (entry !== null && (refreshed || !refresh && now < entry.freshUntil)) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
-        return yield* decode(entry.value);
-      }
-      const lease = yield* transport({
-        operation: "claim",
-        key,
-        version: entry?.version ?? null
-      }).pipe(Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.NullOr(Schema_exports.String))));
-      if (!refresh && entry !== null && now < entry.staleUntil) {
-        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");
-        return yield* load(lease);
-      }
-      if (now >= deadline) return yield* new CacheError({ reason: "timeout" });
-      yield* Effect_exports.sleep("100 millis");
-    }
-  }).pipe(Effect_exports.withSpan("app.cache.get"));
-  return {
-    /** Read arbitrary retained JSON entries without initiating a refresh. Missing and null are distinct. */
-    read: (keys) => Effect_exports.forEach(keys, keyOf).pipe(Effect_exports.flatMap(readKeys)),
-    /** Publish bounded immutable parts before publishing the manifest that references them. */
-    write: (entries, retention) => Effect_exports.gen(function* () {
-      const { fresh } = yield* durations(retention);
-      const now = yield* Clock_exports.currentTimeMillis;
-      const values = yield* Effect_exports.forEach(
-        entries,
-        ({ key, value }) => Effect_exports.gen(function* () {
-          return {
-            key: yield* keyOf(key),
-            entry: {
-              value,
-              version: crypto.randomUUID(),
-              freshUntil: now + fresh,
-              staleUntil: now + fresh
-            }
-          };
-        })
-      );
-      yield* transport({ operation: "write", entries: values });
-    }),
-    /** Revoke retained data and any loader's right to publish its in-flight result. */
-    invalidate: (key) => keyOf(key).pipe(
-      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. */
-    get: (options) => get(options, false),
-    /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
-    revalidate: (options) => get(options, true)
-  };
-};
-
 // src/implementation/cache.ts
 var unavailableCache = {
   transport: () => Effect_exports.fail(new CacheError({ reason: "unavailable" })),
   background: () => Effect_exports.die(new Error("Cache background runner is unavailable"))
 };
-var authorCache = (host, accounts, signal) => {
+var authorCache = (host, accounts, signal, deadline) => {
   const scoped = (scope, callerSignal = signal) => {
-    const cache = makeCache(host.transport, host.background, scope);
+    const cache = makeCache(host.transport, host.background, scope, deadline);
     const load = (method, options) => cache[method]({
       key: options.key,
       schema: decoderOf(options.schema),
@@ -641,7 +548,7 @@ var authorCache = (host, accounts, signal) => {
         const bound = Object.values(accounts).flatMap((value) => Array.isArray(value) ? value : [value]).find((value) => value.id === account.id);
         if (bound === void 0) throw new CacheError({ reason: "invalid" });
         return scoped(
-          { account: bound.id, method: bound.method, fields: bound.fields },
+          { account: bound.id, method: bound.method, generation: bound.generation },
           callerSignal
         );
       }
@@ -651,6 +558,10 @@ var authorCache = (host, accounts, signal) => {
 };
 
 // src/implementation/host.ts
+var WireCatalog = Schema_exports.Struct({
+  tools: Schema_exports.Array(Schema_exports.Union([HostedTool, HostedToolSummary])),
+  routers: Schema_exports.Array(HostedRouter)
+});
 function safe2(work, failure) {
   return Effect_exports.suspend(work).pipe(
     Effect_exports.catchCause(
@@ -658,7 +569,7 @@ function safe2(work, failure) {
     )
   );
 }
-var evaluationSafe = (work) => work.pipe(
+var evaluationSafe = (work, secrets) => work.pipe(
   Effect_exports.catchCause((cause) => {
     if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
     const error = Cause_exports.squash(cause);
@@ -666,22 +577,25 @@ var evaluationSafe = (work) => work.pipe(
     const skills = parseSkillLoadFailed(error);
     const mcp = parseMcpError(error);
     return Effect_exports.fail(
-      Option_exports.isSome(provider) ? provider.value : Option_exports.isSome(skills) ? skills.value : Option_exports.isSome(mcp) ? mcp.value : new HostEvaluationFailed()
+      Option_exports.isSome(provider) ? provider.value : Option_exports.isSome(skills) ? skills.value : Option_exports.isSome(mcp) ? mcp.value : new HostEvaluationFailed(failureDetail(error, secrets))
     );
   })
 );
-function jsonSchema(decoder) {
-  const imported = importedJsonSchema(decoder);
-  if (imported !== void 0) return Schema_exports.decodeUnknownEffect(JsonObject)(imported);
-  const document = Schema_exports.toJsonSchemaDocument(decoder);
-  return Schema_exports.decodeUnknownEffect(JsonObject)({
-    ...document.schema,
-    $defs: document.definitions,
-    $schema: "https://json-schema.org/draft/2020-12/schema"
-  });
-}
+var declarationInvalid = (summary, cause, secrets = []) => new HostDeclarationInvalid({
+  source: "app",
+  errorName: "HostDeclarationInvalid",
+  message: boundFailureMessage(
+    cause === void 0 ? summary : `${summary}: ${describeFailure(cause)}`,
+    secrets
+  )
+});
+var declarationSafe = (work, summary) => Effect_exports.suspend(work).pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(declarationInvalid(summary, Cause_exports.squash(cause)))
+  )
+);
 function providerDeclaration(provider) {
-  return safe2(
+  return declarationSafe(
     () => Effect_exports.gen(function* () {
       const auth = /* @__PURE__ */ new Map();
       for (const [name, method] of Object.entries(provider.auth)) {
@@ -690,14 +604,14 @@ function providerDeclaration(provider) {
             auth.set(name, {
               type: "secrets",
               label: method.label,
-              fields: yield* jsonSchema(method.fields)
+              fields: yield* jsonSchemaDocument(method.fields)
             });
             break;
           case "oauth2":
             auth.set(name, {
               type: "oauth2",
               ...method.config,
-              response: yield* jsonSchema(method.response)
+              response: yield* jsonSchemaDocument(method.response)
             });
             break;
         }
@@ -707,31 +621,35 @@ function providerDeclaration(provider) {
         auth: Object.fromEntries(auth)
       });
     }),
-    new HostDeclarationInvalid()
+    `Account provider "${provider.name}" has an invalid declaration`
   );
 }
 function requirements(slots, database) {
   return Effect_exports.gen(function* () {
     const accounts = /* @__PURE__ */ new Map();
     for (const [slot, selection] of Object.entries(slots)) {
+      const provider = selection instanceof ManyAccounts ? selection.provider : selection;
       accounts.set(slot, {
         cardinality: selection instanceof ManyAccounts ? "many" : "one",
-        definition: yield* providerDeclaration(
-          selection instanceof ManyAccounts ? selection.provider : selection
-        )
+        definition: yield* providerDeclaration(provider),
+        ...provider.health === void 0 ? {} : { health: true }
       });
     }
     return yield* Schema_exports.decodeUnknownEffect(DeclaredRequirements)({
       accounts: Object.fromEntries(accounts),
       capabilities: { skills: true, toolIndex: true, skillSources: true, scheduledTools: true },
       ...database === void 0 ? {} : { database }
-    }).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+    }).pipe(
+      Effect_exports.mapError(
+        (cause) => declarationInvalid("The app's account or database declarations are invalid", cause)
+      )
+    );
   });
 }
-function canonical2(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical2).join(",")}]`;
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
   if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical2(item)}`).join(",")}}`;
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -760,7 +678,7 @@ function bindAccounts(slots, declarations, context) {
         for (const account of accounts) {
           if (ids.has(account.id)) return yield* Effect_exports.fail(new HostAccountsInvalid());
           ids.add(account.id);
-          if (canonical2(account.provider) !== canonical2(requirement.definition) || !Object.hasOwn(provider.auth, account.method))
+          if (canonical(account.provider) !== canonical(requirement.definition) || !Object.hasOwn(provider.auth, account.method))
             return yield* Effect_exports.fail(new HostAccountsInvalid());
           const method = provider.auth[account.method];
           if (method === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
@@ -781,17 +699,67 @@ function bindAccounts(slots, declarations, context) {
     new HostAccountsInvalid()
   );
 }
+var fetchLifetime = (signal, background) => Effect_exports.acquireRelease(
+  Effect_exports.sync(() => {
+    const controller = new AbortController();
+    let refreshes = 0;
+    let ended = false;
+    const settle = () => {
+      if (ended && refreshes === 0) controller.abort();
+    };
+    const end = () => {
+      ended = true;
+      settle();
+    };
+    signal.addEventListener("abort", end, { once: true });
+    if (signal.aborted) end();
+    const settled = Effect_exports.sync(() => {
+      refreshes -= 1;
+      settle();
+    });
+    return {
+      signal: controller.signal,
+      close: () => {
+        signal.removeEventListener("abort", end);
+        end();
+      },
+      /** Counted from the hand-off, so a refresh that has not started yet keeps the fetch. */
+      background: (task) => Effect_exports.suspend(() => {
+        refreshes += 1;
+        return background(task.pipe(Effect_exports.ensuring(settled))).pipe(
+          Effect_exports.onError(() => settled)
+        );
+      })
+    };
+  }),
+  (lifetime) => Effect_exports.sync(lifetime.close)
+);
 function dispatch(app, request, context, signal) {
   return Effect_exports.scoped(
     Effect_exports.gen(function* () {
-      if (!isApp(app)) return yield* Effect_exports.fail(new HostDeclarationInvalid());
+      if (!isApp(app))
+        return yield* Effect_exports.fail(
+          declarationInvalid("The app module's default export is not an app created by defineApp")
+        );
       const native = toEffectApp(app);
+      const secrets = accountSecrets(context.accounts);
+      const storageFailure = (error) => Effect_exports.fail(new HostOperationFailed(failureDetail(error, secrets)));
       const declared = yield* requirements(native.accounts, native.database?.schema);
-      if (request.operation === "requirements")
+      if (request.operation === "requirements") {
+        if (native.database !== void 0)
+          yield* parseDatabaseSchema(native.database.schema).pipe(
+            Effect_exports.catchTag(
+              "AppDatabaseError",
+              (cause) => Effect_exports.fail(
+                declarationInvalid("The app's account or database declarations are invalid", cause)
+              )
+            )
+          );
         return yield* safe2(
           () => Schema_exports.decodeUnknownEffect(JsonValue)(declared),
           new HostDeclarationInvalid()
         );
+      }
       const lifetime = yield* Effect_exports.acquireRelease(
         Effect_exports.sync(() => new AbortController()),
         (controller) => Effect_exports.sync(() => controller.abort())
@@ -817,6 +785,14 @@ function dispatch(app, request, context, signal) {
           return yield* new WorkflowFailure({ reason: "engine", retryable: true });
         return result;
       });
+      if (request.operation === "account-check")
+        return yield* checkAccount(
+          native.accounts,
+          declared,
+          request.requirement,
+          context,
+          invocationSignal
+        ).pipe(withinDeadline);
       let running;
       let transactionOpen = false;
       const delivery = (request2, signal2) => Effect_exports.suspend(
@@ -851,11 +827,22 @@ function dispatch(app, request, context, signal) {
       const files = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(
         context.files ?? []
       ).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+      let cacheCommands = 0;
+      const hostCache = context.cache ?? unavailableCache;
+      const fetching = yield* fetchLifetime(signal, hostCache.background);
       const bound = {
         cache: authorCache(
-          context.cache ?? unavailableCache,
+          {
+            ...hostCache,
+            transport: (command) => {
+              cacheCommands += 1;
+              return hostCache.transport(command);
+            },
+            background: fetching.background
+          },
           Redacted_exports.value(context.accounts),
-          invocationSignal
+          invocationSignal,
+          deadline
         ),
         files,
         ...yield* bindAccounts(native.accounts, declared, context).pipe(
@@ -863,35 +850,43 @@ function dispatch(app, request, context, signal) {
         ),
         workflows: workflowReads,
         signal: invocationSignal,
-        fetch: yield* invocationFetch(invocationSignal),
+        fetch: yield* invocationFetch(fetching.signal),
         elicit: makeElicit(delivery, invocationSignal)
       };
-      const definition = yield* evaluationSafe(native.evaluate(bound)).pipe(
+      const definition = yield* evaluationSafe(native.evaluate(bound), secrets).pipe(
         Effect_exports.withSpan("app.evaluate")
       );
       if (request.operation === "skills") {
         const declared2 = definition.skills ?? (yield* folderSkillsEffect({ files }).pipe(
           Effect_exports.mapError(() => new HostDeclarationInvalid())
         ));
-        const source2 = definition.dynamicSkills;
-        const dynamic = source2 === void 0 ? [] : yield* evaluationSafe(Effect_exports.suspend(source2.list)).pipe(
+        const source = definition.dynamicSkills;
+        const before = cacheCommands;
+        const dynamic = source === void 0 ? [] : yield* evaluationSafe(Effect_exports.suspend(source.list), secrets).pipe(
           Effect_exports.withSpan("app.skills.load")
         );
-        const skills = yield* Schema_exports.decodeUnknownEffect(AppSkills)([...declared2, ...dynamic]).pipe(
-          Effect_exports.mapError(() => new HostDeclarationInvalid())
-        );
-        return request.sources === true ? { skills, dynamic: source2 !== void 0 } : skills;
+        const cached = source !== void 0 && cacheCommands > before;
+        const authored = new Set([...declared2, ...dynamic].map((skill) => skill.name));
+        const routed = (yield* routerSkills(definition.tools).pipe(
+          Effect_exports.withSpan("app.skills.routers")
+        )).filter((skill) => !authored.has(skill.name));
+        const skills = yield* Schema_exports.decodeUnknownEffect(AppSkills)([
+          ...declared2,
+          ...dynamic,
+          ...routed
+        ]).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+        return request.sources === true ? { skills, dynamic: source !== void 0, cached } : skills;
       }
       if (request.operation === "workflows") {
         return yield* Effect_exports.forEach(
           Object.entries(definition.workflows ?? {}),
-          ([name2, entry]) => safe2(
+          ([name, entry]) => safe2(
             () => Effect_exports.gen(function* () {
               return yield* Schema_exports.decodeUnknownEffect(HostedWorkflow)({
-                name: name2,
+                name,
                 ...entry.description === void 0 ? {} : { description: entry.description },
-                inputSchema: yield* jsonSchema(entry.input),
-                ...entry.output === void 0 ? {} : { outputSchema: yield* jsonSchema(entry.output) }
+                inputSchema: yield* jsonSchemaDocument(entry.input),
+                ...entry.output === void 0 ? {} : { outputSchema: yield* jsonSchemaDocument(entry.output) }
               });
             }),
             new HostDeclarationInvalid()
@@ -924,108 +919,60 @@ function dispatch(app, request, context, signal) {
               new WorkflowFailure({ reason: "credentials", retryable: false })
             );
             return {
-              ...accounts,
-              cache: authorCache(
-                context.cache ?? unavailableCache,
-                Redacted_exports.value(current.accounts),
-                signal2
-              ),
-              files,
-              fetch: yield* invocationFetch(signal2),
-              signal: signal2,
-              runId: execution.runId,
-              stepId,
-              idempotencyKey: stepId
+              context: {
+                ...accounts,
+                cache: authorCache(
+                  context.cache ?? unavailableCache,
+                  Redacted_exports.value(current.accounts),
+                  signal2
+                ),
+                files,
+                fetch: yield* invocationFetch(signal2),
+                signal: signal2,
+                runId: execution.runId,
+                stepId,
+                idempotencyKey: stepId
+              },
+              // The resolved values, not the app's decoded fields, which may be `Redacted`.
+              secrets: accountSecrets(current.accounts)
             };
           }),
           invocationSignal
         );
-        const output = yield* workflowSafe(entry.run(workflowContext, input2));
+        const output = yield* workflowSafe(entry.run(workflowContext, input2), secrets);
         const outputSchema = entry.output;
         const decoded = outputSchema === void 0 ? output : yield* safe2(
           () => Schema_exports.decodeUnknownEffect(outputSchema)(output),
-          new WorkflowFailure({ reason: "output", retryable: false })
+          new WorkflowFailure({
+            reason: "output",
+            retryable: false,
+            message: "The workflow's result does not match its declared output schema."
+          })
         );
         return yield* safe2(
           () => Schema_exports.decodeUnknownEffect(WorkflowValue)(decoded),
-          new WorkflowFailure({ reason: "output", retryable: false })
+          new WorkflowFailure({
+            reason: "output",
+            retryable: false,
+            message: "The workflow returned a value that is not JSON, such as undefined, or is larger than 1 MiB. Return null for no result."
+          })
         );
       }
       if (request.operation === "inspect") {
         const summary = request.detail === "summary";
-        const wanted = request.tools === void 0 ? void 0 : new Set(request.tools);
-        const metadata = [];
-        for (const [prefix, readOnly, catalog2] of [
-          [OperationToolPrefixes.query, true, definition.queries],
-          [OperationToolPrefixes.mutate, false, definition.mutations]
-        ]) {
-          for (const [name2, operation] of Object.entries(catalog2 ?? {})) {
-            if (wanted !== void 0 && !wanted.has(`${prefix}${name2}`)) continue;
-            const schedules = Object.entries(definition.schedules ?? {}).filter(([, schedule]) => schedule.tool === `${prefix}${name2}`).map(([name3, { tool: _tool, ...schedule }]) => ({ name: name3, ...schedule }));
-            if (request.scheduled === true && schedules.length === 0) continue;
-            metadata.push(
-              yield* safe2(
-                () => Effect_exports.gen(function* () {
-                  const fields = {
-                    name: `${prefix}${name2}`,
-                    schedules,
-                    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name2}`,
-                    ...operation.title === void 0 ? {} : { title: operation.title },
-                    readOnly,
-                    annotations: { ...operation.annotations, readOnlyHint: readOnly }
-                  };
-                  if (summary)
-                    return yield* Schema_exports.decodeUnknownEffect(HostedToolSummary)(fields);
-                  return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
-                    ...fields,
-                    inputSchema: yield* jsonSchema(operation.input),
-                    ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchema(operation.output) },
-                    ...operation._meta === void 0 ? {} : { _meta: operation._meta }
-                  });
-                }),
-                new HostDeclarationInvalid()
-              )
-            );
-          }
-        }
-        const dynamic = request.scheduled === true ? void 0 : definition.dynamicTools;
-        if (dynamic !== void 0 && (wanted === void 0 || metadata.length < wanted.size)) {
-          const declared2 = new Set(metadata.map((tool2) => tool2.name));
-          const discover = () => {
-            if (summary && dynamic.summaries !== void 0) return dynamic.summaries();
-            if (wanted !== void 0 && dynamic.describe !== void 0) {
-              const describe = dynamic.describe;
-              return Effect_exports.forEach(
-                [...wanted].filter((name2) => !declared2.has(name2)),
-                (name2) => describe(name2),
-                { concurrency: "unbounded" }
-              ).pipe(Effect_exports.map((tools) => tools.filter((tool2) => tool2 !== void 0)));
-            }
-            return dynamic.list();
-          };
-          const discovered = yield* evaluationSafe(discover()).pipe(
-            Effect_exports.flatMap(
-              (value) => safe2(
-                () => summary ? Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedToolSummary))(value) : Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedTool))(value),
-                new HostDeclarationInvalid()
-              )
-            )
-          );
-          const names = new Set(declared2);
-          for (const tool2 of discovered) {
-            const readOnly = tool2.name.startsWith(OperationToolPrefixes.query);
-            if (!readOnly && !tool2.name.startsWith(OperationToolPrefixes.mutate) || tool2.name === OperationToolPrefixes.query || tool2.name === OperationToolPrefixes.mutate || names.has(tool2.name))
-              return yield* new HostDeclarationInvalid();
-            names.add(tool2.name);
-            if (wanted !== void 0 && !wanted.has(tool2.name)) continue;
-            metadata.push({
-              ...tool2,
-              readOnly,
-              annotations: { ...tool2.annotations, readOnlyHint: readOnly }
-            });
-          }
-        }
-        return metadata;
+        const catalog = yield* readCatalog(definition.tools, {
+          summary,
+          secrets,
+          ...request.tools === void 0 ? {} : { wanted: new Set(request.tools) },
+          ...request.scheduled === true ? { scheduled: true } : {},
+          schedules: (name) => Object.entries(definition.schedules ?? {}).filter(([, schedule]) => schedule.tool === name).map(([name2, { tool: _tool, ...schedule }]) => ({ name: name2, ...schedule }))
+        }).pipe(Effect_exports.withSpan("app.catalog.read"));
+        return yield* safe2(
+          () => Schema_exports.encodeEffect(WireCatalog)(catalog).pipe(
+            Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonValue))
+          ),
+          new HostDeclarationInvalid()
+        );
       }
       if (request.operation === "webhook-complete" || request.operation === "webhook-validate" || request.operation === "webhooks" || request.operation === "webhook-register" || request.operation === "webhook-handle" || request.operation === "webhook-unregister") {
         const executeWebhook = (db) => dispatchWebhook(
@@ -1049,25 +996,22 @@ function dispatch(app, request, context, signal) {
         const storage2 = context.storage ?? unavailableStorage;
         return yield* storage2.mutate(native.database.schema, executeWebhook).pipe(
           Effect_exports.catchTags({
-            AppDatabaseError: () => Effect_exports.fail(new HostOperationFailed()),
-            AppStorageUnavailable: () => Effect_exports.fail(new HostOperationFailed()),
-            AppStorageError: () => Effect_exports.fail(new HostOperationFailed())
+            AppDatabaseError: storageFailure,
+            DatabaseLimitExceeded: (error) => Effect_exports.fail(error),
+            AppStorageUnavailable: storageFailure,
+            AppStorageError: storageFailure
           })
         );
       }
-      const kind = request.operation === "call" ? request.tool.startsWith(OperationToolPrefixes.query) ? "query" : request.tool.startsWith(OperationToolPrefixes.mutate) ? "mutate" : void 0 : request.operation;
-      if (kind === void 0) return yield* new HostToolNotFound();
-      const name = request.operation === "call" ? request.tool.slice(OperationToolPrefixes[kind].length) : request.name;
-      const toolName = `${OperationToolPrefixes[kind]}${name}`;
-      const catalog = kind === "query" ? definition.queries : definition.mutations;
-      const declaredTool = catalog !== void 0 && Object.hasOwn(catalog, name) ? catalog[name] : void 0;
-      const source = definition.dynamicTools;
-      const resolvedTool = source === void 0 || declaredTool !== void 0 ? void 0 : yield* evaluationSafe(source.resolve(toolName));
-      const tool = declaredTool ?? resolvedTool;
-      if (tool !== void 0 && tool.kind !== (kind === "query" ? "query" : "mutation"))
-        return yield* new HostDeclarationInvalid();
+      const toolName = request.operation === "call" ? request.tool : request.name;
+      const location = locate(definition.tools, toolName);
+      const tool = location === void 0 ? void 0 : location.kind === "operation" ? location.operation : yield* evaluationSafe(location.source.resolve(location.name), secrets);
       if (tool === void 0)
         return yield* request.operation === "call" ? new HostToolNotFound() : new HostOperationNotFound();
+      const requested = request.operation === "call" ? request.kind : request.operation === "query" ? "query" : "mutation";
+      if (requested !== void 0 && tool.kind !== requested)
+        return yield* new HostKindMismatch({ tool: toolName, requested, actual: tool.kind });
+      const kind = tool.kind === "query" ? "query" : "mutate";
       const input = yield* Effect_exports.suspend(
         () => Schema_exports.decodeUnknownEffect(tool.input)(request.input)
       ).pipe(
@@ -1121,7 +1065,7 @@ function dispatch(app, request, context, signal) {
         transactionOpen = db !== void 0;
         const output = yield* Effect_exports.gen(function* () {
           running = yield* captureTelemetry;
-          const fetch = yield* invocationFetch(invocationSignal);
+          const fetch = yield* invocationFetch(fetching.signal);
           return yield* tool.run(
             {
               ...bound,
@@ -1156,7 +1100,7 @@ function dispatch(app, request, context, signal) {
                 status: response.value.status,
                 message: response.value.message,
                 ...response.value.recovery === void 0 ? {} : { recovery: response.value.recovery }
-              }) : Option_exports.isSome(failure) ? failure.value : new HostOperationFailed()
+              }) : Option_exports.isSome(failure) ? failure.value : new HostOperationFailed(failureDetail(error, secrets))
             );
           }),
           Effect_exports.withSpan("app.operation.execute", {
@@ -1187,14 +1131,55 @@ function dispatch(app, request, context, signal) {
         )
       ).pipe(
         Effect_exports.catchTags({
-          AppDatabaseError: () => Effect_exports.fail(new HostOperationFailed()),
-          AppStorageUnavailable: () => Effect_exports.fail(new HostOperationFailed()),
-          AppStorageError: () => Effect_exports.fail(new HostOperationFailed())
+          AppDatabaseError: storageFailure,
+          DatabaseLimitExceeded: (error) => Effect_exports.fail(error),
+          AppStorageUnavailable: storageFailure,
+          AppStorageError: storageFailure
         })
       );
     })
   );
 }
+function checkAccount(slots, declared, requirement, context, signal) {
+  return Effect_exports.gen(function* () {
+    const selection = Object.hasOwn(slots, requirement) ? slots[requirement] : void 0;
+    const slot = Object.hasOwn(declared.accounts, requirement) ? declared.accounts[requirement] : void 0;
+    if (selection === void 0 || slot === void 0) return yield* new HostAccountsInvalid();
+    const provider = selection instanceof ManyAccounts ? selection.provider : selection;
+    const health = provider.health;
+    if (health === void 0) return yield* new HostOperationNotFound();
+    const { accounts } = yield* bindAccounts(
+      { [requirement]: provider },
+      { accounts: { [requirement]: { ...slot, cardinality: "one" } } },
+      context
+    ).pipe(Effect_exports.withSpan("app.accounts.bind"));
+    const account = accounts[requirement];
+    if (account === void 0 || !("id" in account)) return yield* new HostAccountsInvalid();
+    const result = yield* Effect_exports.suspend(
+      () => Effect_exports.gen(function* () {
+        return yield* health.run({ account, fetch: yield* invocationFetch(signal), signal });
+      })
+    ).pipe(
+      Effect_exports.catchCause((cause) => {
+        if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
+        const error = Cause_exports.squash(cause);
+        const status = Schema_exports.decodeUnknownOption(ResponseStatusError)(error);
+        const classified = Option_exports.isSome(status) ? Option_exports.fromNullishOr(httpProviderError(status.value.status)) : parseProviderError(error);
+        return Effect_exports.fail(
+          Option_exports.isSome(classified) ? accountProviderError(classified.value, account.id) : new HostOperationFailed()
+        );
+      }),
+      Effect_exports.withSpan("app.account.check")
+    );
+    return yield* safe2(
+      () => Schema_exports.decodeUnknownEffect(AccountCheckResult)(result ?? {}).pipe(
+        Effect_exports.flatMap(Schema_exports.encodeEffect(AccountCheckResult)),
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonValue))
+      ),
+      new HostOutputInvalid()
+    );
+  });
+}
 var parseSkillLoadFailed = (error) => Schema_exports.decodeUnknownOption(SkillLoadFailed)(error).pipe(
   Option_exports.map(
     ({ reason, message, status }) => new SkillLoadFailed({
@@ -1220,11 +1205,14 @@ var errorStatus = Match_exports.type().pipe(
     HostAccountsInvalid: () => 422,
     HostInputInvalid: () => 422,
     HostOperationNotFound: () => 404,
+    HostKindMismatch: () => 409,
     HostToolNotFound: () => 404,
     HostToolBlocked: () => 403,
     HostToolApprovalRequired: () => 409,
     HostToolPolicyFailed: () => 500,
     HostOperationFailed: () => 500,
+    DatabaseLimitExceeded: () => 422,
+    DatabaseFieldReserved: () => 422,
     HostDeclarationInvalid: () => 500,
     HostEvaluationFailed: () => 500,
     HostOutputInvalid: () => 500,
@@ -1270,12 +1258,17 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
   ),
   Effect_exports.catchCause(
     (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.logError(cause).pipe(
-      Effect_exports.as(
-        Response.json(
-          { ok: false, error: { _tag: "HostDeclarationInvalid" } },
-          { status: 500 }
+      Effect_exports.andThen(
+        Schema_exports.encodeEffect(HostError)(
+          declarationInvalid(
+            "The app failed while it was loaded",
+            Cause_exports.squash(cause),
+            accountSecrets(context.accounts)
+          )
         )
-      )
+      ),
+      Effect_exports.map((error) => Response.json({ ok: false, error }, { status: 500 })),
+      Effect_exports.orDie
     )
   )
 );
@@ -1283,6 +1276,5 @@ var createAppHandler = (app) => (request, context) => Effect_exports.gen(functio
 export {
   prepareElicitation,
   ApprovalDecision,
-  cacheKey,
   createAppHandler
 };