apps 0.0.1-beta.0 → 0.0.1-beta.10

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

@@ -1,21 +1,52 @@
 import {
+  makeCache
+} from "./chunk-NKLWZJLE.js";
+import {
+  accountSecrets,
+  boundFailureMessage,
+  describeFailure,
+  failureDetail,
+  readCatalog,
+  routerSkills
+} from "./chunk-FL2QR3XW.js";
+import {
+  folderSkillsEffect
+} from "./chunk-IPI4MFSN.js";
+import {
+  ResponseStatusError,
   authorDatabase,
   isApp,
   toEffectApp,
-  toPromise,
   unavailableStorage
-} from "./chunk-X3YBZCJW.js";
+} from "./chunk-YXQHV65J.js";
+import {
+  parseDatabaseSchema
+} from "./chunk-ZQINWV4W.js";
+import {
+  declaredOperations,
+  fromPromise,
+  locate,
+  nativeOperation,
+  toPromise
+} from "./chunk-Z5M2LQOZ.js";
 import {
-  nativeOperation
-} from "./chunk-C24KEZXR.js";
+  accountProviderError,
+  httpProviderError,
+  parseProviderError
+} from "./chunk-MKWZPDR6.js";
 import {
+  AccountCheckResult,
   DeclaredProvider,
   DeclaredRequirements,
+  ElicitationFailed,
+  ElicitationResponse,
+  FormElicitation,
   HostAccountsInvalid,
   HostDeclarationInvalid,
   HostError,
   HostEvaluationFailed,
   HostInputInvalid,
+  HostKindMismatch,
   HostOperationFailed,
   HostOperationNotFound,
   HostOutputInvalid,
@@ -25,23 +56,21 @@ import {
   HostToolBlocked,
   HostToolNotFound,
   HostToolPolicyFailed,
+  HostedRouter,
   HostedTool,
+  HostedToolSummary,
   HostedWebhook,
+  HostedWorkflow,
+  InvocationDeadline,
   ManualWebhookSetup,
-  OperationToolPrefixes,
+  ManyAccounts,
+  McpError,
+  NonRetryableError,
+  OpenapiResponseError,
   ResolvedAccounts,
   ToolResultObservation,
   TrustedToolApproval,
   WebhookResponseData,
-  defaultWebhookTransportLimits
-} from "./chunk-22WRQZT7.js";
-import {
-  ElicitationFailed,
-  ElicitationResponse,
-  FormElicitation,
-  HostedWorkflow,
-  ManyAccounts,
-  NonRetryableError,
   WorkflowDuration,
   WorkflowFailure,
   WorkflowName,
@@ -49,30 +78,44 @@ import {
   WorkflowStepOptions,
   WorkflowValue,
   approvalElicitation,
+  defaultWebhookTransportLimits,
+  maxInputProblems,
   workflowDurationMillis
-} from "./chunk-HP7E42X6.js";
+} from "./chunk-WLE7WX2U.js";
+import {
+  CacheError
+} from "./chunk-R3EV5FTO.js";
+import {
+  AppSkills,
+  SkillFile,
+  SkillLoadFailed
+} from "./chunk-JU7VHODU.js";
 import {
   captureTelemetry,
   invocationFetch
-} from "./chunk-OWD2YICM.js";
+} from "./chunk-ODEIDRGW.js";
 import {
+  decoderOf,
   importedJsonSchema,
-  jsonSchemaDecoder
-} from "./chunk-BPEFS4YF.js";
+  jsonSchemaDecoder,
+  jsonSchemaDocument
+} from "./chunk-5T57N25Q.js";
 import {
   JsonObject,
   JsonValue
-} from "./chunk-36DNRFZQ.js";
+} from "./chunk-27F7W2LG.js";
 import {
   Cause_exports,
+  Clock_exports,
   Effect_exports,
   Encoding_exports,
   Match_exports,
   Option_exports,
   Redacted_exports,
+  SchemaIssue_exports,
   Schema_exports,
   Stream_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/implementation/elicitation.ts
 var prepareElicitation = (input) => Effect_exports.gen(function* () {
@@ -113,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();
@@ -156,7 +209,11 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
       Effect_exports.timeout(timeout),
       Effect_exports.catchTag(
         "TimeoutError",
-        () => Effect_exports.fail(new WorkflowFailure({ reason: "execution", retryable: true }))
+        () => (
+          // Both the capability deadline and the native engine deadline describe
+          // the same cancellation, regardless of which timer fires first.
+          Effect_exports.fail(new WorkflowFailure({ reason: "engine", retryable: true }))
+        )
       )
     );
   };
@@ -176,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 });
@@ -213,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 = {
@@ -253,6 +318,23 @@ var makeWorkflowContext = (execution, definition, fresh, signal) => Effect_expor
   return { runId: execution.runId, step };
 });
 
