apps 0.0.1-beta.1 → 0.0.1-beta.100

package/js/chunk-KOXMLKTM.js

@@ -1,1288 +0,0 @@
-import {
-  folderSkillsEffect
-} from "./chunk-ZTFQHGEB.js";
-import {
-  CacheEntry,
-  CacheError,
-  authorDatabase,
-  cacheLimits,
-  isApp,
-  toEffectApp,
-  unavailableStorage
-} from "./chunk-RBAC33PQ.js";
-import {
-  fromPromise,
-  nativeOperation,
-  toPromise
-} from "./chunk-PZ36XMXW.js";
-import {
-  parseProviderError
-} from "./chunk-ZJWDMTE3.js";
-import {
-  DeclaredProvider,
-  DeclaredRequirements,
-  ElicitationFailed,
-  ElicitationResponse,
-  FormElicitation,
-  HostAccountsInvalid,
-  HostDeclarationInvalid,
-  HostError,
-  HostEvaluationFailed,
-  HostInputInvalid,
-  HostOperationFailed,
-  HostOperationNotFound,
-  HostOutputInvalid,
-  HostRequest,
-  HostRequestInvalid,
-  HostToolApprovalRequired,
-  HostToolBlocked,
-  HostToolNotFound,
-  HostToolPolicyFailed,
-  HostedTool,
-  HostedToolSummary,
-  HostedWebhook,
-  HostedWorkflow,
-  InvocationDeadline,
-  ManualWebhookSetup,
-  ManyAccounts,
-  McpError,
-  NonRetryableError,
-  OperationToolPrefixes,
-  ResolvedAccounts,
-  ToolResultObservation,
-  TrustedToolApproval,
-  WebhookResponseData,
-  WorkflowDuration,
-  WorkflowFailure,
-  WorkflowName,
-  WorkflowReplay,
-  WorkflowStepOptions,
-  WorkflowValue,
-  approvalElicitation,
-  defaultWebhookTransportLimits,
-  maxInputProblems,
-  workflowDurationMillis
-} from "./chunk-IHQ4ML7K.js";
-import {
-  AppSkills,
-  SkillFile,
-  SkillLoadFailed
-} from "./chunk-YEJOQEII.js";
-import {
-  OpenapiResponseError
-} from "./chunk-SWPD52J7.js";
-import {
-  captureTelemetry,
-  invocationFetch
-} from "./chunk-ZCAMUXSG.js";
-import {
-  decoderOf,
-  importedJsonSchema,
-  jsonSchemaDecoder
-} from "./chunk-2HHMABB6.js";
-import {
-  JsonObject,
-  JsonValue
-} from "./chunk-SATWJKN6.js";
-import {
-  Cause_exports,
-  Clock_exports,
-  Duration_exports,
-  Effect_exports,
-  Encoding_exports,
-  Match_exports,
-  Option_exports,
-  Redacted_exports,
-  SchemaIssue_exports,
-  Schema_exports,
-  Stream_exports
-} from "./chunk-FW5HBOIK.js";
-
-// 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) => 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(Effect_exports.flatMap(form.respond));
-  }),
-  signal
-);
-
-// src/contracts/approval.ts
-var ApprovalDecision = Schema_exports.Literals(["approved", "denied", "user-approval"]);
-
-// src/implementation/workflow-context.ts
-var workflowSafe = (work) => 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);
-    return Effect_exports.fail(
-      new WorkflowFailure({
-        reason: "execution",
-        retryable: !(error instanceof NonRetryableError)
-      })
-    );
-  })
-);
-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 ctx = yield* fresh(stepId, AbortSignal.any([signal, controller.signal]));
-            const result = yield* workflowSafe(
-              Effect_exports.tryPromise({ try: () => callback(ctx), catch: (error) => error })
-            );
-            return yield* Schema_exports.decodeUnknownEffect(WorkflowValue)(result).pipe(
-              Effect_exports.mapError(
-                () => new WorkflowFailure({ reason: "output", retryable: false })
-              )
-            );
-          })
-        ).pipe(Effect_exports.provideContext(services))
-      )
-    );
-  });
-  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
-    );
-    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[0], input: args, stepId, timeout }).pipe(Effect_exports.provideContext(services))
-      )
-    );
-  });
-  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 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(
-    (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(Encoding_exports.decodeBase64(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);
-        })
-      )
-    );
-  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: Encoding_exports.encodeBase64(new Uint8Array(bytes))
-    }),
-    new HostOutputInvalid()
-  );
-});
-
-// ../app-cache/src/index.ts
-var canonical = (value) => {
-  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
-  if (value !== null && typeof value === "object")
-    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
-  return JSON.stringify(value);
-};
-var cacheKey = (key) => Effect_exports.gen(function* () {
-  const parsed = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(key).pipe(
-    Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
-  );
-  const bytes = new TextEncoder().encode(canonical(parsed));
-  if (bytes.byteLength > cacheLimits.keyBytes)
-    return yield* new CacheError({ reason: "capacity" });
-  const hash = yield* Effect_exports.tryPromise({
-    try: () => crypto.subtle.digest("SHA-256", bytes),
-    catch: () => new CacheError({ reason: "invalid" })
-  });
-  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-});
-var makeCache = (transport, background, scope = "shared") => {
-  const keyOf = (key) => cacheKey([scope, key]);
-  const readKeys = (keys) => transport({ operation: "read", keys }).pipe(
-    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))),
-    Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
-  );
-  const durations = (freshFor, staleFor = 0) => Effect_exports.try({
-    try: () => {
-      const fresh = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor));
-      const stale = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor));
-      if (![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) || fresh + stale > cacheLimits.retentionMs)
-        throw new CacheError({ reason: "invalid" });
-      return { fresh, stale };
-    },
-    catch: () => new CacheError({ reason: "invalid" })
-  });
-  const get = (options, refresh) => Effect_exports.gen(function* () {
-    const key = yield* keyOf(options.key);
-    const { fresh, stale } = yield* durations(options.freshFor, options.staleFor);
-    const decode = (value) => Schema_exports.decodeUnknownEffect(options.schema)(value);
-    const load = (lease) => Effect_exports.gen(function* () {
-      const value = yield* options.load.pipe(Effect_exports.flatMap(decode));
-      const json = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(value).pipe(
-        Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
-      );
-      const now = yield* Clock_exports.currentTimeMillis;
-      const published = yield* transport({
-        operation: "publish",
-        key,
-        lease,
-        entry: {
-          value: json,
-          version: crypto.randomUUID(),
-          freshUntil: now + fresh,
-          staleUntil: now + fresh + stale
-        }
-      });
-      if (published !== true) return yield* new CacheError({ reason: "unavailable" });
-      return value;
-    }).pipe(
-      Effect_exports.withSpan("app.cache.load"),
-      Effect_exports.timeout(cacheLimits.loadTimeoutMs),
-      Effect_exports.ensuring(
-        transport({ operation: "release", key, lease }).pipe(Effect_exports.catch(() => Effect_exports.void))
-      )
-    );
-    const deadline = (yield* Clock_exports.currentTimeMillis) + cacheLimits.leaseMs;
-    let initialVersion;
-    while (true) {
-      const entry = (yield* readKeys([key]))[0] ?? null;
-      const now = yield* Clock_exports.currentTimeMillis;
-      if (initialVersion === void 0) initialVersion = entry?.version ?? null;
-      const refreshed = refresh && entry !== null && entry.version !== initialVersion;
-      if (entry !== null && (refreshed || !refresh && now < entry.freshUntil)) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
-        return yield* decode(entry.value);
-      }
-      const lease = yield* transport({
-        operation: "claim",
-        key,
-        version: entry?.version ?? null
-      }).pipe(Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.NullOr(Schema_exports.String))));
-      if (!refresh && entry !== null && now < entry.staleUntil) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
-        if (lease !== null) yield* background(load(lease).pipe(Effect_exports.asVoid));
-        return yield* decode(entry.value);
-      }
-      if (lease !== null) {
-        yield* Effect_exports.annotateCurrentSpan("cache.result", "miss");
-        return yield* load(lease);
-      }
-      if (now >= deadline) return yield* new CacheError({ reason: "timeout" });
-      yield* Effect_exports.sleep("100 millis");
-    }
-  }).pipe(Effect_exports.withSpan("app.cache.get"));
-  return {
-    /** Read arbitrary retained JSON entries without initiating a refresh. Missing and null are distinct. */
-    read: (keys) => Effect_exports.forEach(keys, keyOf).pipe(Effect_exports.flatMap(readKeys)),
-    /** Publish bounded immutable parts before publishing the manifest that references them. */
-    write: (entries, retention) => Effect_exports.gen(function* () {
-      const { fresh } = yield* durations(retention);
-      const now = yield* Clock_exports.currentTimeMillis;
-      const values = yield* Effect_exports.forEach(
-        entries,
-        ({ key, value }) => Effect_exports.gen(function* () {
-          return {
-            key: yield* keyOf(key),
-            entry: {
-              value,
-              version: crypto.randomUUID(),
-              freshUntil: now + fresh,
-              staleUntil: now + fresh
-            }
-          };
-        })
-      );
-      yield* transport({ operation: "write", entries: values });
-    }),
-    /** Revoke retained data and any loader's right to publish its in-flight result. */
-    invalidate: (key) => keyOf(key).pipe(
-      Effect_exports.flatMap((key2) => transport({ operation: "invalidate", key: key2 })),
-      Effect_exports.asVoid
-    ),
-    /** Read fresh data, refresh stale data in the background, or wait for the lease owner. */
-    get: (options) => get(options, false),
-    /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
-    revalidate: (options) => get(options, true)
-  };
-};
-
-// src/implementation/cache.ts
-var unavailableCache = {
-  transport: () => Effect_exports.fail(new CacheError({ reason: "unavailable" })),
-  background: () => Effect_exports.die(new Error("Cache background runner is unavailable"))
-};
-var authorCache = (host, accounts, signal) => {
-  const scoped = (scope, callerSignal = signal) => {
-    const cache = makeCache(host.transport, host.background, scope);
-    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, fields: bound.fields },
-          callerSignal
-        );
-      }
-    };
-  };
-  return scoped("shared");
-};
-
-// src/implementation/host.ts
-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) => 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()
-    );
-  })
-);
-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"
-  });
-}
-function providerDeclaration(provider) {
-  return safe2(
-    () => Effect_exports.gen(function* () {
-      const auth = /* @__PURE__ */ new Map();
-      for (const [name, method] of Object.entries(provider.auth)) {
-        switch (method._tag) {
-          case "secrets":
-            auth.set(name, {
-              type: "secrets",
-              label: method.label,
-              fields: yield* jsonSchema(method.fields)
-            });
-            break;
-          case "oauth2":
-            auth.set(name, {
-              type: "oauth2",
-              ...method.config,
-              response: yield* jsonSchema(method.response)
-            });
-            break;
-        }
-      }
-      return yield* Schema_exports.decodeUnknownEffect(DeclaredProvider)({
-        name: provider.name,
-        auth: Object.fromEntries(auth)
-      });
-    }),
-    new HostDeclarationInvalid()
-  );
-}
-function requirements(slots, database) {
-  return Effect_exports.gen(function* () {
-    const accounts = /* @__PURE__ */ new Map();
-    for (const [slot, selection] of Object.entries(slots)) {
-      accounts.set(slot, {
-        cardinality: selection instanceof ManyAccounts ? "many" : "one",
-        definition: yield* providerDeclaration(
-          selection instanceof ManyAccounts ? selection.provider : selection
-        )
-      });
-    }
-    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()));
-  });
-}
-function canonical2(value) {
-  if (Array.isArray(value)) return `[${value.map(canonical2).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical2(item)}`).join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-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 (canonical2(account.provider) !== canonical2(requirement.definition) || !Object.hasOwn(provider.auth, account.method))
-            return yield* Effect_exports.fail(new HostAccountsInvalid());
-          const method = provider.auth[account.method];
-          if (method === void 0) return yield* Effect_exports.fail(new HostAccountsInvalid());
-          const fields = yield* Schema_exports.decodeUnknownEffect(
-            method._tag === "secrets" ? method.fields : method.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()
-  );
-}
-function dispatch(app, request, context, signal) {
-  return Effect_exports.scoped(
-    Effect_exports.gen(function* () {
-      if (!isApp(app)) return yield* Effect_exports.fail(new HostDeclarationInvalid());
-      const native = toEffectApp(app);
-      const declared = yield* requirements(native.accounts, native.database?.schema);
-      if (request.operation === "requirements")
-        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;
-      });
-      let running;
-      let transactionOpen = false;
-      const delivery = (request2, signal2) => Effect_exports.suspend(
-        () => transactionOpen ? Effect_exports.fail(new ElicitationFailed({ reason: "transaction" })) : running !== void 0 && context.elicitation !== void 0 ? context.elicitation(request2, signal2).pipe(
-          Effect_exports.withSpan("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 workflowControls = {
-        start: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.start(input2),
-          invocationSignal
-        ),
-        get: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.get(input2),
-          invocationSignal
-        ),
-        list: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.list(input2),
-          invocationSignal
-        ),
-        terminate: toPromise(
-          (input2) => context.workflowControls === void 0 ? unavailableWorkflow() : context.workflowControls.terminate(input2),
-          invocationSignal
-        )
-      };
-      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()));
-      const bound = {
-        cache: authorCache(
-          context.cache ?? unavailableCache,
-          Redacted_exports.value(context.accounts),
-          invocationSignal
-        ),
-        files,
-        ...yield* bindAccounts(native.accounts, declared, context).pipe(
-          Effect_exports.withSpan("app.accounts.bind")
-        ),
-        workflows: workflowReads,
-        signal: invocationSignal,
-        fetch: yield* invocationFetch(invocationSignal),
-        elicit: makeElicit(delivery, invocationSignal)
-      };
-      const definition = yield* evaluationSafe(native.evaluate(bound)).pipe(
-        Effect_exports.withSpan("app.evaluate")
-      );
-      if (request.operation === "skills") {
-        const declared2 = definition.skills ?? (yield* folderSkillsEffect({ files }).pipe(
-          Effect_exports.mapError(() => new HostDeclarationInvalid())
-        ));
-        const source2 = definition.dynamicSkills;
-        const dynamic = source2 === void 0 ? [] : yield* evaluationSafe(Effect_exports.suspend(source2.list)).pipe(
-          Effect_exports.withSpan("app.skills.load")
-        );
-        const skills = yield* Schema_exports.decodeUnknownEffect(AppSkills)([...declared2, ...dynamic]).pipe(
-          Effect_exports.mapError(() => new HostDeclarationInvalid())
-        );
-        return request.sources === true ? { skills, dynamic: source2 !== void 0 } : skills;
-      }
-      if (request.operation === "workflows") {
-        return yield* Effect_exports.forEach(
-          Object.entries(definition.workflows ?? {}),
-          ([name2, entry]) => safe2(
-            () => Effect_exports.gen(function* () {
-              return yield* Schema_exports.decodeUnknownEffect(HostedWorkflow)({
-                name: name2,
-                ...entry.description === void 0 ? {} : { description: entry.description },
-                inputSchema: yield* jsonSchema(entry.input),
-                ...entry.output === void 0 ? {} : { outputSchema: yield* jsonSchema(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 {
-              ...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
-            };
-          }),
-          invocationSignal
-        );
-        const output = yield* workflowSafe(entry.run(workflowContext, input2));
-        const outputSchema = entry.output;
-        const decoded = outputSchema === void 0 ? output : yield* safe2(
-          () => Schema_exports.decodeUnknownEffect(outputSchema)(output),
-          new WorkflowFailure({ reason: "output", retryable: false })
-        );
-        return yield* safe2(
-          () => Schema_exports.decodeUnknownEffect(WorkflowValue)(decoded),
-          new WorkflowFailure({ reason: "output", retryable: false })
-        );
-      }
-      if (request.operation === "inspect") {
-        const summary = request.detail === "summary";
-        const wanted = request.tools === void 0 ? void 0 : new Set(request.tools);
-        const metadata = [];
-        for (const [prefix, readOnly, catalog2] of [
-          [OperationToolPrefixes.query, true, definition.queries],
-          [OperationToolPrefixes.mutate, false, definition.mutations]
-        ]) {
-          for (const [name2, operation] of Object.entries(catalog2 ?? {})) {
-            if (wanted !== void 0 && !wanted.has(`${prefix}${name2}`)) continue;
-            const schedules = Object.entries(definition.schedules ?? {}).filter(([, schedule]) => schedule.tool === `${prefix}${name2}`).map(([name3, { tool: _tool, ...schedule }]) => ({ name: name3, ...schedule }));
-            if (request.scheduled === true && schedules.length === 0) continue;
-            metadata.push(
-              yield* safe2(
-                () => Effect_exports.gen(function* () {
-                  const fields = {
-                    name: `${prefix}${name2}`,
-                    schedules,
-                    description: operation.description ?? `${readOnly ? "Query" : "Mutate"} ${name2}`,
-                    ...operation.title === void 0 ? {} : { title: operation.title },
-                    readOnly,
-                    annotations: { ...operation.annotations, readOnlyHint: readOnly }
-                  };
-                  if (summary)
-                    return yield* Schema_exports.decodeUnknownEffect(HostedToolSummary)(fields);
-                  return yield* Schema_exports.decodeUnknownEffect(HostedTool)({
-                    ...fields,
-                    inputSchema: yield* jsonSchema(operation.input),
-                    ...operation.output === void 0 ? operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema } : { outputSchema: yield* jsonSchema(operation.output) },
-                    ...operation._meta === void 0 ? {} : { _meta: operation._meta }
-                  });
-                }),
-                new HostDeclarationInvalid()
-              )
-            );
-          }
-        }
-        const dynamic = request.scheduled === true ? void 0 : definition.dynamicTools;
-        if (dynamic !== void 0 && (wanted === void 0 || metadata.length < wanted.size)) {
-          const declared2 = new Set(metadata.map((tool2) => tool2.name));
-          const discover = () => {
-            if (summary && dynamic.summaries !== void 0) return dynamic.summaries();
-            if (wanted !== void 0 && dynamic.describe !== void 0) {
-              const describe = dynamic.describe;
-              return Effect_exports.forEach(
-                [...wanted].filter((name2) => !declared2.has(name2)),
-                (name2) => describe(name2),
-                { concurrency: "unbounded" }
-              ).pipe(Effect_exports.map((tools) => tools.filter((tool2) => tool2 !== void 0)));
-            }
-            return dynamic.list();
-          };
-          const discovered = yield* evaluationSafe(discover()).pipe(
-            Effect_exports.flatMap(
-              (value) => safe2(
-                () => summary ? Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedToolSummary))(value) : Schema_exports.decodeUnknownEffect(Schema_exports.Array(HostedTool))(value),
-                new HostDeclarationInvalid()
-              )
-            )
-          );
-          const names = new Set(declared2);
-          for (const tool2 of discovered) {
-            const readOnly = tool2.name.startsWith(OperationToolPrefixes.query);
-            if (!readOnly && !tool2.name.startsWith(OperationToolPrefixes.mutate) || tool2.name === OperationToolPrefixes.query || tool2.name === OperationToolPrefixes.mutate || names.has(tool2.name))
-              return yield* new HostDeclarationInvalid();
-            names.add(tool2.name);
-            if (wanted !== void 0 && !wanted.has(tool2.name)) continue;
-            metadata.push({
-              ...tool2,
-              readOnly,
-              annotations: { ...tool2.annotations, readOnlyHint: readOnly }
-            });
-          }
-        }
-        return metadata;
-      }
-      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,
-            fetch: bound.fetch,
-            ...db === void 0 || native.database === void 0 ? {} : {
-              db: authorDatabase(native.database.tables, db, invocationSignal, true)
-            }
-          },
-          Redacted_exports.value(context.accounts)
-        );
-        if (native.database === void 0 || !["webhook-register", "webhook-handle", "webhook-unregister"].includes(request.operation))
-          return yield* executeWebhook();
-        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())
-          })
-        );
-      }
-      const kind = request.operation === "call" ? request.tool.startsWith(OperationToolPrefixes.query) ? "query" : request.tool.startsWith(OperationToolPrefixes.mutate) ? "mutate" : void 0 : request.operation;
-      if (kind === void 0) return yield* new HostToolNotFound();
-      const name = request.operation === "call" ? request.tool.slice(OperationToolPrefixes[kind].length) : request.name;
-      const toolName = `${OperationToolPrefixes[kind]}${name}`;
-      const catalog = kind === "query" ? definition.queries : definition.mutations;
-      const declaredTool = catalog !== void 0 && Object.hasOwn(catalog, name) ? catalog[name] : void 0;
-      const source = definition.dynamicTools;
-      const resolvedTool = source === void 0 || declaredTool !== void 0 ? void 0 : yield* evaluationSafe(source.resolve(toolName));
-      const tool = declaredTool ?? resolvedTool;
-      if (tool !== void 0 && tool.kind !== (kind === "query" ? "query" : "mutation"))
-        return yield* new HostDeclarationInvalid();
-      if (tool === void 0)
-        return yield* request.operation === "call" ? new HostToolNotFound() : new HostOperationNotFound();
-      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(
-          () => 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 execute = (db) => Effect_exports.gen(function* () {
-        transactionOpen = db !== void 0;
-        const output = yield* Effect_exports.gen(function* () {
-          running = yield* captureTelemetry;
-          const fetch = yield* invocationFetch(invocationSignal);
-          return yield* tool.run(
-            {
-              ...bound,
-              fetch,
-              workflows: kind === "mutate" ? workflowControls : workflowReads,
-              ...db === void 0 || native.database === void 0 ? {} : {
-                db: authorDatabase(
-                  native.database.tables,
-                  db,
-                  invocationSignal,
-                  kind === "mutate"
-                )
-              }
-            },
-            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 failure = Schema_exports.decodeUnknownOption(ElicitationFailed)(error);
-            return Effect_exports.fail(
-              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()
-            );
-          }),
-          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()
-        );
-      });
-      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();
-      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) => 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())
-        })
-      );
-    })
-  );
-}
-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,
-    HostToolNotFound: () => 404,
-    HostToolBlocked: () => 403,
-    HostToolApprovalRequired: () => 409,
-    HostToolPolicyFailed: () => 500,
-    HostOperationFailed: () => 500,
-    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 value = yield* dispatch(app, command, context, request.signal).pipe(
-    Effect_exports.provideService(ToolResultObservation, {
-      failed: () => {
-        toolError = true;
-      }
-    }),
-    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 } : {} });
-}).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 : Effect_exports.logError(cause).pipe(
-      Effect_exports.as(
-        Response.json(
-          { ok: false, error: { _tag: "HostDeclarationInvalid" } },
-          { status: 500 }
-        )
-      )
-    )
-  )
-);
-
-export {
-  prepareElicitation,
-  ApprovalDecision,
-  cacheKey,
-  createAppHandler
-};