apps 0.0.1-beta.5 → 0.0.1-beta.55

package/js/chunk-BTSIG4NQ.js

@@ -0,0 +1,1885 @@
+import {
+  makeCache
+} from "./chunk-AQU56EPI.js";
+import {
+  accountSecrets,
+  boundFailureMessage,
+  describeFailure,
+  failureDetail,
+  leavingProviderError,
+  parseMcpError,
+  parseSkillLoadFailed,
+  readCatalog,
+  routerSkills
+} from "./chunk-QEBRH5AP.js";
+import {
+  appInvocationFetch
+} from "./chunk-7UUHJR2Q.js";
+import {
+  folderSkillsEffect
+} from "./chunk-XBG7HHXC.js";
+import {
+  ResponseStatusError,
+  declaredEvents,
+  isApp,
+  makeEmitter,
+  toEffectApp
+} from "./chunk-PXXZ6ABC.js";
+import {
+  declaredOperations,
+  locate,
+  nativeOperation
+} from "./chunk-47F7VXST.js";
+import {
+  accountProviderError,
+  appCode,
+  fromPromise,
+  httpProviderError,
+  method,
+  parseProviderError,
+  toPromise
+} from "./chunk-LTDHQJ2Z.js";
+import {
+  AccountCheckResult,
+  DeclaredProvider,
+  DeclaredRequirements,
+  ElicitationFailed,
+  ElicitationResponse,
+  FormElicitation,
+  HostAccountsInvalid,
+  HostDeclarationInvalid,
+  HostError,
+  HostEvaluationFailed,
+  HostInputInvalid,
+  HostKindMismatch,
+  HostOperationFailed,
+  HostOperationNotFound,
+  HostOutputInvalid,
+  HostRequest,
+  HostRequestInvalid,
+  HostToolApprovalRequired,
+  HostToolBlocked,
+  HostToolNotFound,
+  HostToolPolicyFailed,
+  HostedRouter,
+  HostedTool,
+  HostedToolSummary,
+  HostedWebhook,
+  HostedWorkflow,
+  InvocationDeadline,
+  InvocationTimingSink,
+  ManualWebhookSetup,
+  ManyAccounts,
+  NonRetryableError,
+  OpenapiResponseError,
+  ResolvedAccounts,
+  ToolResultObservation,
+  TrustedToolApproval,
+  WebhookResponseData,
+  WorkflowDuration,
+  WorkflowFailure,
+  WorkflowName,
+  WorkflowReplay,
+  WorkflowStepOptions,
+  WorkflowValue,
+  approvalElicitation,
+  defaultWebhookTransportLimits,
+  maxInputProblems,
+  migrationsDirectory,
+  reservedTablePrefix,
+  workflowDurationMillis
+} from "./chunk-TLWLJ7PD.js";
+import {
+  CacheError
+} from "./chunk-MWKHKOTL.js";
+import {
+  AppSkills,
+  SkillFile
+} from "./chunk-H72MEDMN.js";
+import {
+  allowedValues,
+  decoderOf,
+  echoableKey,
+  importedJsonSchema,
+  importedSchemaKeys,
+  jsonSchemaDecoder,
+  jsonSchemaDocument,
+  maxAlternativeKeys,
+  missingKey,
+  missingKeyText,
+  objectShape,
+  unionShape
+} from "./chunk-KGCTYL2S.js";
+import {
+  captureTelemetry,
+  makeOwnershipAccounting,
+  measuredSpan,
+  owned
+} from "./chunk-JM7LOD2W.js";
+import {
+  JsonObject,
+  JsonValue
+} from "./chunk-H2CJWXA3.js";
+import {
+  Base64_exports,
+  Cause_exports,
+  Clock_exports,
+  Effect_exports,
+  Match_exports,
+  Option_exports,
+  Redacted_exports,
+  SchemaAST_exports,
+  SchemaIssue_exports,
+  Schema_exports,
+  Stream_exports
+} from "./chunk-IFJU5SYQ.js";
+
+// src/implementation/invocation-timing.ts
+var elicitationWaitSpan = "app.elicitation.wait";
+var workflowControlSpan = "app.workflow.control";
+var timedInvocation = (operation) => (effect) => Effect_exports.gen(function* () {
+  const report = yield* InvocationTimingSink;
+  return yield* effect.pipe(
+    measuredSpan(`app.${operation}`, {}, (start) => {
+      const accounting = makeOwnershipAccounting(start, "executor");
+      return {
+        around: accounting.observe,
+        end: (end, span) => {
+          const spent = accounting.read(end);
+          report({
+            elapsedMs: Number(end - start) / 1e6,
+            upstreamMs: spent.upstream,
+            elicitationMs: spent.person,
+            authoredMs: spent.app
+          });
+          span.attribute("executor.upstream.wait_ms", spent.upstream);
+          span.attribute("executor.elicitation.wait_ms", spent.person);
+          span.attribute("executor.authored_ms", spent.app);
+          span.attribute("executor.overhead_ms", spent.executor);
+        }
+      };
+    })
+  );
+});
+
+// src/implementation/elicitation.ts
+var prepareElicitation = (input) => Effect_exports.gen(function* () {
+  const request = yield* Schema_exports.decodeUnknownEffect(FormElicitation)(input, {
+    onExcessProperty: "error"
+  }).pipe(Effect_exports.mapError(() => new ElicitationFailed({ reason: "invalid-request" })));
+  const content = yield* jsonSchemaDecoder(request.requestedSchema).pipe(
+    Effect_exports.mapError(() => new ElicitationFailed({ reason: "invalid-request" }))
+  );
+  const respond = (input2) => Effect_exports.gen(function* () {
+    const response = yield* Schema_exports.decodeUnknownEffect(ElicitationResponse)(input2).pipe(
+      Effect_exports.catchTag(
+        "SchemaError",
+        () => Effect_exports.fail(new ElicitationFailed({ reason: "invalid-response" }))
+      )
+    );
+    if (response.action === "accept") {
+      const fields = response.content === void 0 ? {} : response.content;
+      yield* Schema_exports.decodeUnknownEffect(content)(fields).pipe(
+        Effect_exports.mapError(() => new ElicitationFailed({ reason: "invalid-response" }))
+      );
+      return { ...response, content: fields };
+    }
+    return response;
+  });
+  return { request, respond };
+});
+var makeElicit = (handler, signal, telemetry) => toPromise(
+  (input) => Effect_exports.gen(function* () {
+    if (handler === void 0) return yield* new ElicitationFailed({ reason: "unavailable" });
+    const form = yield* prepareElicitation(input);
+    return yield* handler(form.request, signal).pipe(
+      owned("person", elicitationWaitSpan),
+      Effect_exports.flatMap(form.respond)
+    );
+  }),
+  signal,
+  telemetry
+);
+
+// src/contracts/approval.ts
+var ApprovalDecision = Schema_exports.Literals(["approved", "denied", "user-approval"]);
+
+// src/implementation/workflow-context.ts
+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),
+        ...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();
+  const identify = (kind, name) => Effect_exports.gen(function* () {
+    yield* Schema_exports.decodeUnknownEffect(WorkflowName)(name).pipe(
+      Effect_exports.mapError(() => new WorkflowFailure({ reason: "input", retryable: false }))
+    );
+    const key = JSON.stringify([kind, name]);
+    const count = (counts.get(key) ?? 0) + 1;
+    counts.set(key, count);
+    const digest = yield* Effect_exports.tryPromise({
+      try: () => crypto.subtle.digest(
+        "SHA-256",
+        new TextEncoder().encode(JSON.stringify([execution.runId, kind, name, count]))
+      ),
+      catch: () => new WorkflowFailure({ reason: "execution", retryable: false })
+    });
+    return Array.from(
+      new Uint8Array(digest),
+      (byte) => byte.toString(16).padStart(2, "0")
+    ).join("");
+  });
+  const attempt = (options, work) => {
+    const timeout = workflowDurationMillis(options.timeout ?? "10 minutes");
+    if (timeout === void 0)
+      return Effect_exports.fail(new WorkflowFailure({ reason: "input", retryable: false }));
+    return work.pipe(
+      Effect_exports.timeout(timeout),
+      Effect_exports.catchTag(
+        "TimeoutError",
+        () => (
+          // 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 }))
+        )
+      )
+    );
+  };
+  const runStep = (name, options, callback) => Effect_exports.gen(function* () {
+    const stepId = yield* identify("do", name);
+    const parsed = yield* Schema_exports.decodeUnknownEffect(WorkflowStepOptions)(options).pipe(
+      Effect_exports.mapError(() => new WorkflowFailure({ reason: "input", retryable: false }))
+    );
+    return yield* execution.driver.do(
+      `do:${name.slice(0, 100)}:${stepId}`,
+      parsed,
+      () => attempt(
+        parsed,
+        Effect_exports.scoped(
+          Effect_exports.gen(function* () {
+            const controller = yield* Effect_exports.acquireRelease(
+              Effect_exports.sync(() => new AbortController()),
+              (controller2) => Effect_exports.sync(() => controller2.abort())
+            );
+            const step2 = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
+            const result = yield* workflowSafe(
+              fromPromise(callback, "step")(step2.context),
+              step2.secrets
+            );
+            return yield* Schema_exports.decodeUnknownEffect(WorkflowValue)(result).pipe(
+              Effect_exports.mapError(
+                () => 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 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 });
+    const args = yield* Schema_exports.decodeUnknownEffect(JsonValue)(input).pipe(
+      Effect_exports.mapError(() => new WorkflowFailure({ reason: "input", retryable: false }))
+    );
+    const parsed = yield* Schema_exports.decodeUnknownEffect(WorkflowStepOptions)(options).pipe(
+      Effect_exports.mapError(() => new WorkflowFailure({ reason: "input", retryable: false }))
+    );
+    const stepId = yield* identify(kind, name);
+    const timeout = workflowDurationMillis(parsed.timeout ?? "10 minutes");
+    if (timeout === void 0)
+      return yield* new WorkflowFailure({ reason: "input", retryable: false });
+    return yield* execution.driver.do(
+      `${kind}:${name.slice(0, 100)}:${stepId}`,
+      parsed,
+      () => attempt(
+        parsed,
+        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 = {
+    do: (name, options, run) => {
+      const callback = typeof options === "function" ? options : run;
+      if (callback === void 0)
+        return Promise.reject(new WorkflowFailure({ reason: "input", retryable: false }));
+      return invoke(runStep(name, typeof options === "function" ? {} : options, callback));
+    },
+    runQuery: (name, operation, input, options = {}) => invoke(operationStep("query", name, operation, input, options)),
+    runMutation: (name, operation, input, options = {}) => invoke(operationStep("mutation", name, operation, input, options)),
+    sleep: (name, duration) => invoke(
+      Schema_exports.decodeUnknownEffect(WorkflowDuration)(duration).pipe(
+        Effect_exports.mapError(() => new WorkflowFailure({ reason: "input", retryable: false })),
+        Effect_exports.flatMap(
+          (parsed) => identify("sleep", name).pipe(
+            Effect_exports.flatMap(
+              (id) => execution.driver.sleep(`sleep:${name.slice(0, 100)}:${id}`, parsed)
+            )
+          )
+        )
+      )
+    ),
+    sleepUntil: (name, timestamp) => invoke(
+      identify("until", name).pipe(
+        Effect_exports.flatMap(
+          (id) => execution.driver.sleepUntil(
+            `until:${name.slice(0, 100)}:${id}`,
+            timestamp instanceof Date ? timestamp.getTime() : timestamp
+          )
+        )
+      )
+    )
+  };
+  return { runId: execution.runId, step };
+});
+
+// src/implementation/input-problems.ts
+var nativeObjectShape = (ast, limit) => objectShape(
+  ast.propertySignatures.flatMap(
+    ({ name, type }) => typeof name === "string" ? [{ name, optional: SchemaAST_exports.isOptional(SchemaAST_exports.toEncoded(type)) }] : []
+  ),
+  ast.indexSignatures.length > 0,
+  limit
+);
+var unionMembers = (ast) => SchemaAST_exports.isUnion(ast) ? ast.types.flatMap(unionMembers) : SchemaAST_exports.isUndefined(ast) || SchemaAST_exports.isVoid(ast) ? [] : [ast];
+var fixedValues = (ast) => {
+  if (SchemaAST_exports.isLiteral(ast)) return [ast.literal];
+  if (SchemaAST_exports.isEnum(ast)) return ast.enums.map(([, value]) => value);
+  if (!SchemaAST_exports.isUnion(ast)) return void 0;
+  const members = unionMembers(ast).map(fixedValues);
+  return members.length > 0 && members.every((values) => values !== void 0) ? members.flat() : void 0;
+};
+var describeMember = (ast) => Match_exports.value(ast).pipe(
+  Match_exports.when(
+    SchemaAST_exports.isObjects,
+    (objects) => objects.propertySignatures.length > 0 ? nativeObjectShape(objects, maxAlternativeKeys) : "object"
+  ),
+  Match_exports.when(SchemaAST_exports.isArrays, () => "array"),
+  Match_exports.when(SchemaAST_exports.isTemplateLiteral, () => "a string matching a template"),
+  Match_exports.when(SchemaAST_exports.isString, () => "string"),
+  Match_exports.when(SchemaAST_exports.isNumber, () => "number"),
+  Match_exports.when(SchemaAST_exports.isBoolean, () => "boolean"),
+  Match_exports.when(SchemaAST_exports.isNull, () => "null"),
+  Match_exports.orElse(() => "a value with other constraints")
+);
+var memberSelector = (members) => {
+  const [first] = members;
+  if (members.length < 2 || first === void 0 || !SchemaAST_exports.isObjects(first)) return void 0;
+  return first.propertySignatures.map(({ name }) => name).find(
+    (name) => typeof name === "string" && members.every(
+      (member) => SchemaAST_exports.isObjects(member) && member.propertySignatures.some(
+        (property) => property.name === name && fixedValues(SchemaAST_exports.toEncoded(property.type)) !== void 0
+      )
+    )
+  );
+};
+var unionExpectation = (ast) => {
+  const members = unionMembers(ast);
+  const fixed = members.map(fixedValues);
+  const values = fixed.flatMap((memberValues) => memberValues === void 0 ? [] : memberValues);
+  const others = members.filter((_, index) => fixed[index] === void 0);
+  if (others.length === 0) return allowedValues(values);
+  return unionShape(
+    [
+      ...values.length === 0 ? [] : [allowedValues(values)],
+      ...new Set(others.map(describeMember))
+    ],
+    memberSelector(members)
+  );
+};
+var expectedUnion = (ast) => `Expected ${unionExpectation(ast)}`;
+var expectedValue = (ast) => {
+  const encoded = SchemaAST_exports.toEncoded(ast);
+  const values = fixedValues(encoded);
+  if (values !== void 0) return allowedValues(values);
+  const members = unionMembers(encoded);
+  const [only] = members;
+  if (only === void 0) return void 0;
+  if (members.length > 1 && SchemaAST_exports.isUnion(encoded)) return unionExpectation(encoded);
+  if (SchemaAST_exports.isObjects(only) && only.propertySignatures.length > 0)
+    return nativeObjectShape(only);
+  const described = describeMember(only);
+  return described === "a value with other constraints" ? void 0 : described;
+};
+var leafHook = (issue) => SchemaIssue_exports.hasInput(issue) ? "Invalid value" : Match_exports.value(issue).pipe(
+  Match_exports.tag("InvalidType", ({ ast }) => {
+    const values = fixedValues(ast);
+    return values !== void 0 ? `Expected ${allowedValues(values)}` : SchemaAST_exports.isObjects(ast) && ast.propertySignatures.length > 0 ? `Expected ${nativeObjectShape(ast)}` : SchemaIssue_exports.defaultLeafHook(issue);
+  }),
+  Match_exports.orElse(SchemaIssue_exports.defaultLeafHook)
+);
+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 declaredKey = (parent, key) => parent !== void 0 && SchemaAST_exports.isObjects(parent) ? parent.propertySignatures.find(({ name }) => name === key)?.type : void 0;
+var nativeKeys = (parent) => (key) => parent.indexSignatures.length > 0 || parent.propertySignatures.some(({ name }) => name === key);
+var located = (issue, path, parent) => Match_exports.value(issue).pipe(
+  Match_exports.tag("Pointer", (pointer) => {
+    const declared = pointer.issue._tag === "MissingKey" && pointer.path.length === 1 ? declaredKey(parent, pointer.path[0]) : void 0;
+    return declared === void 0 || parent === void 0 || !SchemaAST_exports.isObjects(parent) ? located(pointer.issue, [...path, ...pointer.path]) : [
+      {
+        path: [...path, ...pointer.path],
+        message: missingKey(expectedValue(declared)),
+        accepts: nativeKeys(parent)
+      }
+    ];
+  }),
+  Match_exports.tag(
+    "Composite",
+    ({ ast, issues }) => issues.flatMap((issue2) => located(issue2, path, ast))
+  ),
+  Match_exports.tag("Encoding", (encoding) => located(encoding.issue, path)),
+  Match_exports.tag(
+    "AnyOf",
+    ({ ast, issues }) => issues.length === 0 ? [{ path, message: expectedUnion(ast) }] : issues.flatMap((issue2) => located(issue2, path))
+  ),
+  Match_exports.orElse((issue2) => {
+    const accepts = issue2._tag === "Filter" ? importedSchemaKeys(issue2.filter) : void 0;
+    return format(issue2).issues.map((problem) => ({
+      path: [
+        ...path,
+        ...(problem.path ?? []).map((key) => typeof key === "object" ? key.key : key)
+      ],
+      message: problem.message,
+      ...accepts === void 0 ? {} : { accepts }
+    }));
+  })
+);
+var segment = (key) => typeof key === "number" ? `[${key}]` : typeof key === "string" && echoableKey(key) ? `.${key}` : "[key]";
+var rendered = (path) => `input${path.map(segment).join("")}`;
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var valueAt = (input, path) => path.reduce(
+  (value, key) => Array.isArray(value) && typeof key === "number" ? value[key] : isRecord(value) && typeof key === "string" && Object.hasOwn(value, key) ? value[key] : void 0,
+  input
+);
+var spelling = (key) => key.toLowerCase().replace(/[-_]/g, "");
+var suppliedElsewhere = (input, path, accepts) => {
+  const key = path.at(-1);
+  if (typeof key !== "string" || !echoableKey(key)) return void 0;
+  const at = path.slice(0, -1);
+  const holder = valueAt(input, at);
+  if (!isRecord(holder)) return void 0;
+  const candidates = Object.keys(holder).filter((name) => echoableKey(name) && !accepts(name));
+  const respelled = candidates.find((name) => name !== key && spelling(name) === spelling(key));
+  const deeper = candidates.find((name) => {
+    const child = holder[name];
+    return isRecord(child) && Object.hasOwn(child, key);
+  });
+  const found = respelled !== void 0 ? [...at, respelled] : deeper !== void 0 ? [...at, deeper, key] : void 0;
+  return found === void 0 ? void 0 : `The input has ${String(found.at(-1))} at ${rendered(found)}; did you mean ${rendered(path)}?`;
+};
+var inputInvalid = (error, input) => {
+  if (!Schema_exports.isSchemaError(error)) return new HostInputInvalid();
+  const problems = located(error.issue, []).slice(0, maxInputProblems).map(({ path, message, accepts }) => {
+    const elsewhere = accepts !== void 0 && message.startsWith(missingKeyText) ? suppliedElsewhere(input, path, accepts) : void 0;
+    return `${rendered(path)}: ${message}${elsewhere === void 0 ? "" : `. ${elsewhere}`}`.slice(
+      0,
+      512
+    );
+  });
+  return new HostInputInvalid({ problems });
+};
+
+// src/implementation/webhooks.ts
+var safe = (work, error) => Effect_exports.suspend(work).pipe(
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(error)
+  )
+);
+var dispatchWebhook = (definition, command, context, accounts) => Effect_exports.gen(function* () {
+  const hooks = definition.webhooks ?? {};
+  if (command.operation === "webhooks") {
+    return yield* Effect_exports.forEach(
+      Object.entries(hooks),
+      ([name, hook2]) => safe(
+        () => Effect_exports.gen(function* () {
+          if (!Object.hasOwn(accounts, hook2.account))
+            return yield* new HostDeclarationInvalid();
+          const describe = (schema) => {
+            const imported = importedJsonSchema(schema);
+            if (imported !== void 0) return Schema_exports.decodeUnknownEffect(JsonObject)(imported);
+            const document = Schema_exports.toJsonSchemaDocument(schema);
+            return Schema_exports.decodeUnknownEffect(JsonObject)({
+              ...document.schema,
+              $defs: document.definitions
+            });
+          };
+          const configSchema = yield* describe(hook2.config);
+          if (hook2.setup === void 0 ? hook2.register === void 0 || hook2.unregister === void 0 : hook2.register !== void 0 || hook2.unregister !== void 0)
+            return yield* new HostDeclarationInvalid();
+          const setup = hook2.setup === void 0 ? void 0 : {
+            ...yield* Schema_exports.decodeUnknownEffect(ManualWebhookSetup)(hook2.setup),
+            stateSchema: yield* describe(hook2.state)
+          };
+          return yield* Schema_exports.decodeUnknownEffect(HostedWebhook)({
+            name,
+            account: hook2.account,
+            configSchema,
+            ...setup === void 0 ? {} : { setup }
+          });
+        }),
+        new HostDeclarationInvalid()
+      )
+    );
+  }
+  const hook = Object.hasOwn(hooks, command.name) ? hooks[command.name] : void 0;
+  if (hook === void 0) return yield* new HostOperationNotFound();
+  const selected = accounts[hook.account];
+  const source = Array.isArray(selected) ? selected.find((account2) => account2.id === command.sourceAccount) : selected;
+  if (source === void 0 || source.id !== command.sourceAccount)
+    return yield* new HostInputInvalid();
+  const bound = context.accounts[hook.account];
+  const account = Array.isArray(bound) ? bound.find(
+    (value) => typeof value === "object" && value !== null && "id" in value && value.id === source.id
+  ) : bound;
+  const config = yield* safe(
+    () => Schema_exports.decodeUnknownEffect(hook.config)(command.config),
+    new HostInputInvalid()
+  );
+  if (command.operation === "webhook-validate")
+    return yield* safe(
+      () => Schema_exports.decodeUnknownEffect(JsonValue)(config),
+      new HostInputInvalid()
+    );
+  const input = {
+    config,
+    subscriptionId: command.subscriptionId,
+    account,
+    callbackUrl: command.callbackUrl,
+    secret: command.secret
+  };
+  const invoke = (callback, value) => safe(() => callback(context, value), new HostOperationFailed());
+  if (command.operation === "webhook-complete") {
+    if (hook.setup === void 0) return yield* new HostInputInvalid();
+    return yield* safe(
+      () => Schema_exports.decodeUnknownEffect(hook.state)(command.state).pipe(
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonValue))
+      ),
+      new HostInputInvalid()
+    );
+  }
+  if (command.operation === "webhook-register") {
+    if (hook.register === void 0 || hook.setup !== void 0)
+      return yield* new HostOperationFailed();
+    const state2 = yield* invoke(hook.register, input);
+    return yield* safe(
+      () => Schema_exports.decodeUnknownEffect(hook.state)(state2).pipe(
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonValue))
+      ),
+      new HostOutputInvalid()
+    );
+  }
+  const state = command.state === null ? null : yield* safe(
+    () => Schema_exports.decodeUnknownEffect(hook.state)(command.state),
+    new HostInputInvalid()
+  );
+  if (command.operation === "webhook-unregister") {
+    if (hook.unregister === void 0 || hook.setup !== void 0)
+      return yield* new HostOperationFailed();
+    yield* invoke(hook.unregister, { ...input, state });
+    return null;
+  }
+  const body = yield* Effect_exports.fromResult(Base64_exports.decode(command.request.body)).pipe(
+    Effect_exports.mapError(() => new HostInputInvalid())
+  );
+  if (body.byteLength > defaultWebhookTransportLimits.maxBodyBytes)
+    return yield* new HostInputInvalid();
+  const request = yield* safe(
+    () => Effect_exports.sync(
+      () => new Request(command.request.url, {
+        method: command.request.method,
+        headers: command.request.headers,
+        ...context.signal === void 0 ? {} : { signal: context.signal },
+        ...command.request.method === "GET" || command.request.method === "HEAD" ? {} : { body: Uint8Array.from(body) }
+      })
+    ),
+    new HostInputInvalid()
+  );
+  const response = yield* invoke(hook.handle, { ...input, state, request });
+  if (!(response instanceof Response)) return yield* new HostOutputInvalid();
+  const chunks = [];
+  let size = 0;
+  const stream = response.body;
+  if (stream !== null)
+    yield* Stream_exports.fromReadableStream({
+      evaluate: () => stream,
+      onError: () => new HostOutputInvalid()
+    }).pipe(
+      Stream_exports.runForEach(
+        (chunk) => Effect_exports.gen(function* () {
+          size += chunk.byteLength;
+          if (size > defaultWebhookTransportLimits.maxBodyBytes)
+            return yield* new HostOutputInvalid();
+          chunks.push(chunk);
+        })
+      ),
+      appCode("webhook")
+    );
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  const headers = {};
+  response.headers.forEach((value, name) => {
+    headers[name] = value;
+  });
+  return yield* safe(
+    () => Schema_exports.decodeUnknownEffect(WebhookResponseData)({
+      status: response.status,
+      headers,
+      body: Base64_exports.encode(new Uint8Array(bytes))
+    }),
+    new HostOutputInvalid()
+  );
+});
+
+// src/implementation/sql.ts
+var receipts = `${reservedTablePrefix}step_receipts`;
+var stepEvents = `${reservedTablePrefix}step_events`;
+var migrationsTable = `${reservedTablePrefix}migrations`;
+var legacyRows = `${reservedTablePrefix}legacy_rows`;
+var materialize = (cursor) => {
+  const rows = cursor.toArray();
+  return {
+    columnNames: cursor.columnNames,
+    rowsRead: cursor.rowsRead,
+    rowsWritten: cursor.rowsWritten,
+    toArray: () => [...rows],
+    one: () => {
+      if (rows.length !== 1)
+        throw new Error(`Expected exactly one row, but the statement returned ${rows.length}.`);
+      return rows[0];
+    },
+    [Symbol.iterator]: () => rows[Symbol.iterator]()
+  };
+};
+var isThenable = (value) => (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+var missingDatabase = () => {
+  throw new Error(
+    `This app has no database. Add its first migration, such as ${migrationsDirectory}/0001_create_notes.sql with a CREATE TABLE statement, and deploy again.`
+  );
+};
+var noDatabase = { exec: missingDatabase, transaction: missingDatabase };
+var settings = [
+  "foreign_keys",
+  "defer_foreign_keys",
+  "ignore_check_constraints",
+  "legacy_alter_table",
+  "recursive_triggers",
+  "reverse_unordered_selects"
+];
+var readSettings = (storage) => new Map(
+  settings.map((name) => [name, Number(storage.sql.exec(`PRAGMA ${name}`).toArray()[0]?.[name])])
+);
+var changedSetting = (storage, baseline) => {
+  const current = readSettings(storage);
+  return settings.find((name) => current.get(name) !== baseline.get(name));
+};
+var restoreSettings = (storage, baseline) => {
+  const current = readSettings(storage);
+  for (const [name, value] of baseline)
+    if (current.get(name) !== value) storage.sql.exec(`PRAGMA ${name} = ${value}`);
+  storage.sql.exec("PRAGMA case_sensitive_like = OFF");
+};
+var ReadRolledBack = class extends Error {
+};
+var authorSql = (storage, options) => {
+  let closed = false;
+  const live = () => {
+    if (closed || options.signal.aborted)
+      throw new Error("This call has ended, so its ctx.sql no longer runs statements.");
+  };
+  let open = false;
+  let transactions = 0;
+  const baseline = readSettings(storage);
+  const checkSettings = () => {
+    const changed = changedSetting(storage, baseline);
+    if (changed !== void 0)
+      throw refuse(
+        new Error(
+          `SQLite connection settings belong to Executor, so app code cannot change PRAGMA ${changed}; the statement was rolled back. Migrations may change settings while they run.`
+        )
+      );
+  };
+  const changes = () => Number(storage.sql.exec("SELECT total_changes() AS n").toArray()[0]?.n);
+  let violation;
+  const refuse = (error) => {
+    if (open) violation ??= error;
+    return error;
+  };
+  const run = (query, bindings, mode) => {
+    try {
+      return runStatement(query, bindings, mode);
+    } finally {
+      restoreSettings(storage, baseline);
+    }
+  };
+  const runStatement = (query, bindings, mode) => {
+    live();
+    if (mode === "write") {
+      const statement = () => {
+        const cursor = materialize(storage.sql.exec(query, ...bindings));
+        checkSettings();
+        return cursor;
+      };
+      if (!open) return storage.transactionSync(statement);
+      try {
+        return statement();
+      } catch (error) {
+        refuse(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+      }
+    }
+    if (open) {
+      return runStatement(query, bindings, "write");
+    }
+    const before = changes();
+    let read;
+    let changed = false;
+    try {
+      storage.transactionSync(() => {
+        read = materialize(storage.sql.exec(query, ...bindings));
+        changed = changes() !== before;
+        checkSettings();
+        throw new ReadRolledBack();
+      });
+    } catch (error) {
+      if (!(error instanceof ReadRolledBack)) throw error;
+    }
+    if (changed || read === void 0)
+      throw new Error(
+        options.step !== void 0 ? "A workflow step mutation writes only inside ctx.sql.transaction(...), so a retried step applies its writes once." : "Queries are read-only. Change data from a mutation."
+      );
+    return read;
+  };
+  const reader = {
+    exec: (query, ...bindings) => run(query, bindings, "read")
+  };
+  const transactionHandle = () => {
+    let active = true;
+    const tx = {
+      exec: (query, ...bindings) => {
+        if (!active)
+          throw new Error("This transaction has ended, so its tx no longer runs statements.");
+        return run(query, bindings, "write");
+      }
+    };
+    return {
+      tx,
+      end: () => {
+        active = false;
+      }
+    };
+  };
+  const transaction = (work) => {
+    live();
+    if (open) throw new Error("ctx.sql.transaction(...) cannot be nested.");
+    const step = options.step;
+    if (step !== void 0 && transactions > 0)
+      throw new Error(
+        "A workflow step mutation opens at most one ctx.sql.transaction(...), which records the step's result."
+      );
+    transactions += 1;
+    violation = void 0;
+    const handle = transactionHandle();
+    const emittedBefore = options.emitted?.length;
+    const discardEmitted = () => {
+      if (options.emitted !== void 0 && emittedBefore !== void 0)
+        options.emitted.length = emittedBefore;
+    };
+    const body = () => {
+      open = true;
+      try {
+        const complete = () => {
+          const value = work(handle.tx);
+          if (isThenable(value))
+            throw new Error(
+              "ctx.sql.transaction(...) callbacks are synchronous and cannot await. Call outside services before or after the transaction."
+            );
+          if (violation !== void 0) throw violation;
+          return value;
+        };
+        if (step === void 0) return complete();
+        storage.sql.exec(
+          `CREATE TABLE IF NOT EXISTS ${receipts} (id TEXT PRIMARY KEY, fingerprint TEXT NOT NULL, result TEXT NOT NULL) WITHOUT ROWID`
+        );
+        const saved = storage.sql.exec(`SELECT fingerprint, result FROM ${receipts} WHERE id = ?`, step.key).toArray()[0];
+        storage.sql.exec(
+          `CREATE TABLE IF NOT EXISTS ${stepEvents} (id TEXT PRIMARY KEY, events TEXT NOT NULL) WITHOUT ROWID`
+        );
+        if (saved !== void 0) {
+          if (saved.fingerprint !== step.fingerprint)
+            throw new Error("This workflow step already ran with different input.");
+          const replayed = storage.sql.exec(`SELECT events FROM ${stepEvents} WHERE id = ?`, step.key).toArray()[0];
+          if (replayed !== void 0 && options.emitted !== void 0)
+            options.emitted.push(...JSON.parse(String(replayed.events)));
+          return JSON.parse(String(saved.result));
+        }
+        const encoded = JSON.stringify(complete() ?? null);
+        const emitted = options.emitted?.slice(emittedBefore ?? 0) ?? [];
+        if (emitted.length > 0)
+          storage.sql.exec(
+            `INSERT INTO ${stepEvents} (id, events) VALUES (?, ?)`,
+            step.key,
+            JSON.stringify(emitted)
+          );
+        storage.sql.exec(
+          `INSERT INTO ${receipts} (id, fingerprint, result) VALUES (?, ?, ?)`,
+          step.key,
+          step.fingerprint,
+          encoded
+        );
+        return JSON.parse(encoded);
+      } finally {
+        open = false;
+        handle.end();
+      }
+    };
+    try {
+      return storage.transactionSync(body);
+    } catch (error) {
+      discardEmitted();
+      throw error;
+    }
+  };
+  const writer = {
+    // A step's writes go through its one transaction, which also records its receipt.
+    exec: (query, ...bindings) => run(query, bindings, options.step ? "read" : "write"),
+    transaction
+  };
+  return {
+    reader,
+    writer,
+    close: () => {
+      closed = true;
+    }
+  };
+};
+var MigrationFileInvalid = class extends Schema_exports.TaggedError()(
+  "MigrationFileInvalid",
+  { path: Schema_exports.String, reason: Schema_exports.String }
+) {
+  get message() {
+    return `${this.path}: ${this.reason}`;
+  }
+};
+var MigrationHistoryChanged = class extends Schema_exports.TaggedError()(
+  "MigrationHistoryChanged",
+  { reason: Schema_exports.String }
+) {
+  get message() {
+    return `${this.reason} Applied migrations cannot change: restore the original file and add a new migration instead. Nothing was applied; the previous deployment is still active.`;
+  }
+};
+var MigrationFailed = class extends Schema_exports.TaggedError()("MigrationFailed", {
+  path: Schema_exports.String,
+  reason: Schema_exports.String
+}) {
+  get message() {
+    return `${this.path} failed: ${this.reason}. No migrations were applied; the previous deployment is still active.`;
+  }
+};
+var migrationName = /^(\d+)_[A-Za-z0-9_-]+\.sql$/;
+var sha256 = (text) => (
+  // oxlint-disable-next-line executor/authored-code-through-adapter -- Web Crypto
+  Effect_exports.promise(() => crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))).pipe(
+    Effect_exports.map(
+      (digest) => Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")
+    )
+  )
+);
+var hasMigrations = (files) => files.some(
+  (file) => file.path.startsWith(`${migrationsDirectory}/`) && file.path.endsWith(".sql")
+);
+var migrationsOf = (files) => Effect_exports.gen(function* () {
+  const found = [];
+  for (const file of files) {
+    if (!file.path.startsWith(`${migrationsDirectory}/`) || !file.path.endsWith(".sql")) continue;
+    const name = file.path.slice(migrationsDirectory.length + 1);
+    const match = migrationName.exec(name);
+    if (name.includes("/") || match === null)
+      return yield* new MigrationFileInvalid({
+        path: file.path,
+        reason: "migrations are files directly in migrations/ named like 0001_create_notes.sql: a number that orders them, an underscore, then a name."
+      });
+    const content = file.content.replaceAll("\r\n", "\n");
+    found.push({
+      path: file.path,
+      order: Number(match[1]),
+      content,
+      hash: yield* sha256(content)
+    });
+  }
+  const ordered = [...found].sort((left, right) => left.order - right.order);
+  for (const [index, migration] of ordered.entries()) {
+    const previous = ordered[index - 1];
+    if (previous !== void 0 && previous.order === migration.order)
+      return yield* new MigrationFileInvalid({
+        path: migration.path,
+        reason: `it has the same number as ${previous.path}; give each migration its own number.`
+      });
+  }
+  return ordered;
+});
+var History = Schema_exports.Array(
+  Schema_exports.Struct({ id: Schema_exports.Number, path: Schema_exports.String, hash: Schema_exports.String })
+);
+var migrate = (storage, files) => Effect_exports.gen(function* () {
+  const migrations = yield* migrationsOf(files);
+  const baseline = readSettings(storage);
+  return yield* Effect_exports.sync(
+    () => storage.transactionSync(() => {
+      storage.sql.exec(
+        `CREATE TABLE IF NOT EXISTS ${migrationsTable} (id INTEGER PRIMARY KEY, path TEXT NOT NULL, hash TEXT NOT NULL, applied_at TEXT NOT NULL)`
+      );
+      const stored = storage.sql.exec("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'app_rows'").toArray().length > 0;
+      storage.sql.exec(`DROP VIEW IF EXISTS ${legacyRows}`);
+      storage.sql.exec(
+        `CREATE VIEW ${legacyRows} (table_name, id, body) AS ${stored ? "SELECT table_name, id, body FROM app_rows" : "SELECT '', '', '' WHERE 0"}`
+      );
+      const history = Schema_exports.decodeUnknownSync(History)(
+        storage.sql.exec(`SELECT id, path, hash FROM ${migrationsTable} ORDER BY id`).toArray()
+      );
+      for (const [index, applied] of history.entries()) {
+        const current = migrations[index];
+        if (current === void 0)
+          throw new MigrationHistoryChanged({
+            reason: `${applied.path} was applied to this app's database but is no longer in migrations/.`
+          });
+        if (current.path !== applied.path)
+          throw new MigrationHistoryChanged({
+            reason: `Migration ${index + 1} was applied as ${applied.path}, but the build has ${current.path} in its place.`
+          });
+        if (current.hash !== applied.hash)
+          throw new MigrationHistoryChanged({
+            reason: `${applied.path} changed after it was applied to this app's database.`
+          });
+      }
+      const pending = migrations.slice(history.length);
+      const appliedAt = (/* @__PURE__ */ new Date()).toISOString();
+      for (const [offset, migration] of pending.entries()) {
+        try {
+          storage.sql.exec(migration.content);
+        } catch (error) {
+          throw new MigrationFailed({
+            path: migration.path,
+            reason: error instanceof Error ? error.message : String(error)
+          });
+        }
+        storage.sql.exec(
+          `INSERT INTO ${migrationsTable} (id, path, hash, applied_at) VALUES (?, ?, ?, ?)`,
+          history.length + offset + 1,
+          migration.path,
+          migration.hash,
+          appliedAt
+        );
+      }
+      return pending.map((migration, offset) => ({
+        id: history.length + offset + 1,
+        name: migration.path
+      }));
+    })
+  ).pipe(
+    // Both are thrown inside the transaction so that it rolls back; they are expected failures.
+    Effect_exports.catchDefect(
+      (defect) => Schema_exports.is(MigrationFailed)(defect) || Schema_exports.is(MigrationHistoryChanged)(defect) ? Effect_exports.fail(defect) : Effect_exports.die(defect)
+    ),
+    Effect_exports.ensuring(Effect_exports.sync(() => restoreSettings(storage, baseline)))
+  );
+});
+
+// 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, telemetry, deadline) => {
+  const scoped = (scope, callerSignal = signal) => {
+    const cache = makeCache(host.transport, host.background, scope, deadline);
+    const load = (read, options) => cache[read]({
+      key: options.key,
+      schema: decoderOf(options.schema),
+      freshFor: options.freshFor,
+      ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
+      ...options.stale === void 0 ? {} : { stale: options.stale },
+      load: Effect_exports.acquireUseRelease(
+        Effect_exports.sync(() => new AbortController()),
+        (controller) => appInvocationFetch(controller.signal).pipe(
+          Effect_exports.flatMap(
+            (fetch) => fromPromise(
+              method(options, "load"),
+              "loader"
+            )({
+              fetch,
+              signal: controller.signal,
+              cache: scoped(scope, controller.signal)
+            })
+          )
+        ),
+        (controller) => Effect_exports.sync(() => controller.abort())
+      )
+    });
+    const service = (method2, operation) => toPromise(
+      (...args) => operation(...args).pipe(
+        owned("executor", "app.cache.call", { attributes: { "cache.method": method2 } })
+      ),
+      callerSignal,
+      telemetry
+    );
+    return {
+      get: service("get", (options) => load("get", options)),
+      revalidate: service(
+        "revalidate",
+        (options) => load("revalidate", options)
+      ),
+      read: service(
+        "read",
+        (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);
+          })
+        )
+      ),
+      readMany: service(
+        "readMany",
+        (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)
+            )
+          )
+        )
+      ),
+      write: service("write", cache.write),
+      invalidate: service("invalidate", cache.invalidate),
+      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(
+      (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(failure)
+    )
+  );
+}
+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, secrets);
+    return Effect_exports.fail(
+      Option_exports.isSome(provider) ? leavingProviderError(provider.value, secrets, "discover") : 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 declaredExposure(exposure) {
+  const named = (kind) => Object.entries(exposure ?? {}).filter(([, value]) => value === kind).map(([field]) => field).sort();
+  const plain = named("plain");
+  const raw = named("raw");
+  return { ...plain.length === 0 ? {} : { plain }, ...raw.length === 0 ? {} : { raw } };
+}
+function providerDeclaration(provider) {
+  return declarationSafe(
+    () => Effect_exports.gen(function* () {
+      const auth = /* @__PURE__ */ new Map();
+      for (const [name, method2] of Object.entries(provider.auth)) {
+        switch (method2._tag) {
+          case "secrets":
+            auth.set(name, {
+              type: "secrets",
+              label: method2.label,
+              fields: yield* jsonSchemaDocument(method2.fields),
+              ...declaredExposure(method2.exposure)
+            });
+            break;
+          case "oauth2":
+            auth.set(name, {
+              type: "oauth2",
+              ...method2.config,
+              response: yield* jsonSchemaDocument(method2.response),
+              ...declaredExposure(method2.exposure)
+            });
+            break;
+        }
+      }
+      return yield* Schema_exports.decodeUnknownEffect(DeclaredProvider)({
+        name: provider.name,
+        auth: Object.fromEntries(auth),
+        // Order and repetition carry no meaning, so neither changes the provider's identity.
+        ...provider.hosts === void 0 ? {} : { hosts: [...new Set(provider.hosts)].sort() }
+      });
+    }),
+    `Account provider "${provider.name}" has an invalid declaration`
+  );
+}
+function requirements(slots, sql, events) {
+  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(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 },
+      ...sql ? { sql: true } : {},
+      ...events === void 0 || Object.keys(events).length === 0 ? {} : {
+        events: yield* declarationSafe(
+          () => declaredEvents(events),
+          "The app's event declarations are invalid"
+        )
+      }
+    }).pipe(
+      Effect_exports.mapError(
+        (cause) => declarationInvalid("The app's account declarations are invalid", cause)
+      )
+    );
+  });
+}
+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)}:${canonical(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function withoutHosts({ hosts: _hosts, ...provider }) {
+  return provider;
+}
+function bindAccounts(slots, declarations, context) {
+  return safe2(
+    () => Effect_exports.gen(function* () {
+      const selected = yield* Schema_exports.decodeUnknownEffect(ResolvedAccounts)(
+        Redacted_exports.value(context.accounts)
+      );
+      if (Object.keys(selected).some((slot) => !Object.hasOwn(slots, slot))) {
+        return yield* Effect_exports.fail(new HostAccountsInvalid());
+      }
+      const bound = /* @__PURE__ */ new Map();
+      for (const [slot, selection] of Object.entries(slots)) {
+        const requirement = declarations.accounts[slot];
+        const supplied = Object.hasOwn(selected, slot) ? selected[slot] : void 0;
+        if (requirement === void 0 || supplied === void 0)
+          return yield* Effect_exports.fail(new HostAccountsInvalid());
+        const provider = selection instanceof ManyAccounts ? selection.provider : selection;
+        const many = selection instanceof ManyAccounts;
+        if (many !== Array.isArray(supplied))
+          return yield* Effect_exports.fail(new HostAccountsInvalid());
+        const accounts = Array.isArray(supplied) ? supplied : [supplied];
+        const ids = /* @__PURE__ */ new Set();
+        const values = [];
+        for (const account of accounts) {
+          if (ids.has(account.id)) return yield* Effect_exports.fail(new HostAccountsInvalid());
+          ids.add(account.id);
+          if (canonical(withoutHosts(account.provider)) !== canonical(withoutHosts(requirement.definition)) || !Object.hasOwn(provider.auth, account.method))
+            return yield* Effect_exports.fail(new HostAccountsInvalid());
+          const method2 = provider.auth[account.method];
+          if (method2 === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
+          const fields = yield* Schema_exports.decodeUnknownEffect(
+            method2._tag === "secrets" ? method2.fields : method2.response
+          )(account.fields);
+          values.push({ id: account.id, method: account.method, fields });
+        }
+        if (many) bound.set(slot, values);
+        else {
+          const account = values[0];
+          if (account === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
+          bound.set(slot, account);
+        }
+      }
+      return { accounts: Object.fromEntries(bound) };
+    }),
+    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, emitted) {
+  return Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      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 ownsSql = hasMigrations(context.files ?? []);
+      const declared = yield* requirements(native.accounts, ownsSql, native.events);
+      if (request.operation === "requirements")
+        return yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(JsonValue)(declared),
+          new HostDeclarationInvalid()
+        );
+      if (request.operation === "migrate") {
+        if (!ownsSql) return yield* new HostOperationNotFound();
+        const storage2 = context.storage;
+        if (storage2 === void 0)
+          return yield* new HostOperationFailed(
+            failureDetail(new Error("This host gave the app no SQL storage."), secrets)
+          );
+        const sources = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Array(SkillFile))(
+          context.files ?? []
+        ).pipe(Effect_exports.mapError(() => new HostDeclarationInvalid()));
+        const applied = yield* migrate(storage2, sources).pipe(
+          Effect_exports.mapError((error) => new HostOperationFailed(failureDetail(error, secrets))),
+          Effect_exports.withSpan("app.sql.migrate")
+        );
+        return yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(JsonValue)(applied),
+          new HostOutputInvalid()
+        );
+      }
+      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 storage = context.storage;
+      const sqlSession = (step) => !ownsSql ? Effect_exports.succeed({ reader: noDatabase, writer: noDatabase }) : storage === void 0 ? Effect_exports.fail(
+        new HostOperationFailed(
+          failureDetail(new Error("This host gave the app no SQL storage."), secrets)
+        )
+      ) : Effect_exports.acquireRelease(
+        Effect_exports.sync(
+          () => authorSql(storage, {
+            signal: invocationSignal,
+            emitted,
+            ...step === void 0 ? {} : { step }
+          })
+        ),
+        (session2) => Effect_exports.sync(session2.close)
+      );
+      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,
+          deadline
+        ).pipe(withinDeadline);
+      let running;
+      const delivery = (request2, signal2) => Effect_exports.suspend(
+        () => running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
+          // Delivering the question and waiting for its answer is the person's time.
+          owned("person", "app.tool.elicitation"),
+          Effect_exports.provideContext(running.context)
+        ) : Effect_exports.fail(new ElicitationFailed({ reason: "unavailable" }))
+      );
+      const unavailableWorkflow = () => Effect_exports.fail(new WorkflowFailure({ reason: "unavailable", retryable: false }));
+      const telemetry = yield* captureTelemetry;
+      const control = (operation, work) => work.pipe(
+        owned("executor", workflowControlSpan, {
+          attributes: { "executor.workflow.operation": operation }
+        })
+      );
+      const workflowControls = {
+        start: toPromise(
+          (input2) => control(
+            "start",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.start(input2)
+          ),
+          invocationSignal,
+          telemetry.context
+        ),
+        get: toPromise(
+          (input2) => control(
+            "get",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.get(input2)
+          ),
+          invocationSignal,
+          telemetry.context
+        ),
+        list: toPromise(
+          (input2) => control(
+            "list",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.list(input2)
+          ),
+          invocationSignal,
+          telemetry.context
+        ),
+        terminate: toPromise(
+          (input2) => control(
+            "terminate",
+            context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.terminate(input2)
+          ),
+          invocationSignal,
+          telemetry.context
+        )
+      };
+      const workflowReads = {
+        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,
+          telemetry.context,
+          deadline
+        ),
+        files,
+        ...yield* bindAccounts(native.accounts, declared, context).pipe(
+          Effect_exports.withSpan("app.accounts.bind")
+        ),
+        workflows: workflowReads,
+        signal: invocationSignal,
+        fetch: yield* appInvocationFetch(fetching.signal),
+        elicit: makeElicit(delivery, invocationSignal, telemetry.context)
+      };
+      const accountIds = Object.values(bound.accounts).flatMap(
+        (selected) => (Array.isArray(selected) ? selected : [selected]).map(
+          (account) => account.id
+        )
+      );
+      const emitter = (sourceAccount) => makeEmitter({
+        events: native.events ?? {},
+        accounts: accountIds,
+        ...sourceAccount === void 0 ? {} : { sourceAccount },
+        emitted
+      });
+      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 ?? {}),
+          ([name, entry]) => safe2(
+            () => Effect_exports.gen(function* () {
+              return yield* Schema_exports.decodeUnknownEffect(HostedWorkflow)({
+                name,
+                ...entry.description === void 0 ? {} : { description: entry.description },
+                inputSchema: yield* jsonSchemaDocument(entry.input),
+                ...entry.output === void 0 ? {} : { outputSchema: yield* jsonSchemaDocument(entry.output) }
+              });
+            }),
+            new HostDeclarationInvalid()
+          )
+        );
+      }
+      if (request.operation === "workflow-validate" || request.operation === "workflow-run") {
+        const entry = definition.workflows !== void 0 && Object.hasOwn(definition.workflows, request.name) ? definition.workflows[request.name] : void 0;
+        if (entry === void 0)
+          return yield* new WorkflowFailure({ reason: "not_found", retryable: false });
+        const input2 = yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(entry.input)(request.input),
+          new WorkflowFailure({ reason: "input", retryable: false })
+        );
+        if (request.operation === "workflow-validate")
+          return yield* safe2(
+            () => Schema_exports.decodeUnknownEffect(WorkflowValue)(input2),
+            new WorkflowFailure({ reason: "input", retryable: false })
+          );
+        const execution = context.workflow;
+        if (execution === void 0)
+          return yield* new WorkflowFailure({ reason: "unavailable", retryable: false });
+        const workflowContext = yield* makeWorkflowContext(
+          execution,
+          definition,
+          (stepId, signal2) => Effect_exports.gen(function* () {
+            const current = yield* execution.resolve();
+            const accounts = yield* safe2(
+              () => bindAccounts(native.accounts, declared, current),
+              new WorkflowFailure({ reason: "credentials", retryable: false })
+            );
+            return {
+              context: {
+                ...accounts,
+                cache: authorCache(
+                  context.cache ?? unavailableCache,
+                  Redacted_exports.value(current.accounts),
+                  signal2,
+                  (yield* captureTelemetry).context
+                ),
+                files,
+                fetch: yield* appInvocationFetch(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), secrets);
+        const outputSchema = entry.output;
+        const decoded = outputSchema === void 0 ? output : yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(outputSchema)(output),
+          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,
+            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 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 session2 = yield* sqlSession();
+        return yield* dispatchWebhook(
+          definition,
+          request,
+          {
+            files,
+            cache: bound.cache,
+            accounts: bound.accounts,
+            workflows: workflowControls,
+            signal: bound.signal,
+            fetch: bound.fetch,
+            sql: session2.writer,
+            events: emitter("sourceAccount" in request ? request.sourceAccount : void 0)
+          },
+          Redacted_exports.value(context.accounts)
+        );
+      }
+      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).pipe(
+        Effect_exports.withSpan("app.tool.resolve")
+      );
+      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(
+        Effect_exports.catchCause(
+          (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : Effect_exports.fail(inputInvalid(Cause_exports.squash(cause), request.input))
+        )
+      );
+      if (context.approval !== void 0) {
+        const approved = yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(TrustedToolApproval)(context.approval),
+          new HostInputInvalid()
+        );
+        const decoded = yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(JsonValue)(input),
+          new HostInputInvalid()
+        );
+        if (approved.tool !== toolName || !Schema_exports.toEquivalence(JsonValue)(approved.input, decoded)) {
+          return yield* new HostInputInvalid();
+        }
+      } else if (tool.approval !== void 0) {
+        const approval = tool.approval;
+        const decision = yield* safe2(
+          () => approval({ toolName, toolInput: input, signal: invocationSignal }).pipe(
+            Effect_exports.withSpan("app.tool.approval", {
+              attributes: { "executor.tool.name": toolName }
+            }),
+            Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(ApprovalDecision))
+          ),
+          new HostToolPolicyFailed()
+        );
+        yield* Match_exports.value(decision).pipe(
+          Match_exports.when("approved", () => Effect_exports.void),
+          Match_exports.when("denied", () => Effect_exports.fail(new HostToolBlocked())),
+          Match_exports.when(
+            "user-approval",
+            () => safe2(() => Schema_exports.decodeUnknownEffect(JsonValue)(input), new HostInputInvalid()).pipe(
+              Effect_exports.flatMap(
+                (input2) => Effect_exports.fail(
+                  new HostToolApprovalRequired({
+                    input: input2,
+                    elicitation: approvalElicitation(toolName, input2)
+                  })
+                )
+              )
+            )
+          ),
+          Match_exports.exhaustive
+        );
+      }
+      const replay = context.replay === void 0 ? void 0 : yield* safe2(
+        () => Schema_exports.decodeUnknownEffect(WorkflowReplay)(context.replay),
+        new HostInputInvalid()
+      );
+      if (replay !== void 0 && kind !== "mutate") return yield* new HostInputInvalid();
+      const session = yield* sqlSession(replay);
+      const execute = () => Effect_exports.gen(function* () {
+        const output = yield* Effect_exports.gen(function* () {
+          running = yield* captureTelemetry;
+          const fetch = yield* appInvocationFetch(fetching.signal);
+          return yield* tool.run(
+            {
+              ...bound,
+              fetch,
+              workflows: kind === "mutate" ? workflowControls : workflowReads,
+              sql: kind === "mutate" ? session.writer : session.reader,
+              ...kind === "mutate" ? { events: emitter() } : {}
+            },
+            input
+          );
+        }).pipe(
+          Effect_exports.ensuring(
+            Effect_exports.sync(() => {
+              running = void 0;
+            })
+          ),
+          Effect_exports.catchCause((cause) => {
+            if (Cause_exports.hasInterrupts(cause)) return Effect_exports.interrupt;
+            const error = Cause_exports.squash(cause);
+            const provider = parseProviderError(error);
+            const response = Schema_exports.decodeUnknownOption(OpenapiResponseError)(error);
+            const mcp = parseMcpError(error, secrets);
+            const failure = Schema_exports.decodeUnknownOption(ElicitationFailed)(error);
+            return Effect_exports.fail(
+              Option_exports.isSome(provider) ? leavingProviderError(provider.value, secrets, "call") : 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(mcp) ? mcp.value : 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;
+        const decoded = outputSchema === void 0 ? output : yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(outputSchema)(output),
+          new HostOutputInvalid()
+        );
+        return yield* safe2(
+          () => Schema_exports.decodeUnknownEffect(JsonValue)(decoded),
+          new HostOutputInvalid()
+        );
+      });
+      return yield* withinDeadline(execute());
+    })
+  );
+}
+function checkAccount(slots, declared, requirement, context, signal, deadline) {
+  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* appInvocationFetch(signal),
+          signal,
+          ...deadline === void 0 ? {} : { deadline }
+        });
+      })
+    ).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);
+        const secrets = accountSecrets(context.accounts);
+        return Effect_exports.fail(
+          Option_exports.isSome(classified) ? leavingProviderError(accountProviderError(classified.value, account.id), secrets) : new HostOperationFailed(failureDetail(error, secrets))
+        );
+      }),
+      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 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,
+    ElicitationFailed: () => 422
+  })
+);
+var createAppHandler = (app) => (request, context) => Effect_exports.gen(function* () {
+  if (request.method !== "POST") return yield* Effect_exports.fail(new HostRequestInvalid());
+  const input = yield* Effect_exports.tryPromise({
+    try: () => request.json(),
+    catch: () => new HostRequestInvalid()
+  });
+  const command = yield* Schema_exports.decodeUnknownEffect(HostRequest)(input, {
+    onExcessProperty: "error"
+  }).pipe(Effect_exports.mapError(() => new HostRequestInvalid()));
+  yield* Effect_exports.annotateCurrentSpan({
+    "executor.operation": command.operation,
+    ...command.operation === "call" ? { "executor.tool.name": command.tool } : {}
+  });
+  let toolError = false;
+  const emitted = [];
+  const value = yield* dispatch(app, command, context, request.signal, emitted).pipe(
+    Effect_exports.provideService(ToolResultObservation, {
+      failed: () => {
+        toolError = true;
+      }
+    }),
+    // Name what failed on the span; the bounded message stays in the reply only. The host
+    // records an app's own error names and codes as `unrecognized` (telemetry `app-records`).
+    Effect_exports.tapError(
+      (error) => (error._tag === "HostEvaluationFailed" || error._tag === "HostOperationFailed" || error._tag === "HostDeclarationInvalid") && error.errorName !== void 0 ? Effect_exports.annotateCurrentSpan({
+        "error.type": error.errorName,
+        ...error.source === void 0 ? {} : { "executor.failure.source": error.source },
+        ...error.code === void 0 ? {} : { "executor.failure.code": error.code }
+      }) : Effect_exports.void
+    ),
+    // Tool operations time themselves, dividing their time by who owned the work in progress.
+    // Other operations do not.
+    command.operation === "call" || command.operation === "query" || command.operation === "mutate" ? timedInvocation(command.operation) : Effect_exports.withSpan(`app.${command.operation}`)
+  );
+  if (toolError)
+    yield* Effect_exports.annotateCurrentSpan({
+      "executor.outcome": "failed",
+      "error.type": "McpToolError"
+    });
+  return Response.json({
+    ok: true,
+    value,
+    ...toolError ? { toolError: true } : {},
+    ...emitted.length === 0 ? {} : { events: emitted }
+  });
+}).pipe(
+  Effect_exports.catch(
+    (error) => Schema_exports.encodeEffect(HostError)(error).pipe(
+      Effect_exports.map(
+        (encoded) => Response.json({ ok: false, error: encoded }, { status: errorStatus(error) })
+      ),
+      Effect_exports.orDie
+    )
+  ),
+  Effect_exports.catchCause(
+    (cause) => Cause_exports.hasInterrupts(cause) ? Effect_exports.interrupt : (
+      // The cause can carry any text the app threw; its caller receives that, not the log.
+      Effect_exports.logError("The app's request failed unexpectedly").pipe(
+        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
+      )
+    )
+  )
+);
+
+export {
+  prepareElicitation,
+  ApprovalDecision,
+  createAppHandler
+};