+// src/implementation/input-problems.ts
+var leafHook = (issue) => SchemaIssue_exports.hasInput(issue) ? "Invalid value" : SchemaIssue_exports.defaultLeafHook(issue);
+var checkHook = (issue) => SchemaIssue_exports.hasInput(issue) || SchemaIssue_exports.hasInput(issue.issue) ? SchemaIssue_exports.defaultCheckHook(issue) ?? "Invalid value" : SchemaIssue_exports.defaultCheckHook(issue);
+var format = SchemaIssue_exports.makeFormatterStandardSchemaV1({ leafHook, checkHook });
+var segment = (key) => typeof key === "number" ? `[${key}]` : typeof key === "string" && /^[A-Za-z_$][\w$-]{0,63}$/.test(key) ? `.${key}` : "[key]";
+var inputInvalid = (error) => {
+  if (!Schema_exports.isSchemaError(error)) return new HostInputInvalid();
+  const problems = format(error.issue).issues.slice(0, maxInputProblems).map(({ path, message }) => {
+    const location = (path ?? []).map((key) => segment(typeof key === "object" ? key.key : key));
+    return `${location.length === 0 ? "input" : `input${location.join("")}`}: ${message}`.slice(
+      0,
+      512
+    );
+  });
+  return new HostInputInvalid({ problems });
+};
+
 // src/implementation/webhooks.ts
 var safe = (work, error) => Effect_exports.suspend(work).pipe(
   Effect_exports.catchCause(
@@ -407,7 +489,79 @@ var dispatchWebhook = (definition, command, context, accounts) => Effect_exports
   );
 });
 
+// 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, deadline) => {
+  const scoped = (scope, callerSignal = signal) => {
+    const cache = makeCache(host.transport, host.background, scope, deadline);
+    const load = (method, options) => cache[method]({
+      key: options.key,
+      schema: decoderOf(options.schema),
+      freshFor: options.freshFor,
+      ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
+      load: Effect_exports.acquireUseRelease(
+        Effect_exports.sync(() => new AbortController()),
+        (controller) => invocationFetch(controller.signal).pipe(
+          Effect_exports.flatMap(
+            (fetch) => fromPromise(options.load)({
+              fetch,
+              signal: controller.signal,
+              cache: scoped(scope, controller.signal)
+            })
+          )
+        ),
+        (controller) => Effect_exports.sync(() => controller.abort())
+      )
+    });
+    return {
+      get: toPromise((options) => load("get", options), callerSignal),
+      revalidate: toPromise(
+        (options) => load("revalidate", options),
+        callerSignal
+      ),
+      read: toPromise(
+        (key, schema) => cache.read([key]).pipe(
+          Effect_exports.flatMap((entries) => {
+            const entry = entries[0];
+            return entry === void 0 || entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value);
+          })
+        ),
+        callerSignal
+      ),
+      readMany: toPromise(
+        (keys, schema) => cache.read(keys).pipe(
+          Effect_exports.flatMap(
+            (entries) => Effect_exports.forEach(
+              entries,
+              (entry) => entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value)
+            )
+          )
+        ),
+        callerSignal
+      ),
+      write: toPromise(cache.write, callerSignal),
+      invalidate: toPromise(cache.invalidate, callerSignal),
+      forAccount: (account) => {
+        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, generation: bound.generation },
+          callerSignal
+        );
+      }
+    };
+  };
+  return scoped("shared");
+};
+
 // 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(
@@ -415,18 +569,33 @@ function safe2(work, failure) {
     )
   );
 }
-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 evaluationSafe = (work, secrets) => work.pipe(
+  Effect_exports.catchCause((cause) => {
+    if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
+    const error = Cause_exports.squash(cause);
+    const provider = parseProviderError(error);
+    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(failureDetail(error, secrets))
+    );
+  })
+);
+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)) {
@@ -435,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;
         }
@@ -452,24 +621,29 @@ 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 canonical(value) {
@@ -525,22 +699,100 @@ 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())
       );
       const invocationSignal = AbortSignal.any([signal, lifetime.signal]);
+      const deadline = context.deadline === void 0 ? void 0 : yield* safe2(
+        () => Schema_exports.decodeUnknownEffect(InvocationDeadline)(context.deadline),
+        new HostInputInvalid()
+      );
+      const withinDeadline = (work) => Effect_exports.gen(function* () {
+        if (deadline === void 0) return yield* work;
+        const remaining = deadline - (yield* Clock_exports.currentTimeMillis);
+        if (remaining <= 0)
+          return yield* new WorkflowFailure({ reason: "engine", retryable: true });
+        const result = yield* work.pipe(
+          Effect_exports.timeout(remaining),
+          Effect_exports.catchTag(
+            "TimeoutError",
+            () => Effect_exports.fail(new WorkflowFailure({ reason: "engine", retryable: true }))
+          )
+        );
+        if ((yield* Clock_exports.currentTimeMillis) >= deadline)
+          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(
@@ -572,29 +824,69 @@ function dispatch(app, request, context, signal) {
         get: workflowControls.get,
         list: workflowControls.list
       };
+      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(
+          {
+            ...hostCache,
+            transport: (command) => {
+              cacheCommands += 1;
+              return hostCache.transport(command);
+            },
+            background: fetching.background
+          },
+          Redacted_exports.value(context.accounts),
+          invocationSignal,
+          deadline
+        ),
+        files,
         ...yield* bindAccounts(native.accounts, declared, context).pipe(
           Effect_exports.withSpan("app.accounts.bind")
         ),
         workflows: workflowReads,
         signal: invocationSignal,
-        fetch: yield* invocationFetch(invocationSignal),
+        fetch: yield* invocationFetch(fetching.signal),
         elicit: makeElicit(delivery, invocationSignal)
       };
-      const definition = yield* safe2(
-        () => native.evaluate(bound).pipe(Effect_exports.withSpan("app.evaluate")),
-        new HostEvaluationFailed()
+      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 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 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()
@@ -627,61 +919,68 @@ function dispatch(app, request, context, signal) {
               new WorkflowFailure({ reason: "credentials", retryable: false })
             );
             return {
-              ...accounts,
-              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 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 ?? {})) {
-            metadata.push(
-              yield* safe2(
-                () => Effect_exports.gen(function* () {
-                  return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
-                    name: `${prefix}${name2}`,
-                    schedules: Object.entries(definition.schedules ?? {}).filter(([, schedule]) => schedule.tool === `${prefix}${name2}`).map(([name3, { tool: _tool, ...schedule }]) => ({ name: name3, ...schedule })),
-                    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name2}`,
-                    ...operation.title === void 0 ? {} : { title: operation.title },
-                    inputSchema: yield* jsonSchema(operation.input),
-                    ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchema(operation.output) },
-                    readOnly,
-                    annotations: { ...operation.annotations, readOnlyHint: readOnly },
-                    ...operation._meta === void 0 ? {} : { _meta: operation._meta }
-                  });
-                }),
-                new HostDeclarationInvalid()
-              )
-            );
-          }
-        }
-        return metadata;
+        const summary = request.detail === "summary";
+        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(
           definition,
           request,
           {
+            files,
+            cache: bound.cache,
             accounts: bound.accounts,
             workflows: workflowControls,
             signal: bound.signal,
@@ -697,23 +996,28 @@ 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 tool = catalog !== void 0 && Object.hasOwn(catalog, name) ? catalog[name] : void 0;
+      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 input = yield* safe2(
-        () => Schema_exports.decodeUnknownEffect(tool.input)(request.input),
-        new HostInputInvalid()
+      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(
+        Effect_exports.catchCause(
+          (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(inputInvalid(Cause_exports.squash(cause)))
+        )
       );
       if (context.approval !== void 0) {
         const approved = yield* safe2(
@@ -761,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,
@@ -779,9 +1083,6 @@ function dispatch(app, request, context, signal) {
             input
           );
         }).pipe(
-          Effect_exports.withSpan("app.operation.execute", {
-            attributes: { "executor.tool.name": toolName, "executor.operation": kind }
-          }),
           Effect_exports.ensuring(
             Effect_exports.sync(() => {
               running = void 0;
@@ -789,10 +1090,21 @@ function dispatch(app, request, context, signal) {
           ),
           Effect_exports.catchCause((cause) => {
             if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
-            const failure = Schema_exports.decodeUnknownOption(ElicitationFailed)(Cause_exports.squash(cause));
+            const error = Cause_exports.squash(cause);
+            const provider = parseProviderError(error);
+            const response = Schema_exports.decodeUnknownOption(OpenapiResponseError)(error);
+            const failure = Schema_exports.decodeUnknownOption(ElicitationFailed)(error);
             return Effect_exports.fail(
-              Option_exports.isSome(failure) ? failure.value : new HostOperationFailed()
+              Option_exports.isSome(provider) ? provider.value : Option_exports.isSome(response) ? new OpenapiResponseError({
+                code: response.value.code,
+                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(failureDetail(error, secrets))
             );
+          }),
+          Effect_exports.withSpan("app.operation.execute", {
+            attributes: { "executor.tool.name": toolName, "executor.operation": kind }
           })
         );
         const outputSchema = tool.output;
@@ -810,33 +1122,97 @@ function dispatch(app, request, context, signal) {
         new HostInputInvalid()
       );
       if (replay !== void 0 && kind !== "mutate") return yield* new HostInputInvalid();
-      if (native.database === void 0) return yield* execute();
+      if (native.database === void 0) return yield* withinDeadline(execute());
       const storage = context.storage ?? unavailableStorage;
       return yield* storage[kind === "query" ? "read" : "mutate"](
         native.database.schema,
-        (db) => replay === void 0 ? execute(db) : db.once(replay.key, replay.fingerprint, () => execute(db))
+        (db) => withinDeadline(
+          replay === void 0 ? execute(db) : db.once(replay.key, replay.fingerprint, () => execute(db))
+        )
       ).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({
+      reason,
+      ...message ? { message } : {},
+      ...status === void 0 ? {} : { status }
+    })
+  )
+);
+var parseMcpError = (error) => Schema_exports.decodeUnknownOption(McpError)(error).pipe(
+  Option_exports.map(
+    ({ phase, reason, status }) => new McpError({ phase, reason, ...status === void 0 ? {} : { status } })
+  )
+);
 var errorStatus = Match_exports.type().pipe(
   Match_exports.tagsExhaustive({
+    ProviderError: () => 502,
+    McpError: () => 502,
+    SkillLoadFailed: () => 502,
+    OpenapiResponseError: () => 502,
     WorkflowFailure: () => 422,
     HostRequestInvalid: () => 400,
     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,
@@ -882,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
     )
   )
 );