@byok-sdk/cloud-do 0.0.0-stage → 0.24.0

package/dist/index.js

@@ -0,0 +1,3915 @@
+import { DurableObject } from 'cloudflare:workers';
+import { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';
+import { watchEvents, createRegistry, defineExtension, hook, ToolTask, Harness } from '@earendil-works/pi-durable';
+import { validateToolArguments } from '@earendil-works/pi-ai/utils/validation';
+import { createModels, createProvider } from '@earendil-works/pi-ai/models';
+import { AssistantMessageEventStream } from '@earendil-works/pi-ai/utils/event-stream';
+import { getCurrentTools } from '@earendil-works/pi-ai/utils/transcript';
+import { getSystemMessageText } from '@earendil-works/pi-ai/utils/text';
+import { SQLITE_MIGRATIONS, SqliteStorage } from '@earendil-works/pi-durable/storage/sqlite';
+
+// src/agent-do.ts
+
+// src/errors.ts
+var status = {
+  CLOUD_REQUEST_INVALID: 400,
+  CLOUD_INBOX_FULL: 429,
+  CLOUD_INBOX_CONFLICT: 409,
+  CLOUD_INBOX_EXPIRED: 409,
+  CLOUD_INBOX_TOO_LARGE: 400,
+  CLOUD_WAKE_EXHAUSTED: 409,
+  CLOUD_WAKE_EMPTY: 409,
+  CLOUD_EVENT_CURSOR_EXPIRED: 410,
+  CLOUD_EVENTS_BUSY: 429,
+  CLOUD_USER_CREDENTIAL_REJECTED: 400,
+  CLOUD_MODEL_CREDENTIAL_UNAVAILABLE: 503,
+  CLOUD_MODEL_RESPONSE_REJECTED: 502,
+  CLOUD_MODEL_REQUEST_FAILED: 502,
+  CLOUD_SESSION_CONFLICT: 409,
+  CLOUD_TOOL_NOT_AVAILABLE: 400,
+  CLOUD_TOOL_INVOCATION_CONFLICT: 409,
+  CLOUD_TOOL_ARGUMENT_INVALID: 400,
+  CLOUD_TOOL_LIMIT: 400,
+  CLOUD_STEP_LIMIT: 400,
+  CLOUD_BUDGET_EXCEEDED: 400,
+  CLOUD_TOOL_RESULT_LIMIT: 502,
+  CLOUD_TOOL_USAGE_INVALID: 502,
+  CLOUD_TOOL_BUSY: 409,
+  CLOUD_TOOL_TIMEOUT: 504,
+  CLOUD_EXECUTION_TIMEOUT: 504,
+  CLOUD_EXECUTION_INTERRUPTED: 409,
+  CLOUD_EXECUTION_ABORTED: 409,
+  CLOUD_TOOL_FAILED: 502
+};
+var CloudDoError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "CloudDoError";
+    this.status = status[code];
+  }
+  code;
+  status;
+  retryable = false;
+};
+function safeCloudError(error) {
+  try {
+    if (error instanceof CloudDoError) {
+      const code = Object.getOwnPropertyDescriptor(error, "code")?.value;
+      if (typeof code === "string" && Object.hasOwn(status, code)) return new CloudDoError(code);
+    }
+    if (error instanceof Error) {
+      const message = Object.getOwnPropertyDescriptor(error, "message")?.value;
+      if (typeof message === "string" && Object.hasOwn(status, message)) return new CloudDoError(message);
+    }
+  } catch {
+  }
+  return new CloudDoError("CLOUD_MODEL_REQUEST_FAILED");
+}
+function cloudErrorResponse(error) {
+  const safe = safeCloudError(error);
+  return Response.json({ error: { code: safe.code, retryable: false } }, { status: safe.status });
+}
+
+// src/platform-credentials.ts
+var PLATFORM_PROFILES = Object.freeze({
+  zai_openai: Object.freeze({ vendor: "zai", baseUrl: "https://api.z.ai/api/coding/paas/v4", model: "glm-5.3-flash", binding: "AIPHABEE_ZAI_API_KEY", secretName: "model-zai_openai-api-key" }),
+  deepseek_direct: Object.freeze({ vendor: "deepseek", baseUrl: "https://api.deepseek.com", model: "deepseek-v4-flash", binding: "AIPHABEE_DEEPSEEK_API_KEY", secretName: "model-deepseek_direct-api-key" })
+});
+function platformProfile(id) {
+  if (typeof id !== "string" || !Object.hasOwn(PLATFORM_PROFILES, id)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  return id;
+}
+function requirePlatformKey(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9._~+/-]{16,512}$/u.test(value)) throw new CloudDoError("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE");
+  return value;
+}
+function platformCredentialReader(env) {
+  return {
+    async get(name) {
+      const profile = Object.values(PLATFORM_PROFILES).find((profile2) => profile2.secretName === name);
+      if (!profile) throw new CloudDoError("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE");
+      try {
+        return requirePlatformKey(env[profile.binding]);
+      } catch {
+        throw new CloudDoError("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE");
+      }
+    }
+  };
+}
+
+// src/admission.ts
+var credentialFields = /* @__PURE__ */ new Set(["credential", "credentials", "apikey", "api_key", "secret", "authorization", "x-api-key", "api-key", "x-goog-api-key", "proxy-authorization", "cf-aig-authorization", "headers"]);
+function rejectCredentialFields(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") return;
+  if (depth > 8 || seen.has(value)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  seen.add(value);
+  for (const [name, child] of Object.entries(value)) {
+    if (credentialFields.has(name.toLowerCase())) throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+    rejectCredentialFields(child, depth + 1, seen);
+  }
+}
+function hasUserKeyShape(text2) {
+  return /\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{16,}\b|\b[a-f\d]{32}\.[A-Za-z0-9_-]{16,}\b/u.test(text2);
+}
+function admitCloudSubmission(input) {
+  rejectCredentialFields(input);
+  if (!input || typeof input !== "object" || Array.isArray(input)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  const body = input;
+  if (Object.keys(body).some((name) => name !== "instruction" && name !== "profile") || typeof body.instruction !== "string" || !body.instruction.trim() || body.instruction.length > 16e3) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  if (hasUserKeyShape(body.instruction)) throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+  return { instruction: body.instruction, profile: platformProfile(body.profile === void 0 ? "zai_openai" : body.profile) };
+}
+
+// src/leak-guard.ts
+var FRAGMENT_LENGTH = 16;
+function percentPattern(secret) {
+  return new RegExp(Array.from(secret, (character) => {
+    const literal = character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const hex = character.charCodeAt(0).toString(16).padStart(2, "0").replace(/[a-f]/g, (digit) => `[${digit}${digit.toUpperCase()}]`);
+    return `(?:${literal}|%${hex})`;
+  }).join(""));
+}
+function addEncodedForms(forms, secret) {
+  forms.add(secret);
+  const encoded = btoa(secret);
+  forms.add(encoded);
+  forms.add(encoded.replace(/=+$/, ""));
+  forms.add(encoded.replace(/\+/g, "-").replace(/\//g, "_"));
+  forms.add(encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, ""));
+  for (let offset = 0; offset < 3; offset++) {
+    const interior = btoa("\0".repeat(offset) + secret).slice(
+      Math.ceil(8 * offset / 6),
+      Math.floor(8 * (offset + secret.length) / 6)
+    );
+    forms.add(interior);
+    forms.add(interior.replace(/\+/g, "-").replace(/\//g, "_"));
+  }
+}
+var RollingLeakGuard = class {
+  tailLength;
+  forms;
+  percentForms;
+  pending = "";
+  closed = false;
+  constructor(key) {
+    this.tailLength = 3 * key.length - 1;
+    const secrets = /* @__PURE__ */ new Set([key]);
+    const sensitive = key.replace(/^(?:sk-(?:ant-|proj-)?|zai[-_])/, "");
+    for (let start = 0; start <= sensitive.length - FRAGMENT_LENGTH; start++) {
+      secrets.add(sensitive.slice(start, start + FRAGMENT_LENGTH));
+    }
+    const forms = /* @__PURE__ */ new Set();
+    const percentForms = [];
+    for (const secret of secrets) {
+      addEncodedForms(forms, secret);
+      percentForms.push(percentPattern(secret));
+    }
+    this.forms = [...forms];
+    this.percentForms = percentForms;
+  }
+  push(text2) {
+    if (this.closed) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+    const combined = this.pending + text2;
+    this.scan(combined);
+    const releaseLength = Math.max(0, combined.length - this.tailLength);
+    this.pending = combined.slice(releaseLength);
+    return combined.slice(0, releaseLength);
+  }
+  finish() {
+    if (this.closed) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+    this.scan(this.pending);
+    const safe = this.pending;
+    this.discard();
+    return safe;
+  }
+  discard() {
+    this.pending = "";
+    this.closed = true;
+  }
+  scan(text2) {
+    if (this.forms.some((form) => text2.includes(form)) || this.percentForms.some((pattern) => pattern.test(text2))) {
+      this.discard();
+      throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+    }
+  }
+};
+
+// src/input-guard.ts
+async function admitCloudText(env, text2, selected) {
+  if (typeof text2 !== "string") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  if (hasUserKeyShape(text2)) throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+  const credentials2 = platformCredentialReader(env);
+  for (const [id, profile] of Object.entries(PLATFORM_PROFILES)) {
+    let key;
+    try {
+      if (env[profile.binding] === void 0) continue;
+      key = await credentials2.get(profile.secretName);
+    } catch {
+      if (selected && id !== selected) continue;
+      throw new CloudDoError("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE");
+    }
+    const guard = new RollingLeakGuard(key);
+    try {
+      guard.push(text2);
+      guard.finish();
+    } catch {
+      throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+    }
+  }
+}
+async function admitCloudPayload(env, value, selected) {
+  const ancestors = /* @__PURE__ */ new Set();
+  let nodes = 0;
+  const visit = async (item, depth) => {
+    if (++nodes > 1e4 || depth > 32) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    if (typeof item === "string") {
+      await admitCloudText(env, item, selected);
+      return;
+    }
+    if (item === null || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)) return;
+    if (!item || typeof item !== "object" || ancestors.has(item)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    if (!Array.isArray(item) && Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null) {
+      throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    }
+    ancestors.add(item);
+    try {
+      if (Array.isArray(item)) {
+        if (Reflect.ownKeys(item).length !== item.length + 1) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+        for (let i = 0; i < item.length; i++) {
+          const field = Object.getOwnPropertyDescriptor(item, String(i));
+          if (!field || !("value" in field) || !field.enumerable) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+          await visit(field.value, depth + 1);
+        }
+      } else {
+        for (const key of Reflect.ownKeys(item)) {
+          const field = Object.getOwnPropertyDescriptor(item, key);
+          if (typeof key !== "string" || !field || !("value" in field) || !field.enumerable) {
+            throw new CloudDoError("CLOUD_REQUEST_INVALID");
+          }
+          await visit(key, depth + 1);
+          await visit(field.value, depth + 1);
+        }
+      }
+    } finally {
+      ancestors.delete(item);
+    }
+  };
+  await visit(value, 0);
+}
+async function prepareCloudGuard(env, selected) {
+  if (selected !== void 0 && (typeof selected !== "string" || !Object.hasOwn(PLATFORM_PROFILES, selected))) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  const credentials2 = platformCredentialReader(env);
+  const keys = [];
+  for (const [id, profile] of Object.entries(PLATFORM_PROFILES)) {
+    try {
+      if (env[profile.binding] === void 0 && id !== selected) continue;
+      keys.push(await credentials2.get(profile.secretName));
+    } catch {
+      if (selected && id !== selected) continue;
+      keys.length = 0;
+      throw new CloudDoError("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE");
+    }
+  }
+  let disposed = false;
+  const guardText = (text2) => {
+    if (disposed || typeof text2 !== "string") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    if (hasUserKeyShape(text2)) throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+    for (const key of keys) {
+      const guard = new RollingLeakGuard(key);
+      try {
+        guard.push(text2);
+        guard.finish();
+      } catch {
+        throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+      }
+    }
+  };
+  return {
+    guardText,
+    guardPayload(dataJson) {
+      if (disposed || typeof dataJson !== "string") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      let value;
+      try {
+        value = JSON.parse(dataJson);
+      } catch {
+        throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      }
+      let nodes = 0;
+      const visit = (item, depth) => {
+        if (++nodes > 1e4 || depth > 32) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+        if (typeof item === "string") {
+          guardText(item);
+          return;
+        }
+        if (item === null || typeof item === "boolean" || typeof item === "number" && Number.isFinite(item)) return;
+        if (!item || typeof item !== "object") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+        if (Array.isArray(item)) {
+          for (const field of item) visit(field, depth + 1);
+        } else {
+          if (Object.getPrototypeOf(item) !== Object.prototype && Object.getPrototypeOf(item) !== null) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+          for (const [key, field] of Object.entries(item)) {
+            visit(key, depth + 1);
+            visit(field, depth + 1);
+          }
+        }
+      };
+      visit(value, 0);
+      return JSON.stringify(value);
+    },
+    dispose() {
+      keys.length = 0;
+      disposed = true;
+    }
+  };
+}
+
+// src/inbox-admission.ts
+var fields = /* @__PURE__ */ new Set(["dedupKey", "source", "text", "profile", "availableAt", "expiresAt"]);
+var credentials = /* @__PURE__ */ new Set(["credential", "credentials", "apikey", "api_key", "secret", "authorization", "x-api-key", "api-key", "x-goog-api-key", "proxy-authorization", "cf-aig-authorization", "headers"]);
+var INBOX_DAY = 864e5;
+function admitCloudInbox(input, now = Date.now()) {
+  if (!input || typeof input !== "object" || Array.isArray(input) || Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null) {
+    throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  for (const key of Reflect.ownKeys(input)) {
+    if (typeof key === "string" && credentials.has(key.toLowerCase())) throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    if (typeof key !== "string" || !fields.has(key) || !descriptor?.enumerable || !("value" in descriptor)) {
+      throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    }
+  }
+  const body = input;
+  if (typeof body.dedupKey !== "string" || !body.dedupKey.length || body.dedupKey.length > 128 || /[\u0000-\u001f\u007f-\u009f]/u.test(body.dedupKey) || typeof body.text !== "string" || !body.text.trim() || body.text.length > 16e3 || !["message", "schedule", "invocation"].includes(body.source)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  if (hasUserKeyShape(body.text) || hasUserKeyShape(body.dedupKey)) throw new CloudDoError("CLOUD_USER_CREDENTIAL_REJECTED");
+  for (const key of ["availableAt", "expiresAt"]) {
+    if (body[key] !== void 0 && !Number.isSafeInteger(body[key])) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  const availableAt = body.availableAt;
+  const expiresAt = body.expiresAt;
+  if (availableAt !== void 0 && availableAt > now + 30 * INBOX_DAY || expiresAt !== void 0 && availableAt !== void 0 && expiresAt <= availableAt) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  return Object.freeze({
+    dedupKey: body.dedupKey,
+    source: body.source,
+    text: body.text,
+    profile: platformProfile(body.profile === void 0 ? "zai_openai" : body.profile),
+    ...availableAt === void 0 ? {} : { availableAt },
+    ...expiresAt === void 0 ? {} : { expiresAt }
+  });
+}
+
+// src/tools.ts
+var CLOUD_SAFE_REPLAY_TOOLS = Object.freeze([
+  "load_financial_analysis_skill",
+  "resolve_security",
+  "guarded_screen",
+  "search_f10_datasets",
+  "query_f10_dataset",
+  "get_security_profile",
+  "get_quote_snapshot",
+  "get_corporate_actions",
+  "get_financial_statements",
+  "get_financial_facts",
+  "get_financial_ratios",
+  "get_sdi_disclosures",
+  "get_directorate",
+  "get_ownership",
+  "get_related_warrants"
+]);
+var CLOUD_LIVE_IPO_TOOLS = Object.freeze([
+  "get_ipo_profile",
+  "search_ipo_calendar",
+  "get_ipo_timetable",
+  "get_ipo_offering",
+  "get_ipo_allotment",
+  "screen_ipos",
+  "compare_ipos"
+]);
+var safeTools = new Set(CLOUD_SAFE_REPLAY_TOOLS);
+var admittedNames = /* @__PURE__ */ new Set([...CLOUD_SAFE_REPLAY_TOOLS, ...CLOUD_LIVE_IPO_TOOLS]);
+var CLOUD_DOMAIN_ERROR_CODES = Object.freeze({
+  NOT_FOUND: "CLOUD_TOOL_NOT_AVAILABLE",
+  DATA_NOT_LICENSED: "CLOUD_TOOL_NOT_AVAILABLE",
+  DATA_QUALITY_HOLD: "CLOUD_TOOL_NOT_AVAILABLE",
+  SCOPE_DENIED: "CLOUD_TOOL_NOT_AVAILABLE",
+  TOOL_UNAVAILABLE: "CLOUD_TOOL_NOT_AVAILABLE",
+  TOOL_ARGUMENT_INVALID: "CLOUD_TOOL_ARGUMENT_INVALID",
+  OUT_OF_RANGE: "CLOUD_TOOL_ARGUMENT_INVALID",
+  TOO_MANY_ROWS: "CLOUD_TOOL_ARGUMENT_INVALID",
+  AMBIGUOUS_SECURITY: "CLOUD_TOOL_ARGUMENT_INVALID",
+  SYMBOL_AMBIGUOUS: "CLOUD_TOOL_ARGUMENT_INVALID"
+});
+function policyNames(names2, max, pattern, forbidden) {
+  if (names2 === void 0) return Object.freeze([]);
+  if (!Array.isArray(names2) || names2.length > max || new Set(names2).size !== names2.length || Array.from(names2).some((name) => typeof name !== "string" || !pattern.test(name) || forbidden(name))) {
+    throw new CloudDoError("CLOUD_TOOL_NOT_AVAILABLE");
+  }
+  return Object.freeze([...names2].sort());
+}
+function admitCloudTools(tools, pureTools = []) {
+  const pure = new Set(policyNames(pureTools, 8, /^[a-z][a-z0-9_]{2,63}$/, (name) => admittedNames.has(name)));
+  const seen = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    const schema = tool.parameters;
+    if (!(tool.execution === "pure" ? pure.has(tool.name) : admittedNames.has(tool.name)) || seen.has(tool.name) || typeof tool.description !== "string" || tool.mode !== void 0 && tool.mode !== "inline" || (tool.requiredCapabilities?.length ?? 0) > 0 || !schema || schema.type !== "object" || schema.additionalProperties !== false || !schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties) || (tool.execution === "pure" ? tool.resolverRpc !== void 0 : tool.name === "load_financial_analysis_skill" ? tool.execution !== "skill" || Object.keys(schema.properties).length !== 0 : tool.execution !== "read_only_live" || typeof tool.resolverRpc !== "string" || !tool.resolverRpc.trim())) {
+      throw new CloudDoError("CLOUD_TOOL_NOT_AVAILABLE");
+    }
+    seen.add(tool.name);
+  }
+  return Object.freeze([...tools]);
+}
+function admitCloudDispatcher(dispatcher) {
+  const pureTools = policyNames(dispatcher.pureTools, 8, /^[a-z][a-z0-9_]{2,63}$/, (name) => admittedNames.has(name));
+  const domainErrors = policyNames(dispatcher.domainErrors, 64, /^[A-Z][A-Z0-9_]{2,63}$/, (name) => name.startsWith("CLOUD_") || Object.hasOwn(CLOUD_DOMAIN_ERROR_CODES, name));
+  if (dispatcher.modelViews !== void 0 && typeof dispatcher.modelViews !== "boolean") throw new CloudDoError("CLOUD_TOOL_NOT_AVAILABLE");
+  const tools = admitCloudTools(dispatcher.tools, pureTools);
+  const snapshot = JSON.parse(JSON.stringify({ tools }));
+  const freeze = (value) => {
+    if (value && typeof value === "object") {
+      Object.values(value).forEach(freeze);
+      Object.freeze(value);
+    }
+  };
+  freeze(snapshot);
+  return Object.freeze({
+    tools: snapshot.tools,
+    pureTools,
+    domainErrors,
+    modelViews: dispatcher.modelViews ?? false,
+    execute: dispatcher.execute.bind(dispatcher)
+  });
+}
+function dispatcherDigest(dispatcher) {
+  return digest(canonicalArgs({
+    tools: dispatcher.tools.map(({ name, execution, parameters }) => ({ name, execution, parameters })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0),
+    pureTools: [...dispatcher.pureTools ?? []].sort(),
+    domainErrors: [...dispatcher.domainErrors ?? []].sort(),
+    modelViews: dispatcher.modelViews ?? false
+  }));
+}
+function replayForTool(name) {
+  return safeTools.has(name) ? "safe" : "unsafe";
+}
+function canonical(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value)) return JSON.stringify(value);
+  if (typeof value !== "object" || ancestors.has(value)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.keys(value).length !== value.length) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      return `[${value.map((item) => canonical(item, ancestors)).join(",")}]`;
+    }
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key], ancestors)}`).join(",")}}`;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function canonicalArgs(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  return canonical(args, /* @__PURE__ */ new Set());
+}
+async function digest(value) {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function invocationId(conversationId, assistantEntryId, toolCallId) {
+  return digest(JSON.stringify([conversationId, assistantEntryId, toolCallId]));
+}
+function argsDigest(toolName, args) {
+  return digest(`[${JSON.stringify(toolName)},${canonicalArgs(args)}]`);
+}
+
+// src/cloud-state.ts
+var encoder = new TextEncoder();
+var CLOUD_CONTEXT_BYTES = 48e3;
+var RETENTION = 7 * INBOX_DAY;
+var terminalInbox = "state NOT IN ('queued','running')";
+var terminalRun = "state NOT IN ('starting','running')";
+var terminalInvocation = "state NOT IN ('accepted','running')";
+function inboxInput(rows) {
+  return rows.map((row2) => ({ seq: row2.seq, source: row2.source, text: JSON.parse(row2.payloadJson).text }));
+}
+function admissionIdentity(rows) {
+  return { digest: sha256(JSON.stringify(rows.map((row2) => [
+    row2.seq,
+    row2.dedupKey,
+    sha256(JSON.parse(row2.payloadJson).text),
+    row2.profile
+  ]))), seqs: rows.map((row2) => row2.seq) };
+}
+function runInputSeqs(entries) {
+  if (!Array.isArray(entries)) return [];
+  const entry = entries.find((value) => value !== null && typeof value === "object" && value.kind === "byok.run-input");
+  if (!entry || typeof entry !== "object") return [];
+  const data = entry.data;
+  if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+  const items = data.items;
+  if (!Array.isArray(items) || items.length > 16) return [];
+  const seqs = [];
+  for (const item of items) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return [];
+    const { seq, source, text: text2 } = item;
+    if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq <= 0 || seqs.includes(seq) || (typeof source !== "string" || !["message", "schedule", "invocation"].includes(source)) || typeof text2 !== "string") return [];
+    seqs.push(seq);
+  }
+  return seqs;
+}
+function payloadText(row2) {
+  if (row2?.payloadJson === null || row2?.payloadJson === void 0) return null;
+  const value = JSON.parse(row2.payloadJson);
+  return typeof value.text === "string" ? value.text : null;
+}
+function composeCloudInput(rows, historyNewestFirst = []) {
+  const inbox = inboxInput(rows);
+  const history = [];
+  for (const item of historyNewestFirst.slice(0, 20)) {
+    const candidate = [item, ...history];
+    if (encoder.encode(canonicalArgs({ history: candidate, inbox })).byteLength > CLOUD_CONTEXT_BYTES) break;
+    history.unshift(item);
+  }
+  return canonicalArgs({ history, inbox });
+}
+function utf8Prefix(text2, maxBytes) {
+  let bytes = 0;
+  let end = 0;
+  for (const point of text2) {
+    const size = encoder.encode(point).length;
+    if (bytes + size > maxBytes) break;
+    bytes += size;
+    end += point.length;
+  }
+  return text2.slice(0, end);
+}
+function sha256(text2) {
+  const constants = [
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ];
+  const source = encoder.encode(text2);
+  const data = new Uint8Array(Math.ceil((source.length + 9) / 64) * 64);
+  data.set(source);
+  data[source.length] = 128;
+  const view = new DataView(data.buffer);
+  view.setUint32(data.length - 8, Math.floor(source.length / 536870912));
+  view.setUint32(data.length - 4, source.length * 8);
+  const hash = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  const rotate = (value, count) => value >>> count | value << 32 - count;
+  const words = new Uint32Array(64);
+  for (let offset = 0; offset < data.length; offset += 64) {
+    for (let i = 0; i < 16; i++) words[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const a2 = words[i - 15];
+      const b2 = words[i - 2];
+      words[i] = words[i - 16] + (rotate(a2, 7) ^ rotate(a2, 18) ^ a2 >>> 3) + words[i - 7] + (rotate(b2, 17) ^ rotate(b2, 19) ^ b2 >>> 10);
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let i = 0; i < 64; i++) {
+      const first = h + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + (e & f ^ ~e & g) + constants[i] + words[i] | 0;
+      const second = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + first | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = first + second | 0;
+    }
+    for (const [index, value] of [a, b, c, d, e, f, g, h].entries()) hash[index] = hash[index] + value >>> 0;
+  }
+  return hash.map((value) => value.toString(16).padStart(8, "0")).join("");
+}
+var CloudState = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  scheduling = {};
+  rows(query, ...values) {
+    return this.storage.sql.exec(query, ...values).toArray();
+  }
+  ensureSchema() {
+    this.storage.transactionSync(() => {
+      this.storage.sql.exec(`CREATE TABLE IF NOT EXISTS cloud_inbox (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT, dedupKey TEXT NOT NULL UNIQUE, payloadDigest TEXT NOT NULL,
+        source TEXT NOT NULL CHECK(source IN ('message','schedule','invocation')), profile TEXT NOT NULL, payloadJson TEXT,
+        availableAt INTEGER NOT NULL, expiresAt INTEGER NOT NULL,
+        state TEXT NOT NULL CHECK(state IN ('queued','running','done','failed','interrupted','cancelled','expired')),
+        runId INTEGER, attempts INTEGER NOT NULL DEFAULT 0, errorCode TEXT, createdAt INTEGER NOT NULL, settledAt INTEGER);
+        CREATE INDEX IF NOT EXISTS cloud_inbox_runnable ON cloud_inbox(state,availableAt,seq);
+        CREATE TABLE IF NOT EXISTS cloud_events (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,eventKey TEXT NOT NULL UNIQUE,type TEXT NOT NULL,
+        conversationId INTEGER,ref TEXT,dataJson TEXT NOT NULL,createdAt INTEGER NOT NULL);
+        CREATE TABLE IF NOT EXISTS cloud_event_meta (
+        singleton INTEGER PRIMARY KEY CHECK(singleton=1),trimmedThrough INTEGER NOT NULL DEFAULT 0,
+        highWater INTEGER NOT NULL DEFAULT 0,pendingMaintenanceAt INTEGER);
+        INSERT INTO cloud_event_meta(singleton) VALUES(1) ON CONFLICT DO NOTHING;
+        CREATE TABLE IF NOT EXISTS cloud_projections (
+        key TEXT PRIMARY KEY,invocationId TEXT NOT NULL,state TEXT NOT NULL,payloadDigest TEXT NOT NULL,
+        dataJson TEXT NOT NULL,errorCode TEXT,createdAt INTEGER NOT NULL)`);
+      const legacyMembership = !this.rows("PRAGMA table_info(cloud_executions)").some((row2) => row2.name === "membershipPending");
+      this.migrate("cloud_inbox", { inputDurable: "INTEGER NOT NULL DEFAULT 0", revision: "INTEGER" });
+      this.storage.sql.exec(`CREATE TABLE IF NOT EXISTS cloud_run_turns (
+        runId INTEGER NOT NULL, seq INTEGER NOT NULL, claimEvent INTEGER, releaseEvent INTEGER,
+        PRIMARY KEY (runId,seq));
+        CREATE INDEX IF NOT EXISTS cloud_run_turns_by_seq ON cloud_run_turns(seq,runId)`);
+      this.migrate("cloud_executions", {
+        trigger: "TEXT NOT NULL DEFAULT 'submit'",
+        requestId: "TEXT",
+        submissionId: "INTEGER",
+        state: "TEXT NOT NULL DEFAULT 'interrupted'",
+        errorCode: "TEXT",
+        startedAt: "INTEGER",
+        settledAt: "INTEGER",
+        reservation: "TEXT NOT NULL DEFAULT 'none'",
+        eligibilityJson: "TEXT",
+        admissionDigest: "TEXT",
+        admittedSeqs: "TEXT",
+        settlementAck: "INTEGER",
+        revision: "INTEGER",
+        membershipPending: "INTEGER"
+      });
+      if (legacyMembership) {
+        this.storage.sql.exec("INSERT OR IGNORE INTO cloud_run_turns(runId,seq) SELECT runId,seq FROM cloud_inbox WHERE runId IS NOT NULL");
+        this.storage.sql.exec("UPDATE cloud_executions SET membershipPending=1 WHERE trigger='wake'");
+      }
+      this.migrate("cloud_invocations", { deliveredState: "TEXT NOT NULL DEFAULT 'undelivered'", taskId: "INTEGER", resultEntryId: "INTEGER" });
+    });
+  }
+  migrate(table, columns) {
+    const existing = new Set(this.rows(`PRAGMA table_info(${table})`).map((row2) => row2.name));
+    for (const [name, type] of Object.entries(columns)) if (!existing.has(name)) this.storage.sql.exec(`ALTER TABLE ${table} ADD COLUMN ${name} ${type}`);
+  }
+  readInboxItem(seq) {
+    return this.rows("SELECT * FROM cloud_inbox WHERE seq=?", seq)[0];
+  }
+  run(conversationId) {
+    return this.rows("SELECT * FROM cloud_executions WHERE conversationId=?", conversationId)[0];
+  }
+  unsettledRuns() {
+    return this.rows(`SELECT * FROM cloud_executions WHERE ${terminalRun.replace("NOT IN", "IN")} ORDER BY conversationId`);
+  }
+  completedRuns() {
+    return this.rows("SELECT * FROM cloud_executions WHERE state='completed' ORDER BY conversationId DESC LIMIT 20");
+  }
+  invocationRowsForRun(id) {
+    return this.rows("SELECT * FROM cloud_invocations WHERE conversationId=? ORDER BY seq", id);
+  }
+  stamp(table, key, revision) {
+    this.storage.sql.exec(`UPDATE ${table} SET revision=? WHERE ${table === "cloud_inbox" ? "seq" : "conversationId"}=? AND (revision IS NULL OR revision<?)`, revision, key, revision);
+  }
+  claimedSeqs(id) {
+    return this.rows("SELECT seq FROM cloud_run_turns WHERE runId=? ORDER BY seq", id).map((row2) => row2.seq);
+  }
+  markInputDurable(id, seqs) {
+    this.storage.transactionSync(() => {
+      for (const seq of seqs) this.storage.sql.exec("UPDATE cloud_inbox SET inputDurable=1 WHERE seq=? AND runId=? AND state='running'", seq, id);
+    });
+  }
+  pendingBackfills(before = Number.MAX_SAFE_INTEGER) {
+    return this.rows("SELECT * FROM cloud_executions WHERE membershipPending=1 AND conversationId<? ORDER BY conversationId DESC LIMIT 25", before);
+  }
+  applyBackfill(id, seqs) {
+    this.storage.transactionSync(() => {
+      if (this.run(id)?.membershipPending !== 1) return;
+      for (const seq of seqs) this.storage.sql.exec(`INSERT INTO cloud_run_turns(runId,seq)
+        SELECT ?,? WHERE NOT EXISTS(SELECT 1 FROM cloud_run_turns WHERE seq=?)
+        AND NOT EXISTS(SELECT 1 FROM cloud_inbox WHERE seq=?)`, id, seq, seq, seq);
+      this.storage.sql.exec("UPDATE cloud_executions SET membershipPending=0 WHERE conversationId=?", id);
+    });
+  }
+  unackedRuns() {
+    return this.rows(`SELECT * FROM cloud_executions WHERE ${terminalRun} AND settlementAck=0 ORDER BY conversationId`);
+  }
+  ackSettlement(id, guard, now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      if (this.run(id)?.settlementAck !== 0) return false;
+      this.storage.sql.exec("UPDATE cloud_executions SET settlementAck=1 WHERE conversationId=?", id);
+      const event = this.appendEvent({
+        eventKey: `run:${id}:settlement`,
+        type: "run.settlement",
+        conversationId: id,
+        data: { nativeRunId: id, ack: true },
+        createdAt: now
+      }, guard);
+      this.stamp("cloud_executions", id, event.seq);
+      return true;
+    });
+  }
+  /** Read-only preflight also works before this DO has initialized its schema. */
+  validateEnqueue(input, guard, now = Date.now()) {
+    guard.guardText(input.text);
+    guard.guardText(input.dedupKey);
+    const exists = this.rows("SELECT name FROM sqlite_master WHERE type='table' AND name='cloud_inbox'").length > 0;
+    const previous = exists ? this.rows("SELECT * FROM cloud_inbox WHERE dedupKey=?", input.dedupKey)[0] : void 0;
+    this.enqueueIdentity(input, previous, now);
+  }
+  enqueueIdentity(input, previous, now) {
+    const retained = previous && (previous.settledAt === null || previous.settledAt + RETENTION > now) ? previous : void 0;
+    const availableAt = input.availableAt ?? retained?.availableAt ?? now;
+    const expiresAt = input.expiresAt ?? retained?.expiresAt ?? availableAt + INBOX_DAY;
+    if (!Number.isSafeInteger(availableAt) || !Number.isSafeInteger(expiresAt)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const payloadDigest = sha256(canonicalArgs({ source: input.source, text: input.text, profile: input.profile, availableAt, expiresAt }));
+    if (retained && retained.payloadDigest !== payloadDigest) throw new CloudDoError("CLOUD_INBOX_CONFLICT");
+    if (expiresAt <= availableAt || !retained && availableAt > now + 30 * INBOX_DAY) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    return { retained, availableAt, expiresAt, payloadDigest };
+  }
+  async enqueue(input, guard, now = Date.now(), options) {
+    guard.guardText(input.text);
+    guard.guardText(input.dedupKey);
+    if (options) this.setSchedulingState(options);
+    return this.storage.transaction(async () => {
+      const previous = this.rows("SELECT * FROM cloud_inbox WHERE dedupKey=?", input.dedupKey)[0];
+      const { retained, availableAt, expiresAt, payloadDigest } = this.enqueueIdentity(input, previous, now);
+      if (retained) return { accepted: false, row: retained };
+      if (this.rows("SELECT COUNT(*) AS count FROM cloud_inbox WHERE state='queued'")[0].count >= 100) throw new CloudDoError("CLOUD_INBOX_FULL");
+      if (previous) this.storage.sql.exec("DELETE FROM cloud_inbox WHERE seq=?", previous.seq);
+      const row2 = this.rows(
+        `INSERT INTO cloud_inbox(dedupKey,payloadDigest,source,profile,payloadJson,availableAt,expiresAt,state,createdAt)
+        VALUES(?,?,?,?,?,?,?,'queued',?) RETURNING *`,
+        input.dedupKey,
+        payloadDigest,
+        input.source,
+        input.profile,
+        guard.guardPayload(JSON.stringify({ text: input.text })),
+        availableAt,
+        expiresAt,
+        now
+      )[0];
+      const event = this.appendEvent({ eventKey: `inbox:${row2.seq}:accepted`, type: "inbox.accepted", ref: String(row2.seq), data: { seq: row2.seq, source: row2.source, profile: row2.profile, availableAt, expiresAt }, createdAt: now }, guard);
+      this.stamp("cloud_inbox", row2.seq, event.seq);
+      await this.rearmAlarm(void 0, now);
+      return { accepted: true, row: this.readInboxItem(row2.seq) };
+    });
+  }
+  /** Selection never skips another profile or a prefix item that exceeds the budget. */
+  selectBatch(now = Date.now(), guard) {
+    return this.storage.transactionSync(() => {
+      const candidates = this.rows("SELECT * FROM cloud_inbox WHERE state='queued' AND availableAt<=? AND expiresAt>? ORDER BY availableAt,seq LIMIT 17", now, now);
+      const selected = [];
+      for (const row2 of candidates) {
+        if (selected.length >= 16 || selected.length && row2.profile !== selected[0].profile) break;
+        if (encoder.encode(composeCloudInput([...selected, row2])).length > CLOUD_CONTEXT_BYTES) {
+          if (!selected.length && guard) this.settleItem(row2, "failed", "CLOUD_INBOX_TOO_LARGE", guard, now);
+          break;
+        }
+        selected.push(row2);
+      }
+      return selected;
+    });
+  }
+  startRun(id, trigger, deadlineAt, guard, now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      this.storage.sql.exec(`INSERT INTO cloud_executions(conversationId,deadlineAt,trigger,requestId,state,startedAt,settlementAck)
+        VALUES(?,?,?,?,?,?,0) ON CONFLICT(conversationId) DO UPDATE SET trigger=excluded.trigger,
+        requestId=excluded.requestId,state=excluded.state,startedAt=excluded.startedAt,settlementAck=0 WHERE cloud_executions.startedAt IS NULL`, id, deadlineAt, trigger, `${trigger}:${id}`, trigger === "wake" ? "starting" : "running", now);
+      if (trigger === "submit") {
+        const event = this.appendEvent({ eventKey: `run:${id}:started`, type: "run.started", conversationId: id, data: { trigger }, createdAt: now }, guard);
+        this.stamp("cloud_executions", id, event.seq);
+      }
+      return this.run(id);
+    });
+  }
+  markRunning(id, guard, now = Date.now()) {
+    this.storage.transactionSync(() => {
+      const row2 = this.run(id);
+      if (!row2 || row2.state !== "starting") return;
+      this.storage.sql.exec("UPDATE cloud_executions SET state='running' WHERE conversationId=?", id);
+      const event = this.appendEvent({ eventKey: `run:${id}:started`, type: "run.started", conversationId: id, data: { trigger: row2.trigger }, createdAt: now }, guard);
+      this.stamp("cloud_executions", id, event.seq);
+    });
+  }
+  recordSubmission(id, submissionId) {
+    this.storage.sql.exec("UPDATE cloud_executions SET submissionId=? WHERE conversationId=?", submissionId, id);
+  }
+  markReservation(id, reservation, guard, now = Date.now(), admission) {
+    this.storage.transactionSync(() => {
+      const row2 = this.run(id);
+      if (!row2 || row2.state !== "starting" && row2.state !== "running") return;
+      if (reservation === "pending" && admission && row2.admissionDigest === null) this.storage.sql.exec(
+        "UPDATE cloud_executions SET admissionDigest=?,admittedSeqs=? WHERE conversationId=? AND admissionDigest IS NULL",
+        admission.digest,
+        JSON.stringify(admission.seqs),
+        id
+      );
+      if (row2.reservation === reservation) return;
+      this.storage.sql.exec("UPDATE cloud_executions SET reservation=? WHERE conversationId=?", reservation, id);
+      if (reservation !== "pending") this.appendEvent({
+        eventKey: `run:${id}:reservation:${reservation}`,
+        type: "run.reservation",
+        conversationId: id,
+        data: { key: row2.requestId, reservation, action: reservation === "released" ? "release" : "reserve" },
+        createdAt: now
+      }, guard);
+    });
+  }
+  captureEligibility(originalStale) {
+    return this.storage.transactionSync(() => {
+      for (const row2 of this.unsettledRuns()) if (row2.eligibilityJson === null) this.storage.sql.exec(
+        "UPDATE cloud_executions SET eligibilityJson=? WHERE conversationId=? AND eligibilityJson IS NULL",
+        JSON.stringify({ steps: row2.steps, aborted: row2.aborted, fatalCode: row2.fatalCode, wasStale: originalStale?.has(row2.conversationId) ?? false }),
+        row2.conversationId
+      );
+      return this.unsettledRuns();
+    });
+  }
+  claim(id, seqs, profile, guard, now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      const run = this.run(id);
+      if (!run || run.state !== "starting") return [];
+      const stopped = run.fatalCode ?? (run.aborted ? "CLOUD_EXECUTION_ABORTED" : now >= run.deadlineAt ? "CLOUD_EXECUTION_TIMEOUT" : void 0);
+      if (stopped) {
+        this.settleRun(id, { state: "interrupted", errorCode: stopped }, guard, now);
+        return [];
+      }
+      const allowed = new Set(seqs);
+      const selected = [];
+      for (const row2 of this.selectBatch(now, guard)) {
+        if (!allowed.has(row2.seq) || row2.profile !== profile) break;
+        selected.push(row2);
+      }
+      const claimed = [];
+      for (const row2 of selected) {
+        if (row2.attempts >= 3) {
+          this.storage.sql.exec("UPDATE cloud_inbox SET attempts=attempts+1 WHERE seq=?", row2.seq);
+          this.settleItem(row2, "failed", "CLOUD_WAKE_EXHAUSTED", guard, now);
+          continue;
+        }
+        this.storage.sql.exec("UPDATE cloud_inbox SET state='running',runId=?,attempts=attempts+1 WHERE seq=? AND state='queued'", id, row2.seq);
+        claimed.push(this.readInboxItem(row2.seq));
+      }
+      if (!claimed.length) {
+        this.settleRun(id, { state: "interrupted", errorCode: "CLOUD_WAKE_EMPTY" }, guard, now);
+        return [];
+      }
+      this.storage.sql.exec("UPDATE cloud_executions SET state='running' WHERE conversationId=?", id);
+      const event = this.appendEvent({ eventKey: `run:${id}:started`, type: "run.started", conversationId: id, data: { trigger: "wake", seqs: claimed.map((row2) => row2.seq) }, createdAt: now }, guard);
+      for (const item of claimed) {
+        this.storage.sql.exec("INSERT INTO cloud_run_turns(runId,seq,claimEvent) VALUES(?,?,?)", id, item.seq, event.seq);
+        this.stamp("cloud_inbox", item.seq, event.seq);
+      }
+      this.stamp("cloud_executions", id, event.seq);
+      return claimed.map((item) => this.readInboxItem(item.seq));
+    });
+  }
+  settleItem(row2, state, code, guard, now) {
+    this.storage.sql.exec("UPDATE cloud_inbox SET state=?,errorCode=?,payloadJson=CASE WHEN inputDurable=1 THEN NULL ELSE payloadJson END,settledAt=? WHERE seq=? AND state IN ('queued','running')", state, code ?? null, now, row2.seq);
+    const event = this.appendEvent({ eventKey: `inbox:${row2.seq}:settled`, type: "inbox.settled", conversationId: row2.runId ?? void 0, ref: String(row2.seq), data: { seq: row2.seq, state, errorCode: code ?? null }, createdAt: now }, guard);
+    this.stamp("cloud_inbox", row2.seq, event.seq);
+  }
+  failQueued(seqs, code, guard, now = Date.now()) {
+    this.storage.transactionSync(() => {
+      for (const seq of seqs) {
+        const row2 = this.readInboxItem(seq);
+        if (row2?.state === "queued") this.settleItem(row2, "failed", code, guard, now);
+      }
+    });
+  }
+  cancelQueued(seq, guard, now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      const row2 = this.readInboxItem(seq);
+      if (row2?.state === "queued") this.settleItem(row2, "cancelled", "CLOUD_EXECUTION_ABORTED", guard, now);
+      return this.readInboxItem(seq);
+    });
+  }
+  expireQueued(guard, now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      const rows = this.rows("SELECT * FROM cloud_inbox WHERE state='queued' AND expiresAt<=? ORDER BY expiresAt,seq LIMIT 100", now);
+      for (const row2 of rows) this.settleItem(row2, "expired", "CLOUD_INBOX_EXPIRED", guard, now);
+      return rows.length;
+    });
+  }
+  settleRun(id, outcome, guard, now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      const row2 = this.run(id);
+      if (!row2 || row2.state !== "starting" && row2.state !== "running") return row2;
+      const items = this.rows("SELECT * FROM cloud_inbox WHERE runId=? AND state='running' ORDER BY seq", id);
+      for (const item of items) {
+        if (outcome.requeue && item.expiresAt > now) this.storage.sql.exec("UPDATE cloud_inbox SET state='queued',runId=NULL,inputDurable=0 WHERE seq=? AND state='running'", item.seq);
+        else {
+          const expiredRequeue = outcome.requeue && item.expiresAt <= now;
+          this.settleItem(
+            item,
+            expiredRequeue ? "expired" : outcome.state === "completed" ? "done" : outcome.state === "failed" ? "failed" : "interrupted",
+            expiredRequeue ? "CLOUD_INBOX_EXPIRED" : outcome.errorCode,
+            guard,
+            now
+          );
+        }
+      }
+      if (row2.reservation === "pending" || row2.reservation === "held") {
+        this.storage.sql.exec("UPDATE cloud_executions SET reservation='released' WHERE conversationId=?", id);
+        this.appendEvent({ eventKey: `run:${id}:reservation:released`, type: "run.reservation", conversationId: id, data: { key: row2.requestId, reservation: "released", action: "release" }, createdAt: now }, guard);
+      }
+      this.storage.sql.exec("UPDATE cloud_executions SET state=?,errorCode=?,settledAt=?,settlementAck=0 WHERE conversationId=?", outcome.state, outcome.errorCode ?? null, now, id);
+      const data = { state: outcome.state, errorCode: outcome.errorCode ?? null, seqs: items.map((item) => item.seq) };
+      if (outcome.requeue) data.requeued = items.filter((item) => item.expiresAt > now).map((item) => item.seq);
+      if (outcome.entryId !== void 0) data.entryId = outcome.entryId;
+      if (outcome.state === "completed" && outcome.text !== void 0) {
+        try {
+          guard.guardText(outcome.text);
+          data.text = outcome.text;
+        } catch {
+          data.errorCode = "CLOUD_MODEL_RESPONSE_REJECTED";
+        }
+        if (encoder.encode(JSON.stringify(data)).length > 65536) {
+          data.text = utf8Prefix(outcome.text, 1024);
+          data.truncated = true;
+        }
+      }
+      const event = this.appendEvent({ eventKey: `run:${id}:settled`, type: `run.${outcome.state}`, conversationId: id, data, createdAt: now }, guard);
+      for (const item of items) if (outcome.requeue && item.expiresAt > now) {
+        this.storage.sql.exec("UPDATE cloud_run_turns SET releaseEvent=? WHERE runId=? AND seq=? AND releaseEvent IS NULL", event.seq, id, item.seq);
+        this.stamp("cloud_inbox", item.seq, event.seq);
+      }
+      this.stamp("cloud_executions", id, event.seq);
+      return this.run(id);
+    });
+  }
+  /** The caller must wrap this and its state write in one transaction. */
+  appendEvent(event, guard) {
+    guard.guardText(event.eventKey);
+    guard.guardText(event.type);
+    if (event.ref !== void 0) guard.guardText(event.ref);
+    const dataJson = guard.guardPayload(JSON.stringify(event.data));
+    if (encoder.encode(dataJson).length > 65536) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const previous = this.rows("SELECT * FROM cloud_events WHERE eventKey=?", event.eventKey)[0];
+    if (previous) {
+      if (previous.type !== event.type || previous.conversationId !== (event.conversationId ?? null) || previous.ref !== (event.ref ?? null) || previous.dataJson !== dataJson) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      return previous;
+    }
+    const count = this.rows("SELECT COUNT(*) AS count FROM cloud_events")[0].count;
+    if (count >= 1e4) this.trimPrefix(count - 9500);
+    const row2 = this.rows(`INSERT INTO cloud_events(eventKey,type,conversationId,ref,dataJson,createdAt)
+      VALUES(?,?,?,?,?,?) RETURNING *`, event.eventKey, event.type, event.conversationId ?? null, event.ref ?? null, dataJson, event.createdAt ?? Date.now())[0];
+    this.storage.sql.exec("UPDATE cloud_event_meta SET highWater=? WHERE singleton=1", row2.seq);
+    return row2;
+  }
+  eventMeta() {
+    return this.rows("SELECT trimmedThrough,highWater FROM cloud_event_meta WHERE singleton=1")[0];
+  }
+  eventPage(after, limit = 100) {
+    return this.storage.transactionSync(() => {
+      const meta = this.eventMeta();
+      if (!Number.isSafeInteger(after) || after < 0 || after !== 0 && after < meta.trimmedThrough || after > meta.highWater) throw new CloudDoError("CLOUD_EVENT_CURSOR_EXPIRED");
+      return this.rows("SELECT * FROM cloud_events WHERE seq>? ORDER BY seq LIMIT ?", after === 0 ? meta.trimmedThrough : after, this.pageLimit(limit));
+    });
+  }
+  pageLimit(value = 100) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > 100) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    return value;
+  }
+  /** Capture ownership and payloads before any asynchronous pi context read. */
+  planTranscript(after, limit) {
+    return this.storage.transactionSync(() => {
+      const highWater = this.eventMeta().highWater;
+      if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      if (after !== void 0) {
+        if (!after || typeof after !== "object" || Array.isArray(after) || Object.keys(after).length !== 3 || !["horizon", "run", "item"].every((key) => Object.hasOwn(after, key)) || !Number.isSafeInteger(after.horizon) || after.horizon < 0 || after.horizon > highWater || [after.run, after.item].some((value) => value !== null && (!Number.isSafeInteger(value) || value <= 0))) {
+          throw new CloudDoError("CLOUD_REQUEST_INVALID");
+        }
+      }
+      const horizon = after?.horizon ?? highWater;
+      const runRows = after?.run === null ? [] : this.rows(
+        "SELECT * FROM cloud_executions WHERE conversationId<? ORDER BY conversationId DESC LIMIT ?",
+        after?.run ?? Number.MAX_SAFE_INTEGER,
+        limit
+      );
+      const runs = runRows.map((run) => {
+        const memberships = this.rows(`SELECT seq FROM cloud_run_turns WHERE runId=?
+          AND (claimEvent IS NULL OR claimEvent<=?) AND (releaseEvent IS NULL OR releaseEvent>?) ORDER BY seq`, run.conversationId, horizon, horizon);
+        const turns = memberships.map(({ seq }) => {
+          const inbox = this.readInboxItem(seq);
+          const current = inbox ? inbox.runId : this.rows(`SELECT runId FROM cloud_run_turns
+            WHERE seq=? AND claimEvent IS NOT NULL AND releaseEvent IS NULL ORDER BY runId DESC LIMIT 1`, seq)[0]?.runId ?? null;
+          return {
+            seq,
+            runId: current,
+            state: inbox?.state ?? null,
+            errorCode: inbox?.errorCode ?? null,
+            revision: inbox?.revision ?? null,
+            text: payloadText(inbox)
+          };
+        });
+        const invocations = this.invocationRowsForRun(run.conversationId).map((row2) => ({
+          invocationId: row2.invocationId,
+          toolName: row2.toolName,
+          state: row2.state,
+          errorCode: row2.errorCode,
+          revision: row2.state === "accepted" || row2.state === "running" ? null : row2.settledEventSeq
+        }));
+        return { run, turns, invocations };
+      });
+      const itemRows = after?.item === null ? [] : this.rows(`SELECT i.* FROM cloud_inbox i WHERE i.seq<?
+        AND NOT EXISTS(SELECT 1 FROM cloud_run_turns t WHERE t.seq=i.seq
+          AND (t.claimEvent IS NULL OR t.claimEvent<=?) AND (t.releaseEvent IS NULL OR t.releaseEvent>?))
+        ORDER BY i.seq DESC LIMIT ?`, after?.item ?? Number.MAX_SAFE_INTEGER, horizon, horizon, limit);
+      const items = itemRows.map((row2) => ({
+        seq: row2.seq,
+        dedupKey: row2.dedupKey,
+        state: row2.state,
+        errorCode: row2.errorCode,
+        runId: row2.runId,
+        attempts: row2.attempts,
+        revision: row2.revision,
+        text: payloadText(row2)
+      }));
+      return { runs, items, next: {
+        horizon,
+        run: runRows.length < limit ? null : runRows.at(-1).conversationId,
+        item: itemRows.length < limit ? null : itemRows.at(-1).seq
+      } };
+    });
+  }
+  readRun(id) {
+    return this.run(id);
+  }
+  readRuns(options = {}) {
+    return this.rows(`SELECT * FROM cloud_executions WHERE ${terminalRun} AND conversationId<? ORDER BY conversationId DESC LIMIT ?`, this.pageAfter(options.after), this.pageLimit(options.limit));
+  }
+  readInbox(options = {}) {
+    return this.rows(`SELECT * FROM cloud_inbox WHERE ${terminalInbox} AND seq<? ORDER BY seq DESC LIMIT ?`, this.pageAfter(options.after), this.pageLimit(options.limit)).map((row2) => ({ ...row2, payloadJson: null }));
+  }
+  readInvocations(options = {}) {
+    return this.rows(`SELECT seq,invocationId,toolName,state,errorCode FROM cloud_invocations WHERE ${terminalInvocation} AND seq<? ORDER BY seq DESC LIMIT ?`, this.pageAfter(options.after), this.pageLimit(options.limit));
+  }
+  pageAfter(after) {
+    if (after !== void 0 && (!Number.isSafeInteger(after) || after < 0)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    return after ?? Number.MAX_SAFE_INTEGER;
+  }
+  snapshot() {
+    return this.storage.transactionSync(() => {
+      const inbox = [...this.rows("SELECT * FROM cloud_inbox WHERE state IN ('queued','running') ORDER BY seq"), ...this.readInbox()].map((row2) => ({ ...row2, payloadJson: null }));
+      const runs = [...this.unsettledRuns(), ...this.readRuns()];
+      const invocations = [...this.rows("SELECT seq,invocationId,toolName,state,errorCode FROM cloud_invocations WHERE state IN ('accepted','running') ORDER BY seq"), ...this.readInvocations()];
+      return { ...this.eventMeta(), inbox, runs, invocations };
+    });
+  }
+  setDelivery(id, state, taskId, entryId, guard, now = Date.now()) {
+    const row2 = this.rows("SELECT * FROM cloud_invocations WHERE invocationId=?", id)[0];
+    if (!row2 || row2.deliveredState === state && row2.taskId === taskId && row2.resultEntryId === entryId) return;
+    this.storage.sql.exec("UPDATE cloud_invocations SET deliveredState=?,taskId=?,resultEntryId=? WHERE invocationId=?", state, taskId, entryId, id);
+    this.appendEvent({
+      eventKey: `tool:${id}:delivered:${state}:${taskId ?? ""}:${entryId ?? ""}`,
+      type: "tool.delivered",
+      conversationId: row2.conversationId,
+      ref: id,
+      data: { invocationId: id, deliveredState: state, taskId, resultEntryId: entryId },
+      createdAt: now
+    }, guard);
+  }
+  projectInvocation(row2, project, guard, now = Date.now()) {
+    if (!project) return;
+    let admitted;
+    try {
+      const value = project(Object.freeze({ ...row2 }));
+      if (value === void 0) return;
+      const key = value.key;
+      const rawDataJson = value.dataJson;
+      if (typeof key !== "string" || !key.length || key.length > 128 || /[\u0000-\u001f\u007f-\u009f]/u.test(key) || typeof rawDataJson !== "string") throw new Error();
+      if (rawDataJson.length > 16384 || encoder.encode(rawDataJson).byteLength > 16384) throw new Error();
+      guard.guardText(key);
+      const dataJson = guard.guardPayload(rawDataJson);
+      if (encoder.encode(dataJson).length > 16384) throw new Error();
+      admitted = { key: `projection:${row2.invocationId}:${key}`, dataJson, digest: sha256(dataJson) };
+    } catch {
+      this.projectionFailed(row2, guard, now);
+      return;
+    }
+    const previous = this.rows("SELECT invocationId,state,payloadDigest FROM cloud_projections WHERE key=?", admitted.key)[0];
+    if (previous) {
+      if (previous.invocationId !== row2.invocationId || previous.state !== row2.state || previous.payloadDigest !== admitted.digest) this.projectionFailed(row2, guard, now);
+      return;
+    }
+    this.storage.sql.exec("INSERT INTO cloud_projections(key,invocationId,state,payloadDigest,dataJson,createdAt) VALUES(?,?,?,?,?,?)", admitted.key, row2.invocationId, row2.state, admitted.digest, admitted.dataJson, now);
+    this.appendEvent({
+      eventKey: admitted.key,
+      type: "projection",
+      conversationId: row2.conversationId,
+      ref: row2.invocationId,
+      data: { key: admitted.key, invocationId: row2.invocationId, data: JSON.parse(admitted.dataJson) },
+      createdAt: now
+    }, guard);
+  }
+  projectionFailed(row2, guard, now) {
+    const key = `sdk:${row2.invocationId}:projection-failed`;
+    const existing = this.rows("SELECT key FROM cloud_projections WHERE key=?", key)[0];
+    if (existing) return;
+    const dataJson = '{"code":"CLOUD_PROJECTION_FAILED"}';
+    this.storage.sql.exec("INSERT INTO cloud_projections(key,invocationId,state,payloadDigest,dataJson,errorCode,createdAt) VALUES(?,?,?,?,?,?,?)", key, row2.invocationId, row2.state, sha256(dataJson), dataJson, "CLOUD_PROJECTION_FAILED", now);
+    this.appendEvent({ eventKey: key, type: "projection.failed", conversationId: row2.conversationId, ref: row2.invocationId, data: { invocationId: row2.invocationId, code: "CLOUD_PROJECTION_FAILED" }, createdAt: now }, guard);
+  }
+  trimPrefix(count) {
+    const rows = this.rows("SELECT seq FROM cloud_events ORDER BY seq LIMIT ?", count);
+    if (!rows.length) return 0;
+    const through = rows.at(-1).seq;
+    this.storage.sql.exec("DELETE FROM cloud_events WHERE seq<=?", through);
+    this.storage.sql.exec("UPDATE cloud_event_meta SET trimmedThrough=MAX(trimmedThrough,?) WHERE singleton=1", through);
+    return rows.length;
+  }
+  retention(now = Date.now()) {
+    return this.storage.transactionSync(() => {
+      const head = this.rows("SELECT seq,createdAt FROM cloud_events ORDER BY seq LIMIT 500");
+      let count = 0;
+      for (const row2 of head) {
+        if (row2.createdAt + RETENTION > now) break;
+        count++;
+      }
+      const events = this.trimPrefix(count);
+      const expired = this.rows(`SELECT seq FROM cloud_inbox WHERE ${terminalInbox} AND settledAt<=? ORDER BY seq LIMIT 500`, now - RETENTION);
+      for (const row2 of expired) this.storage.sql.exec("DELETE FROM cloud_inbox WHERE seq=?", row2.seq);
+      return { events, inbox: expired.length };
+    });
+  }
+  setSchedulingState(options) {
+    if (options.busy !== void 0) this.scheduling.busy = options.busy;
+    if (options.repairRetrying !== void 0) this.scheduling.repairRetrying = options.repairRetrying;
+  }
+  nextAlarm(now = Date.now(), busy = this.scheduling.busy ?? false) {
+    const targets = [];
+    const queued = this.rows("SELECT availableAt,expiresAt FROM cloud_inbox WHERE state='queued'");
+    for (const row2 of queued) {
+      if (!busy || row2.availableAt > now) targets.push(Math.max(now, row2.availableAt));
+      targets.push(Math.max(now, row2.expiresAt));
+    }
+    if (!busy && (this.unsettledRuns().length || this.unackedRuns().length)) targets.push(now);
+    const head = this.rows("SELECT createdAt FROM cloud_events ORDER BY seq LIMIT 1")[0];
+    if (head) targets.push(Math.max(now, head.createdAt + RETENTION));
+    const settled = this.rows(`SELECT settledAt FROM cloud_inbox WHERE ${terminalInbox} AND settledAt IS NOT NULL ORDER BY settledAt LIMIT 1`)[0];
+    if (settled) targets.push(Math.max(now, settled.settledAt + RETENTION));
+    return targets.length ? Math.min(...targets) : null;
+  }
+  /** This is the only alarm mutation path. Async enqueue calls it inside its storage transaction. */
+  async rearmAlarm(options, now = Date.now()) {
+    if (options) this.setSchedulingState(options);
+    const target = this.nextAlarm(now);
+    if (this.scheduling.repairRetrying) {
+      this.storage.sql.exec("UPDATE cloud_event_meta SET pendingMaintenanceAt=? WHERE singleton=1", target);
+      return;
+    }
+    this.storage.sql.exec("UPDATE cloud_event_meta SET pendingMaintenanceAt=NULL WHERE singleton=1");
+    if (target === null) await this.storage.deleteAlarm();
+    else await this.storage.setAlarm(target);
+  }
+};
+
+// src/provider-fetch.ts
+var FRAME_LIMIT = 65536;
+var TOOL_ARGUMENT_LIMIT = 65536;
+var TOOL_CALL_LIMIT = 12;
+var ToolCallAssembly = class {
+  constructor(key, config) {
+    this.key = key;
+    this.config = config;
+  }
+  key;
+  config;
+  calls = /* @__PURE__ */ new Map();
+  argumentBytes = 0;
+  encoder = new TextEncoder();
+  reject() {
+    throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+  }
+  checkString(value) {
+    if (hasUserKeyShape(value)) this.reject();
+    const guard = new RollingLeakGuard(this.key);
+    guard.push(value);
+    guard.finish();
+  }
+  checkValues(value) {
+    const pending = [value];
+    while (pending.length) {
+      const next = pending.pop();
+      if (typeof next === "string") this.checkString(next);
+      else if (Array.isArray(next)) pending.push(...next);
+      else if (object(next)) {
+        for (const [name, child] of Object.entries(next)) {
+          this.checkString(name);
+          pending.push(child);
+        }
+      }
+    }
+  }
+  add(value) {
+    if (!this.config || !Array.isArray(value) || value.length > TOOL_CALL_LIMIT) this.reject();
+    const indices = /* @__PURE__ */ new Set();
+    for (const item of value) {
+      const row2 = object(item);
+      if (!row2 || !Number.isSafeInteger(row2.index) || row2.index < 0 || row2.index >= TOOL_CALL_LIMIT) this.reject();
+      const index = row2.index;
+      if (indices.has(index)) this.reject();
+      indices.add(index);
+      const call = this.calls.get(index) ?? { arguments: "" };
+      if (!this.calls.has(index)) this.calls.set(index, call);
+      if (row2.id != null) {
+        if (call.id !== void 0 || typeof row2.id !== "string" || !row2.id || row2.id.length > 512) this.reject();
+        this.checkString(row2.id);
+        call.id = row2.id;
+      }
+      if (row2.type != null) {
+        if (call.type !== void 0 || row2.type !== "function") this.reject();
+        call.type = "function";
+      }
+      if (row2.function != null) {
+        const fn = object(row2.function);
+        if (!fn) this.reject();
+        if (fn.name != null) {
+          if (call.name !== void 0 || typeof fn.name !== "string" || !this.config.offeredToolNames.includes(fn.name)) this.reject();
+          this.checkString(fn.name);
+          call.name = fn.name;
+        }
+        if (fn.arguments != null) {
+          if (typeof fn.arguments !== "string") this.reject();
+          this.argumentBytes += this.encoder.encode(fn.arguments).byteLength;
+          if (this.argumentBytes > TOOL_ARGUMENT_LIMIT) this.reject();
+          call.arguments += fn.arguments;
+        }
+      }
+    }
+  }
+  get size() {
+    return this.calls.size;
+  }
+  async finish() {
+    const checked = [];
+    const ids = /* @__PURE__ */ new Set();
+    const ordered = [...this.calls].sort(([left], [right]) => left - right);
+    for (const [index, call] of ordered) {
+      if (index !== checked.length || !call.id || !call.name || call.type !== "function" || ids.has(call.id)) this.reject();
+      ids.add(call.id);
+      let parsed;
+      try {
+        parsed = JSON.parse(call.arguments);
+      } catch {
+        this.reject();
+      }
+      const args = object(parsed);
+      if (!args) this.reject();
+      this.checkValues(args);
+      checked.push({ index, call, args });
+    }
+    for (const { call, args } of checked) await this.config.admitToolCall(call.name, call.id, args);
+    return checked.map(({ index, call, args }) => ({
+      index,
+      id: `call_${index + 1}`,
+      type: "function",
+      function: { name: call.name, arguments: JSON.stringify(args) }
+    }));
+  }
+};
+var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+async function* frames(reader) {
+  const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+  let frame = "";
+  let line = "";
+  let lastWasCR = false;
+  while (true) {
+    const next = await reader.read();
+    const text2 = next.done ? decoder.decode() : decoder.decode(next.value, { stream: true });
+    for (const character of text2) {
+      if (character === "\n" && lastWasCR) {
+        lastWasCR = false;
+        continue;
+      }
+      lastWasCR = character === "\r";
+      if (character === "\n" || character === "\r") {
+        if (!line) {
+          if (frame) yield frame;
+          frame = "";
+        } else {
+          frame += `${line}
+`;
+          line = "";
+        }
+      } else line += character;
+      if (frame.length + line.length > FRAME_LIMIT) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+    }
+    if (next.done) {
+      if (line || frame) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+      return;
+    }
+  }
+}
+function eventData(frame) {
+  return frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+}
+async function* readSseData(body) {
+  const reader = body.getReader();
+  try {
+    for await (const frame of frames(reader)) {
+      const data = eventData(frame);
+      if (data) yield data;
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
+    }
+  }
+}
+function numericUsage(value) {
+  const usage = object(value);
+  if (!usage) return void 0;
+  const result = {};
+  for (const field of ["prompt_tokens", "completion_tokens", "total_tokens"]) {
+    const n = usage[field];
+    if (typeof n === "number" && Number.isSafeInteger(n) && n >= 0) result[field] = n;
+  }
+  return Object.keys(result).length ? result : void 0;
+}
+function guardedBody(body, key, profile, abort, cleanup, transport) {
+  const reader = body.getReader();
+  const guard = new RollingLeakGuard(key);
+  const laneGuards = { content: new RollingLeakGuard(key), reasoning_content: new RollingLeakGuard(key) };
+  const segments = [];
+  const encoder2 = new TextEncoder();
+  let finishReason;
+  const tools = new ToolCallAssembly(key, transport);
+  let usage;
+  const encode = (delta, finish = null) => `data: ${JSON.stringify({
+    id: "cloud",
+    object: "chat.completion.chunk",
+    created: 0,
+    model: profile.model,
+    choices: [{ index: 0, delta, finish_reason: finish }]
+  })}
+
+`;
+  const release = (text2) => {
+    let remaining = text2.length;
+    let result = "";
+    while (remaining > 0) {
+      const first = segments[0];
+      const size = Math.min(first.text.length, remaining);
+      result += encode({ [first.lane]: first.text.slice(0, size) });
+      first.text = first.text.slice(size);
+      remaining -= size;
+      if (!first.text) segments.shift();
+    }
+    return result;
+  };
+  const stop = async () => {
+    guard.discard();
+    laneGuards.content.discard();
+    laneGuards.reasoning_content.discard();
+    segments.length = 0;
+    try {
+      await reader.cancel();
+    } catch {
+    } finally {
+      abort.abort();
+      cleanup();
+    }
+  };
+  const checkedLane = (lane, text2) => {
+    if (!text2) return "";
+    const previous = segments.at(-1);
+    if (previous?.lane === lane) previous.text += text2;
+    else segments.push({ lane, text: text2 });
+    return release(guard.push(text2));
+  };
+  async function* output() {
+    let done = false;
+    try {
+      for await (const frame of frames(reader)) {
+        const data = eventData(frame);
+        if (!data) continue;
+        if (data === "[DONE]") {
+          done = true;
+          break;
+        }
+        const payload = object(JSON.parse(data));
+        if (!payload || payload.error) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+        const currentUsage = numericUsage(payload.usage);
+        if (currentUsage) {
+          for (const [field, value] of Object.entries(currentUsage)) {
+            if (usage?.[field] !== void 0 && value < usage[field]) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+          }
+          usage = { ...usage, ...currentUsage };
+          transport?.onUsage?.(usage);
+        }
+        if (!Array.isArray(payload.choices)) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+        const choice = payload.choices.find((item) => object(item)?.index === 0);
+        if (!choice) continue;
+        const row2 = object(choice);
+        const delta = object(row2.delta);
+        if (!delta || delta.function_call || delta.refusal) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+        if (finishReason && (delta.tool_calls != null || delta.content || delta.reasoning_content)) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+        if (delta.tool_calls != null) tools.add(delta.tool_calls);
+        for (const lane of ["content", "reasoning_content"]) {
+          const text2 = delta[lane];
+          if (text2 === void 0 || text2 === null) continue;
+          if (typeof text2 !== "string") throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+          if (!text2) continue;
+          const safe = checkedLane(lane, laneGuards[lane].push(text2));
+          if (safe) yield safe;
+        }
+        if (row2.finish_reason != null) {
+          if (finishReason || !["stop", "length", "content_filter", "tool_calls"].includes(String(row2.finish_reason))) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+          finishReason = row2.finish_reason;
+        }
+      }
+      if (!done && !finishReason) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+      if (tools.size > 0 !== (finishReason === "tool_calls")) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+      const checkedTools = tools.size ? await tools.finish() : [];
+      const terminal2 = encode(checkedTools.length ? { tool_calls: checkedTools } : {}, finishReason ?? "stop");
+      if (terminal2.length > FRAME_LIMIT) throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+      for (const lane of ["content", "reasoning_content"]) {
+        const safe = checkedLane(lane, laneGuards[lane].finish());
+        if (safe) yield safe;
+      }
+      const final = release(guard.finish());
+      if (final) yield final;
+      yield terminal2;
+      if (usage) yield `data: ${JSON.stringify({ choices: [], usage })}
+
+`;
+      yield "data: [DONE]\n\n";
+    } catch (error) {
+      throw safeCloudError(error);
+    } finally {
+      await stop();
+    }
+  }
+  const iterator = output();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (next.done) controller.close();
+        else controller.enqueue(encoder2.encode(next.value));
+      } catch (error) {
+        controller.error(safeCloudError(error));
+      }
+    },
+    async cancel() {
+      await stop();
+      await iterator.return(void 0);
+    }
+  });
+}
+function createProviderFetch(profile, secret, fetchImpl = globalThis.fetch, transport) {
+  const key = requirePlatformKey(secret);
+  const endpoint = `${profile.baseUrl.replace(/\/$/, "")}/chat/completions`;
+  return async (input, init) => {
+    let request;
+    try {
+      request = new Request(input, init);
+    } catch {
+      throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    }
+    if (request.url !== endpoint || request.method !== "POST") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const abort = new AbortController();
+    const onAbort = () => abort.abort();
+    request.signal.addEventListener("abort", onAbort, { once: true });
+    if (request.signal.aborted) abort.abort();
+    const cleanup = () => request.signal.removeEventListener("abort", onAbort);
+    try {
+      const dispatch = new Request(request, {
+        signal: abort.signal,
+        redirect: "manual",
+        headers: { authorization: `Bearer ${key}`, "content-type": "application/json", accept: "text/event-stream" }
+      });
+      if (abort.signal.aborted) throw new CloudDoError("CLOUD_MODEL_REQUEST_FAILED");
+      transport?.onSend?.();
+      const response = await fetchImpl(dispatch);
+      if (!response.ok || response.status >= 300 && response.status < 400 || !response.body || !response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream")) {
+        abort.abort();
+        cleanup();
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        throw new CloudDoError("CLOUD_MODEL_REQUEST_FAILED");
+      }
+      return new Response(guardedBody(response.body, key, profile, abort, cleanup, transport), { headers: { "content-type": "text/event-stream" } });
+    } catch (error) {
+      abort.abort();
+      cleanup();
+      throw safeCloudError(error);
+    }
+  };
+}
+
+// src/platform-provider.ts
+var PLATFORM_MAX_OUTPUT_TOKENS = 4096;
+var REQUEST_FRAMING_BYTES = 4096;
+function emptyAssistant(model) {
+  return {
+    role: "assistant",
+    content: [],
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+    stopReason: "stop",
+    timestamp: Date.now()
+  };
+}
+function fixedModelErrors(source, model) {
+  const events = new AssistantMessageEventStream();
+  const run = async () => {
+    let terminal2;
+    try {
+      for await (const event of source) {
+        if (event.type === "error") {
+          const message = event.error.errorMessage;
+          const code = message?.includes("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE") ? "CLOUD_MODEL_CREDENTIAL_UNAVAILABLE" : safeCloudError(new Error(message)).code;
+          terminal2 = {
+            ...emptyAssistant(model),
+            content: event.error.content,
+            usage: event.error.usage,
+            stopReason: event.reason,
+            errorMessage: code
+          };
+          events.push({ type: "error", reason: event.reason, error: terminal2 });
+        } else {
+          if (event.type === "done") terminal2 = event.message;
+          events.push(event);
+        }
+      }
+      if (!terminal2) throw new CloudDoError("CLOUD_MODEL_REQUEST_FAILED");
+    } catch {
+      terminal2 = { ...emptyAssistant(model), stopReason: "error", errorMessage: "CLOUD_MODEL_REQUEST_FAILED" };
+      events.push({ type: "error", reason: "error", error: terminal2 });
+    } finally {
+      events.end(terminal2);
+    }
+  };
+  void run();
+  return events;
+}
+function messages(context) {
+  return context.messages.map((message) => {
+    if (message.role === "system") return { role: "system", content: getSystemMessageText(message) };
+    if (message.role === "toolResult") return {
+      role: "tool",
+      tool_call_id: message.toolCallId,
+      content: message.content.map((block) => {
+        if (block.type !== "text") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+        return block.text;
+      }).join("")
+    };
+    if (message.role !== "user" && message.role !== "assistant") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const calls = [];
+    const content = typeof message.content === "string" ? message.content : message.content.map((block) => {
+      if (block.type === "toolCall" && message.role === "assistant") {
+        calls.push({ id: block.id, type: "function", function: { name: block.name, arguments: JSON.stringify(block.arguments) } });
+        return "";
+      }
+      if (block.type !== "text" && block.type !== "thinking") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      return block.type === "text" ? block.text : "";
+    }).join("");
+    return { role: message.role, content, ...calls.length ? { tool_calls: calls } : {} };
+  });
+}
+function stream(profile, model, context, options, runtime) {
+  const events = new AssistantMessageEventStream();
+  const output = emptyAssistant(model);
+  const blocks = /* @__PURE__ */ new Map();
+  const run = async () => {
+    try {
+      const currentTools = getCurrentTools(context.messages);
+      const body = JSON.stringify({
+        model: profile.model,
+        messages: messages(context),
+        stream: true,
+        stream_options: { include_usage: true },
+        max_tokens: PLATFORM_MAX_OUTPUT_TOKENS,
+        ...currentTools.length ? { tools: currentTools.map((tool) => ({
+          type: "function",
+          function: { name: tool.name, description: tool.description, parameters: tool.parameters }
+        })) } : {}
+      });
+      const account = await runtime?.beforeRequest({ inputBytes: new TextEncoder().encode(body).byteLength });
+      const key = requirePlatformKey(options?.apiKey);
+      const request = createProviderFetch(profile, key, globalThis.fetch, {
+        offeredToolNames: currentTools.map((tool) => tool.name),
+        admitToolCall: (name, id, args) => runtime?.admitToolCall(name, id, args),
+        onSend: () => account?.sent(),
+        onUsage: (usage) => account?.usage({ input: usage.prompt_tokens, output: usage.completion_tokens })
+      });
+      const response = await request(`${profile.baseUrl}/chat/completions`, {
+        method: "POST",
+        signal: runtime?.requestSignal?.(options?.signal) ?? options?.signal,
+        body
+      });
+      events.push({ type: "start", partial: output });
+      for await (const data of readSseData(response.body)) {
+        if (data === "[DONE]") break;
+        const frame = JSON.parse(data);
+        if (frame.usage) {
+          output.usage.input = frame.usage.prompt_tokens ?? 0;
+          output.usage.output = frame.usage.completion_tokens ?? 0;
+          output.usage.totalTokens = frame.usage.total_tokens ?? output.usage.input + output.usage.output;
+        }
+        for (const choice of frame.choices) {
+          if (choice.finish_reason === "length") output.stopReason = "length";
+          if (choice.finish_reason === "tool_calls") output.stopReason = "toolUse";
+          for (const call of choice.delta.tool_calls ?? []) {
+            const index = output.content.length;
+            const toolCall = {
+              type: "toolCall",
+              id: call.id,
+              name: call.function.name,
+              arguments: JSON.parse(call.function.arguments)
+            };
+            output.content.push(toolCall);
+            events.push({ type: "toolcall_start", contentIndex: index, partial: output });
+            events.push({ type: "toolcall_delta", contentIndex: index, delta: call.function.arguments, partial: output });
+            events.push({ type: "toolcall_end", contentIndex: index, toolCall, partial: output });
+          }
+          for (const lane of ["content", "reasoning_content"]) {
+            const delta = choice.delta[lane];
+            if (!delta) continue;
+            let index = blocks.get(lane);
+            if (index === void 0) {
+              index = output.content.length;
+              blocks.set(lane, index);
+              output.content.push(lane === "content" ? { type: "text", text: "" } : { type: "thinking", thinking: "" });
+              events.push({ type: lane === "content" ? "text_start" : "thinking_start", contentIndex: index, partial: output });
+            }
+            const block = output.content[index];
+            if (block.type === "text") block.text += delta;
+            else if (block.type === "thinking") block.thinking += delta;
+            events.push({ type: lane === "content" ? "text_delta" : "thinking_delta", contentIndex: index, delta, partial: output });
+          }
+        }
+      }
+      for (const [lane, index] of blocks) {
+        const block = output.content[index];
+        events.push({
+          type: lane === "content" ? "text_end" : "thinking_end",
+          contentIndex: index,
+          content: block.type === "text" ? block.text : block.type === "thinking" ? block.thinking : "",
+          partial: output
+        });
+      }
+      events.push({ type: "done", reason: output.stopReason, message: output });
+    } catch (error) {
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage = safeCloudError(error).code;
+      events.push({ type: "error", reason: output.stopReason, error: output });
+    } finally {
+      events.end(output);
+    }
+  };
+  void run();
+  return events;
+}
+function createPlatformModels(env, credentials2 = platformCredentialReader(env), runtime) {
+  const models = createModels({ authContext: { env: async () => void 0, fileExists: async () => false } });
+  for (const [id, profile] of Object.entries(PLATFORM_PROFILES)) {
+    const implementation = {
+      stream: (model2, context, options) => stream(profile, model2, context, options, runtime),
+      streamSimple: (model2, context, options) => stream(profile, model2, context, options, runtime)
+    };
+    const model = {
+      id: profile.model,
+      name: profile.model,
+      provider: id,
+      api: "openai-completions",
+      baseUrl: profile.baseUrl,
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 65536,
+      maxTokens: PLATFORM_MAX_OUTPUT_TOKENS
+    };
+    models.setProvider(createProvider({
+      id,
+      models: [model],
+      api: implementation,
+      auth: { apiKey: { name: "Platform model key", resolve: async () => {
+        try {
+          const key = requirePlatformKey(await credentials2.get(profile.secretName));
+          return { auth: { apiKey: key }, source: "platform" };
+        } catch {
+          throw new CloudDoError("CLOUD_MODEL_CREDENTIAL_UNAVAILABLE");
+        }
+      } } }
+    }));
+  }
+  const rawStream = models.stream.bind(models);
+  const rawSimple = models.streamSimple.bind(models);
+  models.stream = (model, context, options) => fixedModelErrors(rawStream(model, context, options), model);
+  models.streamSimple = (model, context, options) => fixedModelErrors(rawSimple(model, context, options), model);
+  return models;
+}
+
+// src/invocation-ledger.ts
+var terminal = (state) => state !== "accepted" && state !== "running";
+var fatalCodes = /* @__PURE__ */ new Set([
+  "CLOUD_TOOL_RESULT_LIMIT",
+  "CLOUD_TOOL_LIMIT",
+  "CLOUD_STEP_LIMIT",
+  "CLOUD_TOOL_TIMEOUT",
+  "CLOUD_EXECUTION_TIMEOUT"
+]);
+var InvocationLedger = class {
+  constructor(storage, options = {}) {
+    this.storage = storage;
+    this.options = options;
+  }
+  storage;
+  options;
+  /** The host calls this only after credential and identity preflight. */
+  ensureSchema() {
+    this.storage.transactionSync(() => {
+      this.storage.sql.exec(`CREATE TABLE IF NOT EXISTS cloud_invocations (
+        seq INTEGER PRIMARY KEY AUTOINCREMENT,
+        invocationId TEXT NOT NULL UNIQUE, sessionId TEXT NOT NULL,
+        conversationId INTEGER NOT NULL, assistantEntryId INTEGER NOT NULL,
+        toolCallId TEXT NOT NULL, toolName TEXT NOT NULL,
+        argsDigest TEXT NOT NULL, argsJson TEXT NOT NULL,
+        replay TEXT NOT NULL CHECK (replay IN ('safe','unsafe')),
+        state TEXT NOT NULL CHECK (state IN ('accepted','running','succeeded','failed','aborted','interrupted','timed_out')),
+        attempt INTEGER NOT NULL, replayCount INTEGER NOT NULL DEFAULT 0,
+        deadlineAt INTEGER NOT NULL, abortRequested INTEGER NOT NULL DEFAULT 0,
+        resultJson TEXT, errorCode TEXT,
+        mode TEXT NOT NULL DEFAULT 'inline' CHECK (mode IN ('inline','job')),
+        segmentStartedAt INTEGER, nextSegmentAt INTEGER, jobStateJson TEXT, progressJson TEXT
+      );
+      CREATE INDEX IF NOT EXISTS cloud_invocations_pending ON cloud_invocations(state,seq);
+      CREATE TABLE IF NOT EXISTS cloud_executions (
+        conversationId INTEGER PRIMARY KEY, deadlineAt INTEGER NOT NULL,
+        steps INTEGER NOT NULL DEFAULT 0, tools INTEGER NOT NULL DEFAULT 0,
+        fatalCode TEXT, aborted INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS cloud_counted_tools (
+        conversationId INTEGER NOT NULL, taskId TEXT NOT NULL,
+        PRIMARY KEY(conversationId,taskId)
+      )`);
+      const columns = new Set(this.storage.sql.exec("PRAGMA table_info(cloud_invocations)").toArray().map((row2) => row2.name));
+      for (const name of ["settledAt", "settledEventSeq"]) {
+        if (!columns.has(name)) this.storage.sql.exec(`ALTER TABLE cloud_invocations ADD COLUMN ${name} INTEGER`);
+      }
+      const executionColumns = new Set(this.storage.sql.exec("PRAGMA table_info(cloud_executions)").toArray().map((row2) => row2.name));
+      for (const name of ["inputTokens", "outputTokens", "credits", "sentRequests"]) {
+        if (!executionColumns.has(name)) this.storage.sql.exec(`ALTER TABLE cloud_executions ADD COLUMN ${name} INTEGER NOT NULL DEFAULT 0`);
+      }
+    });
+  }
+  read(id) {
+    return this.storage.sql.exec("SELECT * FROM cloud_invocations WHERE invocationId = ?", id).toArray()[0];
+  }
+  pending() {
+    return this.storage.sql.exec("SELECT * FROM cloud_invocations WHERE state IN ('accepted','running') ORDER BY seq").toArray();
+  }
+  begin(input, guard) {
+    const begun = this.storage.transactionSync(() => {
+      const previous = this.read(input.invocationId);
+      if (previous) {
+        if (previous.argsDigest !== input.argsDigest || previous.toolName !== input.toolName) {
+          throw new CloudDoError("CLOUD_TOOL_INVOCATION_CONFLICT");
+        }
+        return { kind: terminal(previous.state) ? "settled" : "pending", row: previous };
+      }
+      this.storage.sql.exec(
+        `INSERT INTO cloud_invocations
+        (invocationId,sessionId,conversationId,assistantEntryId,toolCallId,toolName,argsDigest,argsJson,replay,state,attempt,deadlineAt)
+        VALUES (?,?,?,?,?,?,?,?,?,'running',1,?)`,
+        input.invocationId,
+        input.sessionId,
+        input.conversationId,
+        input.assistantEntryId,
+        input.toolCallId,
+        input.toolName,
+        input.argsDigest,
+        input.argsJson,
+        input.replay,
+        input.deadlineAt
+      );
+      const row2 = this.read(input.invocationId);
+      this.options.started?.(row2, guard);
+      return { kind: "started", row: row2 };
+    });
+    if (begun.kind === "started") {
+      try {
+        this.options.startedCommitted?.(begun.row);
+      } catch {
+      }
+    }
+    return begun;
+  }
+  finish(id, state, result, errorCode, now = Date.now(), options = {}) {
+    let changed;
+    const resultRow = this.storage.transactionSync(() => {
+      const row2 = this.read(id);
+      if (!row2 || terminal(row2.state) || options.attempt !== void 0 && options.attempt !== row2.attempt) return row2;
+      const execution = this.execution(row2.conversationId);
+      let settledState = state;
+      let settledError = errorCode ?? null;
+      if (state === "succeeded") {
+        if (row2.abortRequested || options.clientConnected === false || !options.recovery && execution?.aborted) {
+          settledState = "aborted";
+          settledError = "CLOUD_EXECUTION_ABORTED";
+        } else if (now >= row2.deadlineAt || execution && now >= execution.deadlineAt) {
+          settledState = "timed_out";
+          settledError = execution && now >= execution.deadlineAt ? "CLOUD_EXECUTION_TIMEOUT" : "CLOUD_TOOL_TIMEOUT";
+        } else if (!options.recovery && execution?.fatalCode) {
+          settledState = "failed";
+          settledError = execution.fatalCode;
+        }
+      }
+      this.storage.sql.exec(
+        `UPDATE cloud_invocations SET state=?,resultJson=?,errorCode=?
+        WHERE invocationId=? AND attempt=? AND state IN ('accepted','running')`,
+        settledState,
+        settledState === "succeeded" && result !== void 0 ? JSON.stringify(result) : null,
+        settledError,
+        id,
+        row2.attempt
+      );
+      const credits = result?.usage?.credits;
+      if (typeof credits === "number" && Number.isSafeInteger(credits) && credits >= 0) {
+        this.storage.sql.exec("UPDATE cloud_executions SET credits=MIN(credits+?,9007199254740991) WHERE conversationId=?", credits, row2.conversationId);
+        if (options.creditCap !== void 0 && (this.execution(row2.conversationId)?.credits ?? 0) > options.creditCap) {
+          this.failExecution(row2.conversationId, "CLOUD_BUDGET_EXCEEDED");
+        }
+      }
+      if (settledError && fatalCodes.has(settledError)) this.failExecution(row2.conversationId, settledError);
+      changed = this.read(id);
+      changed = this.#terminal(changed, options.recovery === true);
+      return changed;
+    });
+    if (changed) this.#notify(changed);
+    return resultRow;
+  }
+  #terminal(row2, recovery) {
+    const event = this.options.terminal?.(row2, recovery);
+    if (event) {
+      this.storage.sql.exec("UPDATE cloud_invocations SET settledAt=?,settledEventSeq=? WHERE invocationId=?", event.createdAt, event.seq, row2.invocationId);
+    }
+    return this.read(row2.invocationId);
+  }
+  #notify(row2) {
+    try {
+      this.options.committed?.(row2);
+    } catch {
+    }
+  }
+  /** Claim before network replay. A second restart never dispatches a claimed row again. */
+  claimRecovery(now = Date.now()) {
+    const settled = [];
+    const claimed = this.storage.transactionSync(() => {
+      const claimed2 = [];
+      for (const row2 of this.pending()) {
+        const execution = this.execution(row2.conversationId);
+        if (row2.abortRequested || execution?.aborted) {
+          this.storage.sql.exec(`UPDATE cloud_invocations SET state='aborted',resultJson=NULL,errorCode='CLOUD_EXECUTION_ABORTED'
+            WHERE invocationId=? AND state IN ('accepted','running')`, row2.invocationId);
+        } else if (now >= row2.deadlineAt || execution && now >= execution.deadlineAt) {
+          const code = execution && now >= execution.deadlineAt ? "CLOUD_EXECUTION_TIMEOUT" : "CLOUD_TOOL_TIMEOUT";
+          this.storage.sql.exec(`UPDATE cloud_invocations SET state='timed_out',resultJson=NULL,errorCode=?
+            WHERE invocationId=? AND state IN ('accepted','running')`, code, row2.invocationId);
+          this.failExecution(row2.conversationId, code);
+        } else if (row2.replay === "safe" && row2.mode === "inline" && row2.replayCount === 0) {
+          this.storage.sql.exec(`UPDATE cloud_invocations SET replayCount=1,attempt=attempt+1,state='running'
+            WHERE invocationId=? AND replayCount=0 AND state IN ('accepted','running')`, row2.invocationId);
+          claimed2.push(this.read(row2.invocationId));
+        } else {
+          this.storage.sql.exec(
+            `UPDATE cloud_invocations SET state=?,resultJson=NULL,errorCode='CLOUD_EXECUTION_INTERRUPTED'
+            WHERE invocationId=? AND state IN ('accepted','running')`,
+            row2.replayCount >= 1 ? "failed" : "interrupted",
+            row2.invocationId
+          );
+        }
+        const updated = this.read(row2.invocationId);
+        if (terminal(updated.state)) {
+          settled.push(this.#terminal(updated, true));
+        }
+      }
+      return claimed2;
+    });
+    for (const row2 of settled) this.#notify(row2);
+    return claimed;
+  }
+  forConversation(conversationId) {
+    return this.storage.sql.exec("SELECT * FROM cloud_invocations WHERE conversationId=? ORDER BY seq", conversationId).toArray();
+  }
+  startExecution(conversationId, deadlineAt) {
+    this.storage.sql.exec("INSERT INTO cloud_executions(conversationId,deadlineAt) VALUES (?,?) ON CONFLICT(conversationId) DO NOTHING", conversationId, deadlineAt);
+    return this.execution(conversationId);
+  }
+  execution(conversationId) {
+    return this.storage.sql.exec("SELECT * FROM cloud_executions WHERE conversationId=?", conversationId).toArray()[0];
+  }
+  failExecution(conversationId, code) {
+    this.storage.sql.exec("UPDATE cloud_executions SET fatalCode=COALESCE(fatalCode,?) WHERE conversationId=?", code, conversationId);
+    return this.execution(conversationId);
+  }
+  abortExecution(conversationId, code) {
+    return this.storage.transactionSync(() => {
+      this.storage.sql.exec("UPDATE cloud_executions SET aborted=1,fatalCode=COALESCE(fatalCode,?) WHERE conversationId=?", code, conversationId);
+      this.storage.sql.exec(`UPDATE cloud_invocations SET abortRequested=1
+        WHERE conversationId=? AND state IN ('accepted','running')`, conversationId);
+      return this.execution(conversationId);
+    });
+  }
+  executionRejection(row2, now) {
+    if (row2.fatalCode) return row2.fatalCode;
+    if (row2.aborted) return "CLOUD_EXECUTION_ABORTED";
+    if (now >= row2.deadlineAt) return "CLOUD_EXECUTION_TIMEOUT";
+    return void 0;
+  }
+  countModel(conversationId, maxSteps = 8, now = Date.now(), budget) {
+    const outcome = this.storage.transactionSync(() => {
+      const row2 = this.execution(conversationId);
+      if (!row2) return { code: "CLOUD_EXECUTION_INTERRUPTED" };
+      const code = this.executionRejection(row2, now) ?? (row2.steps >= maxSteps ? "CLOUD_STEP_LIMIT" : void 0);
+      if (code) {
+        this.failExecution(conversationId, code);
+        return { code };
+      }
+      if (budget && (row2.inputTokens + budget.inputBytes + REQUEST_FRAMING_BYTES > budget.inputTokens || row2.outputTokens + PLATFORM_MAX_OUTPUT_TOKENS > budget.outputTokens)) {
+        this.failExecution(conversationId, "CLOUD_BUDGET_EXCEEDED");
+        return { code: "CLOUD_BUDGET_EXCEEDED" };
+      }
+      this.storage.sql.exec("UPDATE cloud_executions SET steps=steps+1 WHERE conversationId=?", conversationId);
+      return { row: this.execution(conversationId) };
+    });
+    if (outcome.code) throw new CloudDoError(outcome.code);
+    return outcome.row;
+  }
+  addModelUsage(conversationId, input, output) {
+    this.storage.sql.exec(`UPDATE cloud_executions SET inputTokens=MIN(inputTokens+?,9007199254740991),
+      outputTokens=MIN(outputTokens+?,9007199254740991) WHERE conversationId=?`, input, output, conversationId);
+  }
+  /** This mark records durable dispatch intent. It does not prove network receipt. */
+  markModelSent(conversationId) {
+    const update = this.storage.sql.exec(`UPDATE cloud_executions SET sentRequests=sentRequests+1
+      WHERE conversationId=? AND sentRequests < steps`, conversationId);
+    if (update.rowsWritten === 0) throw new CloudDoError("CLOUD_MODEL_REQUEST_FAILED");
+  }
+  countTool(conversationId, taskId, maxTools = 12, now = Date.now()) {
+    const outcome = this.storage.transactionSync(() => {
+      const row2 = this.execution(conversationId);
+      if (!row2) return { code: "CLOUD_EXECUTION_INTERRUPTED" };
+      const stopped = this.executionRejection(row2, now);
+      if (stopped) {
+        this.failExecution(conversationId, stopped);
+        return { code: stopped };
+      }
+      const counted = this.storage.sql.exec("SELECT taskId FROM cloud_counted_tools WHERE conversationId=? AND taskId=?", conversationId, taskId).toArray()[0];
+      if (counted) return { row: row2 };
+      if (row2.tools >= maxTools) {
+        this.failExecution(conversationId, "CLOUD_TOOL_LIMIT");
+        return { code: "CLOUD_TOOL_LIMIT" };
+      }
+      this.storage.sql.exec("INSERT INTO cloud_counted_tools(conversationId,taskId) VALUES (?,?)", conversationId, taskId);
+      this.storage.sql.exec("UPDATE cloud_executions SET tools=tools+1 WHERE conversationId=?", conversationId);
+      return { row: this.execution(conversationId) };
+    });
+    if (outcome.code) throw new CloudDoError(outcome.code);
+    return outcome.row;
+  }
+};
+
+// src/session-config.ts
+var CLOUD_LIMITS = Object.freeze({
+  modelSteps: 8,
+  toolCalls: 12,
+  inlineFetches: 4,
+  callTimeoutMs: 6e4,
+  turnTimeoutMs: 24e4,
+  resultBytes: 48e3
+});
+var CLOUD_BUDGET = Object.freeze({ credits: 100, inputTokens: 128e3, outputTokens: 32768 });
+function record(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  const result = {};
+  for (const key of Reflect.ownKeys(value)) {
+    const field = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || !keys.includes(key) || !field || !("value" in field) || !field.enumerable) {
+      throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    }
+    result[key] = field.value;
+  }
+  return result;
+}
+function text(value, max = 256) {
+  if (typeof value !== "string" || !value.trim() || value.length > max || /\p{Cc}/u.test(value)) {
+    throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  return value;
+}
+function admitSessionConfig(input) {
+  const body = record(input, ["identity", "principal", "scopes", "dispatcherId", "limits"]);
+  const ids = record(body.identity, ["tenantId", "workspaceId", "agentId", "sessionId"]);
+  const identity = {
+    tenantId: text(ids.tenantId),
+    workspaceId: text(ids.workspaceId),
+    agentId: text(ids.agentId),
+    sessionId: text(ids.sessionId)
+  };
+  const rawPrincipal = record(body.principal, ["accountId", "workspaceId", "channel"]);
+  const principal = { accountId: text(rawPrincipal.accountId), workspaceId: text(rawPrincipal.workspaceId), channel: text(rawPrincipal.channel) };
+  if (principal.workspaceId !== identity.workspaceId || !["web", "api", "mcp"].includes(principal.channel)) {
+    throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  if (!Array.isArray(body.scopes) || body.scopes.length > 64 || Reflect.ownKeys(body.scopes).length !== body.scopes.length + 1) {
+    throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  }
+  const scopes = [];
+  for (let i = 0; i < body.scopes.length; i++) {
+    const field = Object.getOwnPropertyDescriptor(body.scopes, String(i));
+    if (!field || !("value" in field) || !field.enumerable) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    scopes.push(text(field.value, 128));
+  }
+  if (new Set(scopes).size !== scopes.length) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  const limits = { ...CLOUD_LIMITS };
+  if (Object.hasOwn(body, "limits")) {
+    const overrides = record(body.limits, Object.keys(CLOUD_LIMITS));
+    for (const key of Object.keys(overrides)) {
+      const value = overrides[key];
+      if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > CLOUD_LIMITS[key]) {
+        throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      }
+      limits[key] = value;
+    }
+  }
+  return { identity, principal, scopes, dispatcherId: text(body.dispatcherId), limits };
+}
+var names = /* @__PURE__ */ new Set(["durable_schema"]);
+for (const migration of SQLITE_MIGRATIONS) for (const sql of migration.statements) {
+  for (const match of sql.matchAll(/\bCREATE\s+(?:UNIQUE\s+)?(?:TABLE|INDEX)\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_][A-Za-z0-9_]*)/gi)) names.add(match[1]);
+}
+var identifiers = new RegExp(`\\b(${[...names].join("|")})\\b`, "g");
+function prefixed(sql) {
+  return sql.split(/('(?:[^']|'')*')/).map((part, i) => i % 2 ? part : part.replace(identifiers, (name) => `pi_${name}`)).join("");
+}
+function binding(value) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) throw new RangeError("SQLite integer outside safe range");
+    return Number(value);
+  }
+  if (value instanceof Uint8Array) return new Uint8Array(value).buffer;
+  return value;
+}
+function row(raw) {
+  const result = { ...raw };
+  for (const [key, value] of Object.entries(result)) if (value instanceof ArrayBuffer) result[key] = new Uint8Array(value);
+  return result;
+}
+var DurableObjectSqliteDatabase = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  tail = Promise.resolve();
+  closed = false;
+  queued(operation, allowClosed = false) {
+    const result = this.tail.then(() => {
+      if (this.closed && !allowClosed) throw new Error("SQLite database is closed");
+      return operation();
+    });
+    this.tail = result.then(() => {
+    }, () => {
+    });
+    return result;
+  }
+  executor(active) {
+    const query = (sql, params) => {
+      if (!active()) throw new Error("SQLite transaction handle is no longer active");
+      return this.storage.sql.exec(prefixed(sql), ...params.map(binding));
+    };
+    return {
+      exec: async (sql) => {
+        query(sql, []).toArray();
+      },
+      run: async (sql, ...params) => {
+        query(sql, params).toArray();
+      },
+      get: async (sql, ...params) => {
+        const rows = query(sql, params).toArray();
+        return rows[0] === void 0 ? void 0 : row(rows[0]);
+      },
+      all: async (sql, ...params) => query(sql, params).toArray().map((raw) => row(raw))
+    };
+  }
+  exec(sql) {
+    return this.queued(() => this.executor(() => true).exec(sql));
+  }
+  run(sql, ...params) {
+    return this.queued(() => this.executor(() => true).run(sql, ...params));
+  }
+  get(sql, ...params) {
+    return this.queued(() => this.executor(() => true).get(sql, ...params));
+  }
+  all(sql, ...params) {
+    return this.queued(() => this.executor(() => true).all(sql, ...params));
+  }
+  transaction(callback) {
+    return this.queued(() => this.storage.transaction(async () => {
+      let active = true;
+      try {
+        return await callback(this.executor(() => active));
+      } finally {
+        active = false;
+      }
+    }));
+  }
+  close() {
+    return this.queued(() => {
+      if (this.closed) return;
+      this.closed = true;
+    }, true);
+  }
+};
+var openDurableObjectStorage = (storage) => SqliteStorage.open(new DurableObjectSqliteDatabase(storage));
+
+// src/session-runtime.ts
+var CLOUD_HARNESS_SETTINGS = {
+  compaction: { enabled: false },
+  retry: { enabled: false, maxRetries: 0 },
+  stream: { maxRetries: 0 }
+};
+var StaleInvocationAttempt = class extends CloudDoError {
+  constructor() {
+    super("CLOUD_EXECUTION_INTERRUPTED");
+  }
+};
+async function raceSignal(work, signal, code) {
+  let remove = () => {
+  };
+  const cancelled = new Promise((_resolve, reject) => {
+    const abort = () => reject(new CloudDoError(code()));
+    signal.addEventListener("abort", abort, { once: true });
+    remove = () => signal.removeEventListener("abort", abort);
+    if (signal.aborted) abort();
+  });
+  try {
+    return await Promise.race([work, cancelled]);
+  } finally {
+    remove();
+  }
+}
+function raceLease(work, lease) {
+  return raceSignal(
+    work,
+    lease.controller.signal,
+    () => Date.now() >= lease.deadlineAt ? "CLOUD_EXECUTION_TIMEOUT" : "CLOUD_EXECUTION_ABORTED"
+  );
+}
+var SessionRuntime = class {
+  constructor(state, env, options) {
+    this.state = state;
+    this.env = env;
+    this.options = options;
+    this.cloud = new CloudState(state.storage);
+    this.ledger = new InvocationLedger(state.storage, {
+      started: (row2, guard) => {
+        this.cloud.appendEvent({
+          eventKey: `tool:${row2.invocationId}:started`,
+          type: "tool.started",
+          conversationId: row2.conversationId,
+          ref: row2.invocationId,
+          data: { invocationId: row2.invocationId, toolName: row2.toolName, state: row2.state }
+        }, guard ?? this.#guard());
+      },
+      startedCommitted: () => this.#doorbell(),
+      terminal: (row2, recovery) => {
+        const guard = this.#guard();
+        const event = this.cloud.appendEvent({
+          eventKey: `tool:${row2.invocationId}:settled`,
+          type: "tool.settled",
+          conversationId: row2.conversationId,
+          ref: row2.invocationId,
+          data: { invocationId: row2.invocationId, state: row2.state, errorCode: row2.errorCode, late: recovery }
+        }, guard);
+        row2.settledAt = event.createdAt;
+        row2.settledEventSeq = event.seq;
+        this.cloud.projectInvocation(row2, this.options.projectInvocation, guard);
+        return event;
+      },
+      committed: (row2) => {
+        if (this.#initializing) this.#deferredSettlements.push(row2);
+        else this.#notifyCommitted(row2);
+      }
+    });
+  }
+  state;
+  env;
+  options;
+  ledger;
+  cloud;
+  #piStorage;
+  #recoveryGuard;
+  #repairRetrying = false;
+  #repairing = false;
+  #settlementFlights = /* @__PURE__ */ new Map();
+  #initializing = false;
+  #deferredSettlements = [];
+  #opened;
+  #recovery;
+  #recovered = false;
+  #config;
+  #dispatcher;
+  #bootstrapFailure;
+  #stale = /* @__PURE__ */ new Set();
+  #active;
+  #inline = 0;
+  #invocations = /* @__PURE__ */ new Map();
+  #fatalDispositions = /* @__PURE__ */ new Map();
+  get recovering() {
+    return !this.#recovered;
+  }
+  get activeLease() {
+    return this.#active;
+  }
+  get hasLiveOwner() {
+    return this.#active?.liveOwner === true;
+  }
+  get busy() {
+    return this.#active !== void 0 || this.#repairing;
+  }
+  get repairRetrying() {
+    return this.#repairRetrying;
+  }
+  #schedulingBusy() {
+    return this.hasLiveOwner || this.#repairing;
+  }
+  #clearSettlementRetry() {
+    if (!this.#repairing && (!this.#active || this.hasLiveOwner)) this.#repairRetrying = false;
+  }
+  prepareGuard(profile) {
+    return prepareCloudGuard(this.env, profile);
+  }
+  #guard() {
+    const guard = this.#active?.guard ?? this.#recoveryGuard;
+    if (!guard) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    return guard;
+  }
+  #doorbell() {
+    try {
+      this.options.onCommit?.();
+    } catch {
+    }
+  }
+  #notifyCommitted(row2) {
+    this.#doorbell();
+    void Promise.resolve().then(() => this.options.onInvocationSettled?.(row2.invocationId, row2.state)).catch(() => void 0);
+  }
+  #flushSettlements() {
+    this.#initializing = false;
+    for (const row2 of this.#deferredSettlements.splice(0)) this.#notifyCommitted(row2);
+  }
+  /** Binding/RPC callers authorize the session before calling this immutable configuration operation. */
+  async configure(input) {
+    const config = admitSessionConfig(input);
+    await admitCloudPayload(this.env, config);
+    const candidate = this.options.createDispatcher(config.dispatcherId);
+    if (!candidate) throw new CloudDoError("CLOUD_TOOL_NOT_AVAILABLE");
+    const dispatcher = admitCloudDispatcher(candidate);
+    await this.#guardToolMetadata(dispatcher);
+    const policyDigest = await dispatcherDigest(dispatcher);
+    this.#sessionSchema();
+    this.state.storage.transactionSync(() => {
+      const existing = this.#storedConfig();
+      if (existing) {
+        if (JSON.stringify(existing) !== JSON.stringify(config) || this.#storedDispatcherDigest() !== policyDigest) throw new CloudDoError("CLOUD_SESSION_CONFLICT");
+        return;
+      }
+      if (this.#opened) throw new CloudDoError("CLOUD_SESSION_CONFLICT");
+      this.state.storage.sql.exec("UPDATE cloud_session SET configJson=?,dispatcherDigest=? WHERE id=1", JSON.stringify(config), policyDigest);
+    });
+  }
+  open(selected) {
+    if (!this.#opened) {
+      const initialized = prepareCloudGuard(this.env, selected).then((guard) => {
+        this.#recoveryGuard = guard;
+        this.#initializing = true;
+        return this.state.blockConcurrencyWhile(async () => {
+          this.ledger.ensureSchema();
+          this.cloud.ensureSchema();
+          this.#sessionSchema();
+          this.#config = this.#storedConfig();
+          if (!this.#config && this.ledger.pending().length) this.#bootstrapFailure = "CLOUD_TOOL_NOT_AVAILABLE";
+          if (this.#config) {
+            this.#config = admitSessionConfig(this.#config);
+            const candidate = this.options.createDispatcher(this.#config.dispatcherId);
+            if (!candidate) this.#bootstrapFailure = "CLOUD_TOOL_NOT_AVAILABLE";
+            else {
+              const dispatcher = admitCloudDispatcher(candidate);
+              const metadata = dispatcher.tools.map(({ name, description, parameters }) => ({ name, description, parameters }));
+              guard.guardPayload(JSON.stringify(metadata));
+              if (await dispatcherDigest(dispatcher) !== this.#storedDispatcherDigest()) this.#bootstrapFailure = "CLOUD_SESSION_CONFLICT";
+              else this.#dispatcher = dispatcher;
+            }
+          }
+          const registry = createRegistry();
+          const tools = this.#dispatcher?.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            replay: "unsafe",
+            outputLimits: { maxBytes: CLOUD_LIMITS.resultBytes, maxLines: CLOUD_LIMITS.resultBytes },
+            execute: (args, api, context) => this.#execute(tool.name, args, api, context)
+          })) ?? [];
+          registry.install(defineExtension({
+            name: "cloud-session-tools",
+            tools,
+            hooks: [hook(ToolTask, { beforeTool: async (_call, api) => {
+              if (this.#stale.has(api.conversationId)) return { block: "CLOUD_EXECUTION_INTERRUPTED" };
+              try {
+                this.ledger.countTool(api.conversationId, String(api.taskId), this.#limits().toolCalls);
+              } catch (error) {
+                const code = safeCloudError(error).code;
+                this.#recordFatal(api.conversationId, code);
+                return { block: code };
+              }
+            } })]
+          }));
+          this.#piStorage = await openDurableObjectStorage(this.state.storage);
+          const harness = await Harness.open(this.#piStorage, {
+            models: createPlatformModels(this.env, platformCredentialReader(this.env), {
+              beforeRequest: (info) => this.#beforeRequest(info),
+              admitToolCall: async (name, id, args) => {
+                try {
+                  await admitCloudPayload(this.env, { name, id, args }, this.#active?.profile);
+                } catch (error) {
+                  if (error instanceof CloudDoError && error.code === "CLOUD_USER_CREDENTIAL_REJECTED") {
+                    throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+                  }
+                  throw error;
+                }
+                const tool = this.#dispatcher?.tools.find((tool2) => tool2.name === name);
+                if (!tool) throw new CloudDoError("CLOUD_TOOL_NOT_AVAILABLE");
+                try {
+                  validateToolArguments(tool, { type: "toolCall", id, name, arguments: args });
+                } catch {
+                  throw new CloudDoError("CLOUD_TOOL_ARGUMENT_INVALID");
+                }
+              },
+              requestSignal: (signal) => this.#requestSignal(signal)
+            }),
+            registry,
+            settings: CLOUD_HARNESS_SETTINGS
+          }, BACKGROUND_CONTEXT);
+          const inspection = await harness.inspect(BACKGROUND_CONTEXT);
+          this.#stale = /* @__PURE__ */ new Set([
+            ...inspection.tasks.map((task) => task.record.conversationId),
+            ...inspection.submissions.map((submission) => submission.conversationId)
+          ]);
+          this.state.storage.sql.exec("UPDATE cloud_session SET staleJson=? WHERE id=1", JSON.stringify([...this.#stale]));
+          this.cloud.captureEligibility(this.#stale);
+          const replay = this.ledger.claimRecovery();
+          await this.cloud.rearmAlarm({ busy: false, repairRetrying: false });
+          return { harness, replay };
+        });
+      });
+      this.#opened = initialized.then(({ harness, replay }) => {
+        this.#flushSettlements();
+        this.#recovery = this.#recover(harness, replay).finally(() => {
+          this.#recoveryGuard?.dispose();
+          this.#recoveryGuard = void 0;
+        });
+        void this.#recovery.catch(() => void 0);
+        return harness;
+      }, (error) => {
+        this.#flushSettlements();
+        this.#recoveryGuard?.dispose();
+        this.#recoveryGuard = void 0;
+        throw error;
+      });
+    }
+    return this.#opened;
+  }
+  async ready(selected) {
+    const harness = await this.open(selected);
+    await this.#recovery;
+    return harness;
+  }
+  agentChange(profile, guard) {
+    const model = { provider: profile, modelId: PLATFORM_PROFILES[profile].model };
+    try {
+      const text2 = this.options.instructions?.(profile);
+      if (text2 === void 0) return { model };
+      if (typeof text2 !== "string" || !text2.trim() || new TextEncoder().encode(text2).length > CLOUD_CONTEXT_BYTES) {
+        throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      }
+      guard.guardText(text2);
+      return { model, instructions: text2 };
+    } catch {
+      throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    }
+  }
+  reserve(profile, guard) {
+    if (!this.#recovered) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    if (this.#bootstrapFailure) throw new CloudDoError(this.#bootstrapFailure);
+    if (this.#active) throw new CloudDoError("CLOUD_TOOL_BUSY");
+    if (this.#repairing) throw new CloudDoError("CLOUD_TOOL_BUSY");
+    const lease = {
+      profile,
+      deadlineAt: Date.now() + this.#limits().turnTimeoutMs,
+      controller: new AbortController(),
+      connected: true,
+      liveOwner: true,
+      settled: false,
+      guard
+    };
+    this.#active = lease;
+    this.cloud.setSchedulingState({ busy: true, repairRetrying: this.#repairRetrying });
+    return lease;
+  }
+  attach(lease, conversationId, trigger = "submit", guard = lease.guard) {
+    if (this.#active !== lease || lease.conversationId !== void 0) throw new CloudDoError("CLOUD_TOOL_BUSY");
+    lease.conversationId = conversationId;
+    lease.trigger = trigger;
+    lease.guard = guard;
+    if (!lease.guard) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    this.cloud.startRun(conversationId, trigger, lease.deadlineAt, lease.guard);
+    if (trigger === "submit") this.cloud.markRunning(conversationId, lease.guard);
+    lease.timer = setTimeout(() => {
+      if (this.#active !== lease || lease.settled) return;
+      this.#recordFatal(conversationId, "CLOUD_EXECUTION_TIMEOUT");
+      lease.controller.abort();
+    }, Math.max(0, lease.deadlineAt - Date.now()));
+    this.#doorbell();
+  }
+  cancel(lease, code = "CLOUD_EXECUTION_ABORTED") {
+    if (this.#active !== lease || lease.settled) return;
+    if (lease.conversationId !== void 0) {
+      const row2 = this.cloud.run(lease.conversationId);
+      if (row2 && row2.state !== "starting" && row2.state !== "running") return;
+    }
+    lease.connected = false;
+    if (lease.conversationId !== void 0) {
+      this.#recordFatal(lease.conversationId, code);
+      try {
+        this.ledger.abortExecution(lease.conversationId, code);
+      } catch {
+      }
+    }
+    lease.controller.abort();
+  }
+  async release(lease, retryCount = 0) {
+    clearTimeout(lease.timer);
+    lease.liveOwner = false;
+    if (this.#active !== lease) return;
+    try {
+      const run = lease.conversationId === void 0 ? void 0 : this.cloud.run(lease.conversationId);
+      if (run?.state === "running") {
+        this.#repairRetrying = lease.trigger === "wake";
+        await this.cloud.rearmAlarm({ busy: false, repairRetrying: this.#repairRetrying });
+        return;
+      }
+      if (run?.state === "starting") {
+        this.cloud.settleRun(run.conversationId, { state: "interrupted", errorCode: this.fatal(run.conversationId) ?? "CLOUD_WAKE_EMPTY" }, this.#guard());
+        this.#doorbell();
+      }
+      this.#active = void 0;
+      try {
+        await this.#deliverSettlements(lease.guard);
+        this.#clearSettlementRetry();
+      } catch (error) {
+        if (lease.trigger === "wake") {
+          this.#repairRetrying = retryCount < 6;
+          this.cloud.setSchedulingState({ busy: this.#schedulingBusy(), repairRetrying: this.#repairRetrying });
+          throw error;
+        }
+      }
+      await this.cloud.rearmAlarm({ busy: this.#schedulingBusy(), repairRetrying: this.#repairRetrying });
+    } catch (error) {
+      if (this.#active === lease) {
+        this.#repairRetrying = lease.trigger === "wake";
+        this.cloud.setSchedulingState({ busy: false, repairRetrying: this.#repairRetrying });
+        if (!this.#repairRetrying) await this.cloud.rearmAlarm({ busy: false, repairRetrying: false });
+      }
+      throw error;
+    } finally {
+      lease.guard?.dispose();
+      lease.guard = void 0;
+    }
+  }
+  recordSubmission(conversationId, submissionId) {
+    this.cloud.recordSubmission(conversationId, submissionId);
+  }
+  markReservation(conversationId, reservation, admission) {
+    this.cloud.markReservation(conversationId, reservation, this.#guard(), Date.now(), admission);
+    this.#doorbell();
+  }
+  claimWake(lease, seqs, profile = lease.profile) {
+    if (this.#active !== lease || lease.conversationId === void 0 || !lease.liveOwner) throw new CloudDoError("CLOUD_TOOL_BUSY");
+    const claimed = this.cloud.claim(lease.conversationId, [...seqs], profile, this.#guard());
+    this.#doorbell();
+    return claimed;
+  }
+  async settle(lease, outcome) {
+    if (this.#active !== lease || lease.conversationId === void 0) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    const delivery = await this.#deliveryEvidence(await this.#opened, lease.conversationId, outcome.state === "completed");
+    this.state.storage.transactionSync(() => {
+      const fatal = this.fatal(lease.conversationId) ?? (lease.controller.signal.aborted ? "CLOUD_EXECUTION_ABORTED" : Date.now() >= lease.deadlineAt ? "CLOUD_EXECUTION_TIMEOUT" : void 0);
+      const finalOutcome = outcome.state === "completed" && fatal ? { state: "failed", errorCode: fatal } : outcome;
+      const stored = this.cloud.settleRun(lease.conversationId, finalOutcome, this.#guard());
+      for (const link of delivery) this.cloud.setDelivery(
+        link.invocationId,
+        stored?.state === "completed" ? link.state : "undelivered",
+        stored?.state === "completed" ? link.taskId : null,
+        stored?.state === "completed" ? link.entryId : null,
+        this.#guard()
+      );
+    });
+    lease.settled = true;
+    clearTimeout(lease.timer);
+    this.#doorbell();
+  }
+  cancelActive(code = "CLOUD_EXECUTION_ABORTED") {
+    if (!this.#active || this.#active.settled) return false;
+    this.cancel(this.#active, code);
+    return true;
+  }
+  /** Only an owner that exited may be repaired. A live provider run is never adjudicated here. */
+  async repairPendingRuns(retryCount = 0) {
+    if (this.hasLiveOwner || this.#repairing) return false;
+    const runs = this.cloud.unsettledRuns();
+    if (!runs.length) {
+      if (this.#repairRetrying && !this.cloud.unackedRuns().length) {
+        this.#repairRetrying = false;
+        await this.cloud.rearmAlarm({ busy: this.busy, repairRetrying: false });
+      }
+      return false;
+    }
+    this.#repairing = true;
+    this.#repairRetrying = true;
+    this.cloud.setSchedulingState({ busy: true, repairRetrying: true });
+    let guard;
+    const previousGuard = this.#active?.guard;
+    try {
+      guard = await this.prepareGuard();
+      this.#recoveryGuard = guard;
+      if (this.#active) this.#active.guard = guard;
+      const harness = await this.#opened;
+      const inspection = await harness.inspect(BACKGROUND_CONTEXT);
+      const live = /* @__PURE__ */ new Set([...inspection.tasks.map((task) => task.record.conversationId), ...inspection.submissions.map((submission) => submission.conversationId)]);
+      this.cloud.captureEligibility(live);
+      for (const run of runs) {
+        const id = run.conversationId;
+        if (!live.has(id)) continue;
+        this.#stale.add(id);
+        this.#recordFatal(id, "CLOUD_EXECUTION_INTERRUPTED");
+        const conversation = await harness.conversation(id, BACKGROUND_CONTEXT);
+        if (conversation) {
+          await conversation.abort(BACKGROUND_CONTEXT, { background: true });
+          await conversation.waitForIdle(BACKGROUND_CONTEXT);
+        }
+      }
+      await this.#adjudicateRuns(harness);
+      clearTimeout(this.#active?.timer);
+      this.#active = void 0;
+      this.#repairRetrying = this.cloud.unackedRuns().length > 0;
+      await this.cloud.rearmAlarm({ busy: false, repairRetrying: this.#repairRetrying });
+      return true;
+    } catch (error) {
+      this.#repairRetrying = retryCount < 6;
+      this.cloud.setSchedulingState({ busy: false, repairRetrying: this.#repairRetrying });
+      throw error;
+    } finally {
+      this.#repairing = false;
+      guard?.dispose();
+      previousGuard?.dispose();
+      this.#recoveryGuard = void 0;
+      if (this.#active) this.#active.guard = void 0;
+    }
+  }
+  async deliverSettlementsForAlarm(retryCount = 0, providedGuard) {
+    let ownGuard;
+    try {
+      if (this.cloud.unackedRuns().length) {
+        const guard = providedGuard ?? (ownGuard = await this.prepareGuard());
+        await this.#deliverSettlements(guard);
+      }
+      this.#clearSettlementRetry();
+      await this.cloud.rearmAlarm({ busy: this.#schedulingBusy(), repairRetrying: this.#repairRetrying });
+    } catch (error) {
+      this.#repairRetrying = retryCount < 6;
+      this.cloud.setSchedulingState({ busy: this.#schedulingBusy(), repairRetrying: this.#repairRetrying });
+      throw safeCloudError(error);
+    } finally {
+      ownGuard?.dispose();
+    }
+  }
+  async #deliverSettlements(guard) {
+    const rows = this.cloud.unackedRuns();
+    if (!rows.length) return;
+    if (!guard) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    const jobs = rows.map((row2) => {
+      const previous = this.#settlementFlights.get(row2.conversationId);
+      if (previous) return previous;
+      const job = this.#deliverSettlement(row2, guard).finally(() => this.#settlementFlights.delete(row2.conversationId));
+      this.#settlementFlights.set(row2.conversationId, job);
+      return job;
+    });
+    const results = await Promise.allSettled(jobs);
+    const failures = results.filter((result) => result.status === "rejected");
+    if (failures.length) throw safeCloudError(failures[0].reason);
+  }
+  async #deliverSettlement(row2, guard) {
+    if (this.cloud.readRun(row2.conversationId)?.settlementAck !== 0) return;
+    const input = Object.freeze({
+      nativeRunId: row2.conversationId,
+      requestId: row2.requestId,
+      trigger: row2.trigger,
+      state: row2.state,
+      errorCode: row2.errorCode,
+      reservation: row2.reservation,
+      admissionDigest: row2.admissionDigest,
+      admittedSeqs: Object.freeze(JSON.parse(row2.admittedSeqs ?? "[]")),
+      claimedSeqs: Object.freeze(this.cloud.claimedSeqs(row2.conversationId)),
+      usage: Object.freeze({
+        steps: row2.steps,
+        sentRequests: row2.sentRequests,
+        inputTokens: row2.inputTokens,
+        outputTokens: row2.outputTokens,
+        credits: row2.credits
+      })
+    });
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CLOUD_LIMITS.callTimeoutMs);
+    try {
+      await raceSignal(
+        Promise.resolve().then(() => this.options.settleRun?.(input, controller.signal)),
+        controller.signal,
+        () => "CLOUD_EXECUTION_TIMEOUT"
+      );
+      if (this.cloud.ackSettlement(row2.conversationId, guard)) this.#doorbell();
+    } catch (error) {
+      throw safeCloudError(error);
+    } finally {
+      clearTimeout(timer);
+      controller.abort();
+    }
+  }
+  async #adjudicateRuns(harness) {
+    for (const run of this.cloud.unsettledRuns()) {
+      const eligibility = JSON.parse(run.eligibilityJson ?? JSON.stringify({ steps: run.steps, aborted: run.aborted, fatalCode: run.fatalCode }));
+      const aborted = eligibility.aborted || run.aborted;
+      let outcome;
+      const submission = run.requestId ? await this.#piStorage.submissionByRequest(run.conversationId, run.requestId, BACKGROUND_CONTEXT) : void 0;
+      if (run.state === "starting") outcome = { state: "interrupted", errorCode: "CLOUD_WAKE_EMPTY" };
+      else if (!aborted && !eligibility.fatalCode && submission?.status === "done") {
+        const conversation = await harness.conversation(run.conversationId, BACKGROUND_CONTEXT);
+        const context = conversation ? await conversation.context(BACKGROUND_CONTEXT) : void 0;
+        const final = context ? [...context.entries].reverse().find((entry) => entry.kind === "pi.assistant" && entry.model?.some((message2) => message2.role === "assistant" && message2.stopReason !== "toolUse")) : void 0;
+        const message = final?.model?.find((message2) => message2.role === "assistant" && message2.stopReason !== "toolUse");
+        const text2 = message?.role === "assistant" ? message.content.filter((part) => part.type === "text").map((part) => part.text).join("") : "";
+        outcome = { state: "completed", text: text2, entryId: final?.id };
+      } else if (!aborted && !eligibility.fatalCode && submission?.status === "unanswered" && submission.reason !== "aborted") {
+        outcome = { state: "failed", errorCode: safeCloudError(new Error(typeof submission.detail === "string" ? submission.detail : "")).code };
+      } else {
+        outcome = {
+          state: "interrupted",
+          errorCode: eligibility.fatalCode ?? (aborted ? "CLOUD_EXECUTION_ABORTED" : "CLOUD_EXECUTION_INTERRUPTED"),
+          requeue: run.trigger === "wake" && eligibility.steps === 0 && !aborted && !eligibility.fatalCode
+        };
+      }
+      const delivery = await this.#deliveryEvidence(harness, run.conversationId, outcome.state === "completed");
+      this.state.storage.transactionSync(() => {
+        const current = this.cloud.run(run.conversationId);
+        const finalOutcome = current?.aborted && !eligibility.aborted ? { state: "interrupted", errorCode: "CLOUD_EXECUTION_ABORTED" } : outcome;
+        const stored = this.cloud.settleRun(run.conversationId, finalOutcome, this.#guard());
+        for (const link of delivery) this.cloud.setDelivery(
+          link.invocationId,
+          stored?.state === "completed" ? link.state : "undelivered",
+          stored?.state === "completed" ? link.taskId : null,
+          stored?.state === "completed" ? link.entryId : null,
+          this.#guard()
+        );
+      });
+      this.#doorbell();
+    }
+  }
+  async #deliveryEvidence(harness, conversationId, completed) {
+    const rows = this.ledger.forConversation(conversationId);
+    const links = rows.map((row2) => ({ invocationId: row2.invocationId, state: "undelivered", taskId: null, entryId: null }));
+    if (!completed || !rows.length) return links;
+    const conversation = await harness.conversation(conversationId, BACKGROUND_CONTEXT);
+    if (!conversation) return links;
+    const context = await conversation.context(BACKGROUND_CONTEXT);
+    let cursor;
+    do {
+      const page = await this.#piStorage.scanTasks({ conversationId, kind: ToolTask.definition.name }, 100, cursor, BACKGROUND_CONTEXT);
+      for (const task of page.items) {
+        if (task.state.status !== "terminal" || task.state.outcome.status !== "completed") continue;
+        const input = task.input;
+        const rowIndex = rows.findIndex((row2) => row2.assistantEntryId === input.assistant && row2.toolCallId === input.callId);
+        if (rowIndex < 0) continue;
+        const result = task.state.outcome.result;
+        const entryIndex = context.entries.findIndex((entry) => entry.id === result.entryId && entry.kind === "pi.tool-result" && entry.byTaskId === task.id);
+        if (entryIndex < 0 || !context.contributions[entryIndex]?.some((message) => message.role === "toolResult")) continue;
+        links[rowIndex] = { invocationId: rows[rowIndex].invocationId, state: "delivered", taskId: task.id, entryId: result.entryId };
+      }
+      cursor = page.next;
+    } while (cursor !== void 0);
+    return links;
+  }
+  fatal(conversationId) {
+    const remembered = this.#fatalDispositions.get(conversationId);
+    if (remembered) return remembered;
+    try {
+      const code = this.ledger.execution(conversationId)?.fatalCode;
+      return code ? this.#toolErrorCode(new Error(code)) : void 0;
+    } catch {
+      return this.#recordFatal(conversationId, "CLOUD_TOOL_FAILED");
+    }
+  }
+  readInvocation(id) {
+    return this.ledger.read(id);
+  }
+  #limits() {
+    return this.#config?.limits ?? CLOUD_LIMITS;
+  }
+  async #guardToolMetadata(dispatcher) {
+    const metadata = dispatcher.tools.map(({ name, description, parameters }) => ({ name, description, parameters }));
+    await admitCloudPayload(this.env, JSON.parse(JSON.stringify(metadata)));
+  }
+  #sessionSchema() {
+    this.state.storage.sql.exec(`CREATE TABLE IF NOT EXISTS cloud_session (
+      id INTEGER PRIMARY KEY CHECK(id=1), configJson TEXT, staleJson TEXT NOT NULL DEFAULT '[]'
+    ); INSERT OR IGNORE INTO cloud_session(id) VALUES(1)`);
+    const columns = this.state.storage.sql.exec("PRAGMA table_info(cloud_session)").toArray();
+    if (!columns.some((row2) => row2.name === "dispatcherDigest")) this.state.storage.sql.exec("ALTER TABLE cloud_session ADD COLUMN dispatcherDigest TEXT");
+  }
+  #storedDispatcherDigest() {
+    return this.state.storage.sql.exec("SELECT dispatcherDigest FROM cloud_session WHERE id=1").one().dispatcherDigest;
+  }
+  #storedConfig() {
+    const row2 = this.state.storage.sql.exec("SELECT configJson FROM cloud_session WHERE id=1").toArray()[0];
+    return row2?.configJson ? JSON.parse(row2.configJson) : void 0;
+  }
+  async #renew(request, signal) {
+    const result = this.options.renew ? await this.options.renew(Object.freeze(request), signal) : { ok: true };
+    if (!result || typeof result !== "object" || typeof result.ok !== "boolean") throw new CloudDoError("CLOUD_MODEL_REQUEST_FAILED");
+    if (!result.ok) throw safeCloudError(new Error(result.code));
+  }
+  async #beforeRequest(info) {
+    if (!this.#recovered || !this.#active?.liveOwner || this.#active.conversationId === void 0) {
+      throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    }
+    const lease = this.#active;
+    const id = lease.conversationId;
+    const fatal = this.fatal(id);
+    if (fatal) throw new CloudDoError(fatal);
+    try {
+      await raceLease(Promise.resolve().then(() => this.#renew({
+        nativeRunId: id,
+        requestId: this.cloud.readRun(id)?.requestId ?? null,
+        kind: "model",
+        recovery: false
+      }, lease.controller.signal)), lease);
+      if (this.#active !== lease || !lease.liveOwner) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+      const stopped = this.fatal(id);
+      if (stopped) throw new CloudDoError(stopped);
+      this.ledger.countModel(id, this.#limits().modelSteps, Date.now(), {
+        inputBytes: info.inputBytes,
+        inputTokens: CLOUD_BUDGET.inputTokens,
+        outputTokens: CLOUD_BUDGET.outputTokens
+      });
+    } catch (error) {
+      throw new CloudDoError(this.#recordFatal(id, safeCloudError(error).code));
+    }
+    const seen = { input: 0, output: 0 };
+    const record2 = (work) => {
+      try {
+        work();
+      } catch {
+        throw new CloudDoError(this.#recordFatal(id, "CLOUD_MODEL_REQUEST_FAILED"));
+      }
+    };
+    return {
+      sent: () => record2(() => this.ledger.markModelSent(id)),
+      usage: (usage) => record2(() => {
+        const input = usage.input ?? seen.input;
+        const output = usage.output ?? seen.output;
+        if (!Number.isSafeInteger(input) || !Number.isSafeInteger(output) || input < seen.input || output < seen.output) {
+          throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+        }
+        if (input !== seen.input || output !== seen.output) this.ledger.addModelUsage(id, input - seen.input, output - seen.output);
+        seen.input = input;
+        seen.output = output;
+      })
+    };
+  }
+  #requestSignal(native) {
+    const signals = [...native ? [native] : [], ...this.#active ? [this.#active.controller.signal] : []];
+    return AbortSignal.any(signals);
+  }
+  async #recover(harness, replay) {
+    for (const id of this.#stale) {
+      this.#recordFatal(id, "CLOUD_EXECUTION_INTERRUPTED");
+      const conversation = await harness.conversation(id, BACKGROUND_CONTEXT);
+      if (conversation) {
+        await conversation.abort(BACKGROUND_CONTEXT, { background: true });
+        await conversation.waitForIdle(BACKGROUND_CONTEXT);
+      }
+    }
+    for (const row2 of replay) {
+      if (!this.#config || !this.#dispatcher) {
+        this.ledger.finish(row2.invocationId, "failed", void 0, "CLOUD_EXECUTION_INTERRUPTED");
+        continue;
+      }
+      await this.#runInvocation(row2, void 0, true).catch(() => void 0);
+    }
+    await this.#adjudicateRuns(harness);
+    await this.#backfillTurns(harness);
+    await this.cloud.rearmAlarm({ busy: false, repairRetrying: false });
+    this.#recovered = true;
+    this.#recoveryGuard?.dispose();
+    this.#recoveryGuard = void 0;
+  }
+  async #backfillTurns(harness) {
+    let before = Number.MAX_SAFE_INTEGER;
+    for (; ; ) {
+      const runs = this.cloud.pendingBackfills(before);
+      if (!runs.length) return;
+      for (const run of runs) {
+        let seqs;
+        try {
+          const conversation = await harness.conversation(run.conversationId, BACKGROUND_CONTEXT);
+          const view = conversation ? await conversation.context(BACKGROUND_CONTEXT) : void 0;
+          seqs = view ? runInputSeqs(view.entries) : [];
+        } catch {
+          continue;
+        }
+        this.cloud.applyBackfill(run.conversationId, seqs);
+      }
+      before = runs[runs.length - 1].conversationId;
+    }
+  }
+  async #execute(name, args, api, context) {
+    try {
+      return await this.#executeChecked(name, args, api, context);
+    } catch (error) {
+      const code = this.#toolErrorCode(error);
+      this.#recordFatal(api.conversationId, code);
+      try {
+        if (error instanceof StaleInvocationAttempt) {
+          const harness = await this.#opened;
+          void harness.abortTask(api.taskId, BACKGROUND_CONTEXT).catch(() => void 0);
+          await harness.getTask(api.taskId, BACKGROUND_CONTEXT);
+        }
+      } catch {
+      }
+      return this.#errorResult(code);
+    }
+  }
+  async #executeChecked(name, args, api, context) {
+    if (this.#stale.has(api.conversationId) || !this.#config || !this.#dispatcher) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    const task = await api.getTask(api.taskId, context);
+    const input = task?.input;
+    if (!input || typeof input !== "object" || Array.isArray(input) || typeof input.assistant !== "number") {
+      throw new CloudDoError("CLOUD_TOOL_FAILED");
+    }
+    this.#guard().guardPayload(canonicalArgs({ name, id: api.callId, args }));
+    const id = await invocationId(api.conversationId, input.assistant, api.callId);
+    const execution = this.ledger.execution(api.conversationId);
+    if (!execution) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+    const begun = this.ledger.begin({
+      invocationId: id,
+      sessionId: this.#config.identity.sessionId,
+      conversationId: api.conversationId,
+      assistantEntryId: input.assistant,
+      toolCallId: api.callId,
+      toolName: name,
+      argsDigest: await argsDigest(name, args),
+      argsJson: canonicalArgs(args),
+      replay: replayForTool(name),
+      deadlineAt: Math.min(Date.now() + this.#limits().callTimeoutMs, execution.deadlineAt)
+    });
+    if (begun.kind === "pending") {
+      const pending = this.#invocations.get(id);
+      if (!pending) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+      await pending;
+    } else if (begun.kind === "started") {
+      const running = this.#runInvocation(begun.row, context.abortSignal, false);
+      this.#invocations.set(id, running);
+      try {
+        await running;
+      } finally {
+        this.#invocations.delete(id);
+      }
+    }
+    return this.#modelResult(this.ledger.read(id));
+  }
+  #modelResult(row2) {
+    const result = this.#result(row2);
+    const error = result.error;
+    if (Object.hasOwn(result, "modelView")) return {
+      isError: result.ok === false,
+      content: [{ type: "text", text: JSON.stringify(result.modelView) }]
+    };
+    if (result.ok === false) {
+      if (this.#dispatcher?.domainErrors?.includes(error.code)) return {
+        isError: true,
+        content: [{ type: "text", text: JSON.stringify({ ok: false, error }) }]
+      };
+      return this.#errorResult(error.code);
+    }
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  }
+  #errorResult(code) {
+    const fixed = safeCloudError(new Error(typeof code === "string" ? code : "CLOUD_TOOL_FAILED")).code;
+    return { isError: true, content: [{ type: "text", text: JSON.stringify({ ok: false, error: { code: fixed } }) }] };
+  }
+  #toolErrorCode(error) {
+    const code = safeCloudError(error).code;
+    return code === "CLOUD_MODEL_REQUEST_FAILED" ? "CLOUD_TOOL_FAILED" : code;
+  }
+  #recordFatal(conversationId, code) {
+    let first = this.#fatalDispositions.get(conversationId);
+    if (!first) {
+      try {
+        const stored = this.ledger.execution(conversationId)?.fatalCode;
+        first = stored ? this.#toolErrorCode(new Error(stored)) : code;
+      } catch {
+        first = code;
+      }
+      this.#fatalDispositions.set(conversationId, first);
+    }
+    try {
+      this.ledger.failExecution(conversationId, first);
+    } catch {
+    }
+    return first;
+  }
+  #result(row2) {
+    if (row2.state !== "succeeded" || row2.resultJson === null) throw new CloudDoError(row2.errorCode ?? "CLOUD_TOOL_FAILED");
+    return JSON.parse(row2.resultJson);
+  }
+  async #runInvocation(row2, native, recovery) {
+    const lease = recovery ? void 0 : this.#active;
+    const controller = new AbortController();
+    let deadline = row2.deadlineAt;
+    const signals = [controller.signal, ...native ? [native] : [], ...lease ? [lease.controller.signal] : []];
+    const signal = AbortSignal.any(signals);
+    let timer;
+    let removeAbort;
+    try {
+      deadline = Math.min(row2.deadlineAt, this.ledger.execution(row2.conversationId)?.deadlineAt ?? row2.deadlineAt);
+      if (Date.now() >= deadline) throw new CloudDoError("CLOUD_TOOL_TIMEOUT");
+      if (!this.#config || !this.#dispatcher) throw new CloudDoError("CLOUD_EXECUTION_INTERRUPTED");
+      if (!recovery && this.fatal(row2.conversationId)) throw new CloudDoError(this.fatal(row2.conversationId));
+      const args = JSON.parse(row2.argsJson);
+      await admitCloudPayload(this.env, args, lease?.profile);
+      if (Date.now() >= deadline) throw new CloudDoError(this.#timeoutCode(row2.conversationId));
+      signal.throwIfAborted();
+      const cancelled = new Promise((_resolve, reject) => {
+        const abort = () => reject(new CloudDoError(Date.now() >= deadline ? Date.now() >= (this.ledger.execution(row2.conversationId)?.deadlineAt ?? Infinity) ? "CLOUD_EXECUTION_TIMEOUT" : "CLOUD_TOOL_TIMEOUT" : "CLOUD_EXECUTION_ABORTED"));
+        signal.addEventListener("abort", abort, { once: true });
+        removeAbort = () => signal.removeEventListener("abort", abort);
+        if (signal.aborted) abort();
+      });
+      timer = setTimeout(() => controller.abort(), Math.max(0, deadline - Date.now()));
+      await Promise.race([Promise.resolve().then(() => this.#renew({
+        nativeRunId: row2.conversationId,
+        requestId: this.cloud.readRun(row2.conversationId)?.requestId ?? null,
+        kind: "tool",
+        toolName: row2.toolName,
+        recovery
+      }, signal)), cancelled]);
+      if (Date.now() >= deadline) throw new CloudDoError(this.#timeoutCode(row2.conversationId));
+      signal.throwIfAborted();
+      if (!recovery && this.fatal(row2.conversationId)) throw new CloudDoError(this.fatal(row2.conversationId));
+      if ((this.ledger.execution(row2.conversationId)?.credits ?? 0) > CLOUD_BUDGET.credits) throw new CloudDoError("CLOUD_BUDGET_EXCEEDED");
+      const usesFetchSlot = this.#dispatcher.tools.find((tool) => tool.name === row2.toolName)?.execution !== "pure";
+      if (usesFetchSlot && this.#inline >= this.#limits().inlineFetches) throw new CloudDoError("CLOUD_TOOL_BUSY");
+      if (usesFetchSlot) this.#inline++;
+      const dispatchContext = Object.freeze({
+        identity: Object.freeze({ ...this.#config.identity }),
+        principal: Object.freeze({ ...this.#config.principal }),
+        scopes: Object.freeze([...this.#config.scopes]),
+        dispatcherId: this.#config.dispatcherId,
+        call: Object.freeze({ invocationId: row2.invocationId, conversationId: row2.conversationId, toolCallId: row2.toolCallId, attempt: row2.attempt }),
+        lookup: (id) => {
+          const found = this.ledger.read(id);
+          if (!found || found.sessionId !== this.#config?.identity.sessionId) return void 0;
+          return Object.freeze({
+            toolName: found.toolName,
+            state: found.state,
+            errorCode: found.errorCode,
+            resultJson: found.resultJson,
+            conversationId: found.conversationId,
+            toolCallId: found.toolCallId,
+            settledAt: found.settledAt,
+            settledEventSeq: found.settledEventSeq
+          });
+        }
+      });
+      const dispatcher = this.#dispatcher;
+      const work = Promise.resolve().then(() => {
+        if (Date.now() >= deadline) throw new CloudDoError(this.#timeoutCode(row2.conversationId));
+        signal.throwIfAborted();
+        return dispatcher.execute(dispatchContext, row2.toolName, args, signal);
+      });
+      void work.finally(() => {
+        if (usesFetchSlot) this.#inline--;
+      }).catch(() => void 0);
+      let result = await Promise.race([work, cancelled]);
+      try {
+        await admitCloudPayload(this.env, result, lease?.profile);
+        result = JSON.parse(this.#guard().guardPayload(JSON.stringify(result)));
+      } catch (error) {
+        if (error instanceof CloudDoError && error.code === "CLOUD_USER_CREDENTIAL_REJECTED") {
+          throw new CloudDoError("CLOUD_MODEL_RESPONSE_REJECTED");
+        }
+        throw error;
+      }
+      if (Object.hasOwn(result, "modelView") && !this.#dispatcher.modelViews) throw new CloudDoError("CLOUD_TOOL_FAILED");
+      const usage = result.usage;
+      if (!usage || typeof usage !== "object" || Array.isArray(usage) || !Number.isSafeInteger(usage.credits) || Number(usage.credits) < 0) {
+        throw new CloudDoError("CLOUD_TOOL_USAGE_INVALID");
+      }
+      if (typeof result.ok !== "boolean" || result.ok && result.error != null) throw new CloudDoError("CLOUD_TOOL_FAILED");
+      let responseFailure;
+      if (result.ok === false) {
+        const rawCode = result.error && typeof result.error === "object" && !Array.isArray(result.error) ? result.error.code : void 0;
+        const domainCode = typeof rawCode === "string" && Object.hasOwn(CLOUD_DOMAIN_ERROR_CODES, rawCode) ? CLOUD_DOMAIN_ERROR_CODES[rawCode] : void 0;
+        if (typeof rawCode === "string" && this.#dispatcher.domainErrors?.includes(rawCode)) {
+          const rawError = result.error;
+          const hasData = Object.hasOwn(rawError, "data");
+          if (hasData && new TextEncoder().encode(JSON.stringify(rawError.data)).length > 2048) throw new CloudDoError("CLOUD_TOOL_RESULT_LIMIT");
+          result = { ...result, error: { code: rawCode, ...hasData ? { data: rawError.data } : {} } };
+        } else {
+          const code = domainCode ?? "CLOUD_TOOL_FAILED";
+          const bill = usage;
+          result = { ok: false, error: { code }, usage: {
+            credits: bill.credits,
+            ...Number.isSafeInteger(bill.rows) && Number(bill.rows) >= 0 ? { rows: bill.rows } : {},
+            ...typeof bill.cached === "boolean" ? { cached: bill.cached } : {}
+          } };
+          if (!domainCode) responseFailure = code;
+        }
+      }
+      if (new TextEncoder().encode(JSON.stringify(result)).length > this.#limits().resultBytes) throw new CloudDoError("CLOUD_TOOL_RESULT_LIMIT");
+      const settled = this.ledger.finish(row2.invocationId, "succeeded", result, void 0, Date.now(), {
+        attempt: row2.attempt,
+        clientConnected: recovery || lease?.connected === true,
+        recovery,
+        creditCap: CLOUD_BUDGET.credits
+      });
+      if (!settled) throw new CloudDoError("CLOUD_TOOL_FAILED");
+      if (settled.attempt !== row2.attempt) throw new StaleInvocationAttempt();
+      if (responseFailure && !recovery) this.#recordFatal(row2.conversationId, responseFailure);
+      return this.#result(settled);
+    } catch (error) {
+      if (error instanceof StaleInvocationAttempt) throw error;
+      const code = signal.aborted ? Date.now() >= deadline ? this.#timeoutCode(row2.conversationId) : "CLOUD_EXECUTION_ABORTED" : this.#toolErrorCode(error);
+      const state = code === "CLOUD_TOOL_TIMEOUT" || code === "CLOUD_EXECUTION_TIMEOUT" ? "timed_out" : code === "CLOUD_EXECUTION_ABORTED" ? "aborted" : "failed";
+      let settled;
+      try {
+        settled = this.ledger.finish(row2.invocationId, state, void 0, code, Date.now(), { attempt: row2.attempt, recovery });
+      } catch {
+      }
+      if (settled && settled.attempt !== row2.attempt) throw new StaleInvocationAttempt();
+      if (!recovery) this.#recordFatal(row2.conversationId, code);
+      throw new CloudDoError(code);
+    } finally {
+      clearTimeout(timer);
+      removeAbort?.();
+      controller.abort();
+    }
+  }
+  #timeoutCode(conversationId) {
+    return Date.now() >= (this.ledger.execution(conversationId)?.deadlineAt ?? Infinity) ? "CLOUD_EXECUTION_TIMEOUT" : "CLOUD_TOOL_TIMEOUT";
+  }
+};
+
+// src/event-stream.ts
+var CloudEventDoorbell = class {
+  generation = 0;
+  listeners = /* @__PURE__ */ new Set();
+  ring() {
+    this.generation++;
+    for (const listener of [...this.listeners]) listener();
+  }
+  get version() {
+    return this.generation;
+  }
+  wait(version, signal, duration = 15e3) {
+    return new Promise((resolve) => {
+      let timer;
+      const finish = () => {
+        clearTimeout(timer);
+        this.listeners.delete(finish);
+        signal.removeEventListener("abort", finish);
+        resolve();
+      };
+      timer = setTimeout(finish, duration);
+      this.listeners.add(finish);
+      signal.addEventListener("abort", finish, { once: true });
+      if (signal.aborted || version !== this.generation) finish();
+    });
+  }
+};
+var CloudEventStreams = class {
+  constructor(bell) {
+    this.bell = bell;
+  }
+  bell;
+  readers = 0;
+  open(state, after, waitUntil) {
+    if (this.readers >= 8) throw new CloudDoError("CLOUD_EVENTS_BUSY");
+    const meta = state.eventMeta();
+    const cursor = after === void 0 ? meta.highWater : after === 0 ? meta.trimmedThrough : after;
+    try {
+      state.eventPage(cursor, 1);
+    } catch (error) {
+      if (safeCloudError(error).code === "CLOUD_EVENT_CURSOR_EXPIRED") return Response.json({ error: { code: "CLOUD_EVENT_CURSOR_EXPIRED", retryable: false }, ...meta }, { status: 410 });
+      throw error;
+    }
+    this.readers++;
+    const body = new IdentityTransformStream();
+    const writer = body.writable.getWriter();
+    const controller = new AbortController();
+    const encoder2 = new TextEncoder();
+    let cleaned = false;
+    let last = cursor;
+    const close = () => {
+      if (!cleaned) {
+        cleaned = true;
+        this.readers--;
+        controller.abort();
+      }
+    };
+    const limit = setTimeout(() => {
+      close();
+      void writer.abort().catch(() => void 0);
+    }, 11e4);
+    void writer.closed.catch(close);
+    let probing = false;
+    const probe = setInterval(() => {
+      if (controller.signal.aborted || probing) return;
+      probing = true;
+      void writer.write(encoder2.encode(": keepalive\n\n")).catch(close).finally(() => {
+        probing = false;
+      });
+    }, 250);
+    const run = async () => {
+      try {
+        while (!controller.signal.aborted) {
+          const version = this.bell.version;
+          let rows;
+          try {
+            rows = state.eventPage(last);
+          } catch (error) {
+            if (safeCloudError(error).code !== "CLOUD_EVENT_CURSOR_EXPIRED") throw error;
+            await writer.write(encoder2.encode("event: reset\ndata: " + JSON.stringify(state.eventMeta()) + "\n\n"));
+            break;
+          }
+          for (const row2 of rows) {
+            if (controller.signal.aborted) break;
+            await writer.write(encoder2.encode("id: " + row2.seq + "\nevent: " + row2.type + "\ndata: " + row2.dataJson + "\n\n"));
+            last = row2.seq;
+          }
+          if (!rows.length && !controller.signal.aborted) {
+            await this.bell.wait(version, controller.signal);
+            if (!controller.signal.aborted && version === this.bell.version) await writer.write(encoder2.encode(": keepalive\n\n"));
+          }
+        }
+        try {
+          await writer.close();
+        } catch {
+        }
+      } catch {
+        try {
+          await writer.abort();
+        } catch {
+        }
+      } finally {
+        clearTimeout(limit);
+        clearInterval(probe);
+        close();
+      }
+    };
+    waitUntil(run());
+    return new Response(body.readable, { headers: { "content-type": "text/event-stream", "cache-control": "no-store" } });
+  }
+};
+async function cloudRunHistory(runtime, harness) {
+  const history = [];
+  for (const run of runtime.cloud.completedRuns()) {
+    const conversation = await harness.conversation(run.conversationId, BACKGROUND_CONTEXT);
+    if (!conversation) continue;
+    let view;
+    try {
+      view = await conversation.context(BACKGROUND_CONTEXT);
+    } catch (error) {
+      if (run.membershipPending === 1) continue;
+      throw error;
+    }
+    const input = run.trigger === "wake" ? view.entries.find((entry2) => entry2.kind === "byok.run-input")?.data : view.entries.find((entry2) => entry2.kind === "pi.user")?.model?.find((message) => message.role === "user")?.content;
+    const entry = [...view.entries].reverse().find((entry2) => entry2.kind === "pi.assistant");
+    const reply = entry?.model?.find((message) => message.role === "assistant");
+    if (input === void 0 || reply?.role !== "assistant") continue;
+    history.push({ input, reply: reply.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") });
+  }
+  return history;
+}
+async function committedRunOutcome(conversation, runtime, status2, detail) {
+  const view = await conversation.context(BACKGROUND_CONTEXT);
+  const entry = [...view.entries].reverse().find((entry2) => entry2.kind === "pi.assistant");
+  const last = entry?.model?.find((message) => message.role === "assistant");
+  const failure = runtime.fatal(conversation.id) ?? (last?.role === "assistant" && (last.stopReason === "error" || last.stopReason === "aborted") ? safeCloudError(new Error(last.errorMessage)).code : void 0) ?? (status2 !== "done" ? safeCloudError(new Error(typeof detail === "string" ? detail : "")).code : void 0);
+  if (failure) return { state: "failed", errorCode: failure };
+  return {
+    state: "completed",
+    entryId: entry?.id,
+    text: last?.role === "assistant" ? last.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") : ""
+  };
+}
+async function runCloudWake(runtime, harness, env, admit, notify, retryCount = 0) {
+  const guard = await runtime.prepareGuard();
+  let lease;
+  let conversation;
+  let selected = [];
+  let settling = false;
+  try {
+    runtime.cloud.expireQueued(guard);
+    runtime.cloud.retention();
+    selected = runtime.cloud.selectBatch(Date.now(), guard);
+    notify();
+    if (!selected.length) {
+      await runtime.cloud.rearmAlarm({ busy: runtime.hasLiveOwner, repairRetrying: runtime.repairRetrying });
+      return false;
+    }
+    lease = runtime.reserve(selected[0].profile, guard);
+    const profile = PLATFORM_PROFILES[lease.profile];
+    conversation = await harness.createConversation({
+      ownership: { kind: "ownerless" },
+      agent: runtime.agentChange(lease.profile, guard)
+    }, BACKGROUND_CONTEXT);
+    runtime.attach(lease, conversation.id, "wake", guard);
+    const identity = admissionIdentity(selected);
+    runtime.markReservation(conversation.id, "pending", identity);
+    const key = runtime.cloud.readRun(conversation.id).requestId;
+    const admission = await raceLease(Promise.resolve().then(() => admit(
+      Object.freeze(selected.map((row2) => Object.freeze({ ...row2 }))),
+      lease.controller.signal,
+      key,
+      identity
+    )), lease);
+    if (!admission || typeof admission !== "object" || typeof admission.accepted !== "boolean") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    if (!admission.accepted) {
+      runtime.markReservation(conversation.id, "none");
+      throw safeCloudError(new Error(admission.code));
+    }
+    if (admission.reservation !== "held" && admission.reservation !== "none") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    runtime.markReservation(conversation.id, admission.reservation);
+    await platformCredentialReader(env).get(profile.secretName);
+    const claimed = runtime.claimWake(lease, selected.map((row2) => row2.seq));
+    notify();
+    if (!claimed.length) {
+      const closed = runtime.cloud.readRun(conversation.id);
+      if (closed?.errorCode && closed.errorCode !== "CLOUD_WAKE_EMPTY") throw new CloudDoError(closed.errorCode);
+      return true;
+    }
+    const inputs = { items: inboxInput(claimed) };
+    const data = JSON.parse(guard.guardPayload(JSON.stringify(inputs)));
+    await conversation.commit((tx) => {
+      if (lease.controller.signal.aborted) throw new CloudDoError(runtime.fatal(conversation.id) ?? "CLOUD_EXECUTION_ABORTED");
+      return tx.appendEntry(conversation.id, { kind: "byok.run-input", data });
+    }, BACKGROUND_CONTEXT);
+    const committed = (await conversation.context(BACKGROUND_CONTEXT)).entries.find((entry) => entry.kind === "byok.run-input")?.data;
+    const durable = claimed.filter((row2) => committed?.items.some((item) => item.seq === row2.seq && item.text === JSON.parse(row2.payloadJson).text)).map((row2) => row2.seq);
+    runtime.cloud.markInputDurable(conversation.id, durable);
+    const content = composeCloudInput(claimed, await cloudRunHistory(runtime, harness));
+    guard.guardText(content);
+    const submission = await conversation.submit({ type: "input", content, whenBusy: "reject", requestId: key }, BACKGROUND_CONTEXT);
+    runtime.recordSubmission(conversation.id, submission.id);
+    const settled = await submission.wait(BACKGROUND_CONTEXT);
+    await conversation.waitForIdle(BACKGROUND_CONTEXT);
+    const outcome = await committedRunOutcome(conversation, runtime, settled.status, settled.status === "unanswered" ? settled.detail : void 0);
+    settling = true;
+    await runtime.settle(lease, outcome);
+  } catch (error) {
+    if (!lease || error instanceof CloudDoError && error.code === "CLOUD_TOOL_BUSY") {
+      if (error instanceof CloudDoError && error.code === "CLOUD_TOOL_BUSY") return false;
+      throw safeCloudError(error);
+    }
+    if (settling || !(error instanceof CloudDoError)) throw safeCloudError(error);
+    const code = (lease.conversationId === void 0 ? void 0 : runtime.fatal(lease.conversationId)) ?? safeCloudError(error).code;
+    runtime.cloud.failQueued(selected.map((row2) => row2.seq), code, guard);
+    if (conversation && runtime.cloud.readRun(conversation.id)?.state === "running") {
+      runtime.cancel(lease, code);
+      await conversation.abort(BACKGROUND_CONTEXT, { background: true });
+      await conversation.waitForIdle(BACKGROUND_CONTEXT);
+    }
+    if (conversation) {
+      settling = true;
+      await runtime.settle(lease, { state: "interrupted", errorCode: code });
+    }
+    notify();
+  } finally {
+    if (lease) await runtime.release(lease, retryCount);
+    else guard.dispose();
+  }
+  return lease !== void 0;
+}
+
+// src/agent-do.ts
+function modelFailureCode(message) {
+  return safeCloudError(new Error(message)).code;
+}
+function assistantText(message) {
+  return message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("");
+}
+function finalAssistant(entries) {
+  const entry = [...entries].reverse().find((entry2) => entry2.kind === "pi.assistant" && entry2.model?.some((message) => message.role === "assistant" && message.stopReason !== "toolUse"));
+  const assistant = entry?.model?.find((message) => message.role === "assistant" && message.stopReason !== "toolUse");
+  return assistant?.role === "assistant" && entry ? { entry, assistant } : void 0;
+}
+function inputTexts(entries) {
+  const seqs = new Set(runInputSeqs(entries));
+  if (!seqs.size) return /* @__PURE__ */ new Map();
+  const data = entries.find((entry) => entry.kind === "byok.run-input")?.data;
+  return new Map((data?.items ?? []).filter((item) => seqs.has(item.seq)).map((item) => [item.seq, item.text]));
+}
+function transcriptRecord(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+  const result = {};
+  for (const key of Reflect.ownKeys(value)) {
+    const field = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || !keys.includes(key) || !field?.enumerable || !("value" in field)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    result[key] = field.value;
+  }
+  return result;
+}
+function projectText(blocks, event) {
+  const replace = (message) => {
+    blocks.clear();
+    message.content.forEach((block, index) => {
+      if (block.type === "text") blocks.set(index, block.text);
+    });
+  };
+  if (event.type === "message_start" && event.message.role === "assistant") replace(event.message);
+  else if (event.type === "snapshot" && event.generation?.message) replace(event.generation.message);
+  else if (event.type === "message_update") {
+    for (const change of event.changes) {
+      if (change.type === "text_delta") blocks.set(change.contentIndex, (blocks.get(change.contentIndex) ?? "") + change.delta);
+      if (change.type === "text_start" || change.type === "block") {
+        if (change.block.type === "text") blocks.set(change.contentIndex, change.block.text);
+        else blocks.delete(change.contentIndex);
+      }
+      if (change.type === "message") replace(change.message);
+    }
+  } else if (event.type === "message_end" && event.entry.model?.[0]?.role === "assistant") return assistantText(event.entry.model[0]);
+  else return void 0;
+  return [...blocks.entries()].sort(([a], [b]) => a - b).map(([, text2]) => text2).join("");
+}
+var AgentDO = class extends DurableObject {
+  #runtime;
+  #doorbell = new CloudEventDoorbell();
+  #eventStreams = new CloudEventStreams(this.#doorbell);
+  /** The consuming Worker supplies trusted code. No executable function is persisted. */
+  createDispatcher(_id) {
+    return void 0;
+  }
+  /** Post-commit notification. Consumer failures never change the invocation outcome. */
+  onInvocationSettled(_id, _state) {
+  }
+  projectInvocation(_row) {
+    return void 0;
+  }
+  /** The consumer owns billing truth and fences every pending admission key on release. */
+  admitWake(_items, _signal, _key, _admission) {
+    return { accepted: true, reservation: "none" };
+  }
+  instructions(_profile) {
+    return void 0;
+  }
+  renew(_request, _signal) {
+    return { ok: true };
+  }
+  settleRun(_run, _signal) {
+  }
+  sessionRuntime() {
+    return this.#runtime ??= new SessionRuntime(this.ctx, this.env, {
+      createDispatcher: (id) => this.createDispatcher(id),
+      projectInvocation: (row2) => this.projectInvocation(row2),
+      onCommit: () => this.#doorbell.ring(),
+      onInvocationSettled: (id, state) => this.onInvocationSettled(id, state),
+      instructions: (profile) => this.instructions(profile),
+      renew: (request, signal) => this.renew(request, signal),
+      settleRun: (run, signal) => this.settleRun(run, signal)
+    });
+  }
+  async configureSession(input) {
+    try {
+      await this.sessionRuntime().configure(input);
+      return Response.json({ configured: true });
+    } catch (error) {
+      return cloudErrorResponse(error);
+    }
+  }
+  async readInvocation(id) {
+    await this.sessionRuntime().ready();
+    if (typeof id !== "string" || !/^[a-f0-9]{64}$/.test(id)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    return this.sessionRuntime().readInvocation(id);
+  }
+  async enqueue(input) {
+    let guard;
+    try {
+      const admitted = admitCloudInbox(input);
+      const runtime = this.sessionRuntime();
+      guard = await runtime.prepareGuard();
+      runtime.cloud.validateEnqueue(admitted, guard);
+      await runtime.ready();
+      const result = await runtime.cloud.enqueue(admitted, guard, Date.now(), {
+        busy: runtime.hasLiveOwner,
+        repairRetrying: runtime.repairRetrying
+      });
+      this.#doorbell.ring();
+      return Response.json({ accepted: result.accepted, ...result.row });
+    } catch (error) {
+      return cloudErrorResponse(error);
+    } finally {
+      guard?.dispose();
+    }
+  }
+  /** The platform supplies retryCount. This handler never replaces a live owner. */
+  async alarm(info) {
+    const runtime = this.sessionRuntime();
+    let harness;
+    try {
+      harness = await runtime.ready();
+    } catch (error) {
+      if (runtime.recovering) return;
+      throw safeCloudError(error);
+    }
+    if (runtime.hasLiveOwner) {
+      const guard = runtime.activeLease?.guard;
+      if (guard) runtime.cloud.expireQueued(guard);
+      runtime.cloud.retention();
+      this.#doorbell.ring();
+      if (runtime.cloud.unackedRuns().length) await runtime.deliverSettlementsForAlarm(info?.retryCount ?? 0, guard);
+      else await runtime.cloud.rearmAlarm({ busy: true, repairRetrying: runtime.repairRetrying });
+      return;
+    }
+    try {
+      await runtime.repairPendingRuns(info?.retryCount ?? 0);
+      if (runtime.busy) return;
+      const woke = await runCloudWake(
+        runtime,
+        harness,
+        this.env,
+        (items, signal, key, admission) => this.admitWake(items, signal, key, admission),
+        () => this.#doorbell.ring(),
+        info?.retryCount ?? 0
+      );
+      if (!woke) await runtime.deliverSettlementsForAlarm(info?.retryCount ?? 0);
+    } catch (error) {
+      throw safeCloudError(error);
+    }
+  }
+  async events(input = {}) {
+    try {
+      const fields2 = this.#readOptions(input, ["after"]);
+      const runtime = this.sessionRuntime();
+      await runtime.ready();
+      return this.#eventStreams.open(runtime.cloud, fields2.after, (work) => this.ctx.waitUntil(work));
+    } catch (error) {
+      return cloudErrorResponse(error);
+    }
+  }
+  async readSnapshot() {
+    await this.sessionRuntime().ready();
+    return this.sessionRuntime().cloud.snapshot();
+  }
+  async readRuns(input = {}) {
+    await this.sessionRuntime().ready();
+    return this.sessionRuntime().cloud.readRuns(this.#readOptions(input, ["after", "limit"]));
+  }
+  async readInbox(input = {}) {
+    await this.sessionRuntime().ready();
+    return this.sessionRuntime().cloud.readInbox(this.#readOptions(input, ["after", "limit"]));
+  }
+  async readInvocations(input = {}) {
+    await this.sessionRuntime().ready();
+    return this.sessionRuntime().cloud.readInvocations(this.#readOptions(input, ["after", "limit"]));
+  }
+  async readTranscript(input = {}) {
+    const options = transcriptRecord(input, ["after", "limit"]);
+    const limit = options.limit === void 0 ? 20 : options.limit;
+    if (typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 1 || limit > 50) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    let after;
+    if (options.after !== void 0) {
+      const cursor = transcriptRecord(options.after, ["horizon", "run", "item"]);
+      if (Object.keys(cursor).length !== 3 || typeof cursor.horizon !== "number" || !Number.isSafeInteger(cursor.horizon) || cursor.horizon < 0 || [cursor.run, cursor.item].some((value) => value !== null && (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0))) {
+        throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      }
+      after = cursor;
+    }
+    const runtime = this.sessionRuntime();
+    const harness = await runtime.ready();
+    const plan = runtime.cloud.planTranscript(after, limit);
+    const contexts = /* @__PURE__ */ new Map();
+    const entries = (id) => {
+      const cached = contexts.get(id);
+      if (cached) return cached;
+      const read = harness.conversation(id, BACKGROUND_CONTEXT).then(async (conversation) => conversation ? (await conversation.context(BACKGROUND_CONTEXT)).entries : []).catch((error) => {
+        if (runtime.cloud.readRun(id)?.membershipPending === 1) return [];
+        throw error;
+      });
+      contexts.set(id, read);
+      return read;
+    };
+    const runs = [];
+    for (const { run, turns, invocations } of plan.runs) {
+      const claimedSeqs = runtime.cloud.claimedSeqs(run.conversationId);
+      const view = await entries(run.conversationId);
+      const texts = inputTexts(view);
+      const final = finalAssistant(view);
+      const result = {
+        nativeRunId: run.conversationId,
+        revision: run.revision,
+        state: run.state,
+        errorCode: run.errorCode,
+        trigger: run.trigger,
+        settlementAck: run.settlementAck === null || run.settlementAck === 1,
+        claimedSeqs,
+        turns: turns.map((turn) => ({ ...turn, text: texts.get(turn.seq) ?? turn.text })),
+        invocations
+      };
+      if (final) {
+        const text2 = assistantText(final.assistant);
+        const truncated = new TextEncoder().encode(text2).length > 16384;
+        result.text = truncated ? utf8Prefix(text2, 1024) : text2;
+        if (truncated) result.truncated = true;
+      }
+      runs.push(result);
+    }
+    for (const item of plan.items) if (item.text === null && item.runId !== null) {
+      item.text = inputTexts(await entries(item.runId)).get(item.seq) ?? null;
+    }
+    return { runs, items: plan.items, next: plan.next };
+  }
+  #readOptions(input, allowed) {
+    if (!input || typeof input !== "object" || Array.isArray(input) || Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const result = {};
+    for (const key of Reflect.ownKeys(input)) {
+      const field = Object.getOwnPropertyDescriptor(input, key);
+      if (typeof key !== "string" || !allowed.includes(key) || !field?.enumerable || !("value" in field) || field.value !== void 0 && typeof field.value !== "number") throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      result[key] = field.value;
+    }
+    return result;
+  }
+  async readRunOutput(conversationId, input = {}) {
+    if (!Number.isSafeInteger(conversationId) || conversationId < 2) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const options = this.#readOptions(input, ["entryId", "offset"]);
+    const runtime = this.sessionRuntime();
+    const harness = await runtime.ready();
+    if (!runtime.cloud.readRun(conversationId)) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const conversation = await harness.conversation(conversationId, BACKGROUND_CONTEXT);
+    if (!conversation) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const context = await conversation.context(BACKGROUND_CONTEXT);
+    const final = finalAssistant(context.entries);
+    if (!final || options.entryId !== void 0 && options.entryId !== final.entry.id) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    const { entry, assistant } = final;
+    const bytes = new TextEncoder().encode(assistantText(assistant));
+    const offset = options.offset ?? 0;
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset > bytes.length || offset < bytes.length && (bytes[offset] & 192) === 128) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+    let end = Math.min(bytes.length, offset + 65536);
+    while (end < bytes.length && (bytes[end] & 192) === 128) end--;
+    return {
+      entryId: entry.id,
+      offset,
+      nextOffset: end,
+      done: end === bytes.length,
+      text: new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(offset, end))
+    };
+  }
+  async cancelActiveRun() {
+    try {
+      const runtime = this.sessionRuntime();
+      await runtime.ready();
+      return Response.json({ cancelled: runtime.cancelActive() });
+    } catch (error) {
+      return cloudErrorResponse(error);
+    }
+  }
+  async cancelInboxItem(seq) {
+    let guard;
+    try {
+      if (!Number.isSafeInteger(seq) || seq < 1) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      const runtime = this.sessionRuntime();
+      await runtime.ready();
+      const row2 = runtime.cloud.readInboxItem(seq);
+      if (!row2) throw new CloudDoError("CLOUD_REQUEST_INVALID");
+      if (row2.state === "running") {
+        if (runtime.activeLease?.conversationId === row2.runId) runtime.cancelActive();
+      } else if (row2.state === "queued") {
+        guard = await runtime.prepareGuard();
+        runtime.cloud.cancelQueued(seq, guard);
+      }
+      await runtime.cloud.rearmAlarm({ busy: runtime.hasLiveOwner, repairRetrying: runtime.repairRetrying });
+      this.#doorbell.ring();
+      return Response.json({ item: runtime.cloud.readInboxItem(seq) });
+    } catch (error) {
+      return cloudErrorResponse(error);
+    } finally {
+      guard?.dispose();
+    }
+  }
+  // Admission and credential preflight happen before even schema initialization.
+  #harness() {
+    return this.sessionRuntime().open();
+  }
+  async open() {
+    const harness = await this.#harness();
+    return { scheduling: (await harness.inspect(BACKGROUND_CONTEXT)).scheduling };
+  }
+  /** D1: every call allocates a new ownerless conversation, including after a restart. */
+  async openExecution() {
+    const harness = await this.#harness();
+    const conversation = await harness.createConversation({ ownership: { kind: "ownerless" } }, BACKGROUND_CONTEXT);
+    return { conversationId: conversation.id };
+  }
+  async #execution(id) {
+    if (!Number.isSafeInteger(id) || id < 2) throw new Error("Invalid execution conversation");
+    const conversation = await (await this.#harness()).conversation(id, BACKGROUND_CONTEXT);
+    if (!conversation) throw new Error("Unknown execution conversation");
+    return conversation;
+  }
+  async #admitText(text2, selected) {
+    await admitCloudText(this.env, text2, selected);
+  }
+  /** Passive native pi entries prove storage without starting a model or tool task. */
+  async appendExecution(conversationId, text2) {
+    if (typeof text2 !== "string") throw new Error("Execution text must be a string");
+    await this.#admitText(text2);
+    const conversation = await this.#execution(conversationId);
+    await conversation.commit((tx) => tx.appendEntry(conversation.id, { kind: "byok.execution", data: { text: text2 } }), BACKGROUND_CONTEXT);
+  }
+  async readExecution(conversationId) {
+    const conversation = await this.#execution(conversationId);
+    const context = await conversation.context(BACKGROUND_CONTEXT);
+    return context.entries.filter((entry) => entry.kind === "byok.execution").map((entry) => {
+      const data = entry.data;
+      return data.text;
+    });
+  }
+  /** Binding/RPC-only. The consumer authorizes identity before obtaining this stub.
+   * Errors are structured Responses so the same code/status survive DO RPC. */
+  async submit(input) {
+    let lease;
+    let guard;
+    try {
+      const admitted = admitCloudSubmission(input);
+      const profile = PLATFORM_PROFILES[admitted.profile];
+      await platformCredentialReader(this.env).get(profile.secretName);
+      await this.#admitText(admitted.instruction, admitted.profile);
+      const runtime = this.sessionRuntime();
+      const harness = await runtime.ready(admitted.profile);
+      guard = await runtime.prepareGuard(admitted.profile);
+      lease = runtime.reserve(admitted.profile, guard);
+      const conversation = await harness.createConversation({
+        ownership: { kind: "ownerless" },
+        agent: runtime.agentChange(admitted.profile, guard)
+      }, BACKGROUND_CONTEXT);
+      const execution = lease;
+      runtime.attach(execution, conversation.id);
+      const events = await watchEvents(harness, conversation.id, BACKGROUND_CONTEXT);
+      const encoder2 = new TextEncoder();
+      let bodyController;
+      const body = new TransformStream({ start(controller) {
+        bodyController = controller;
+      } });
+      const writer = body.writable.getWriter();
+      let cancelled = false;
+      let aborting;
+      let failure;
+      let released = "";
+      const textBlocks = /* @__PURE__ */ new Map();
+      const deliveryGraceMs = 250;
+      let deliveryTimer;
+      const stopDelivery = () => {
+        cancelled = true;
+        clearTimeout(deliveryTimer);
+        clearInterval(probe);
+        bodyController.error(new CloudDoError("CLOUD_EXECUTION_ABORTED"));
+        void writer.abort().catch(() => void 0);
+      };
+      const boundAbortedDelivery = () => {
+        if (cancelled) return;
+        clearTimeout(deliveryTimer);
+        deliveryTimer = setTimeout(stopDelivery, deliveryGraceMs);
+      };
+      deliveryTimer = setTimeout(stopDelivery, Math.max(0, execution.deadlineAt - Date.now()) + deliveryGraceMs);
+      execution.controller.signal.addEventListener("abort", boundAbortedDelivery, { once: true });
+      if (execution.controller.signal.aborted) boundAbortedDelivery();
+      const cancel = () => {
+        stopDelivery();
+        if (!aborting && !execution.settled && execution.liveOwner) {
+          runtime.cancel(execution);
+          aborting = conversation.abort(BACKGROUND_CONTEXT).finally(() => events.stop()).catch(() => void 0);
+        }
+        return aborting;
+      };
+      void writer.closed.catch(cancel);
+      const write = async (value) => {
+        if (cancelled) return;
+        try {
+          await writer.write(encoder2.encode(`data: ${JSON.stringify(value)}
+
+`));
+        } catch {
+          void cancel();
+        }
+      };
+      let probing = false;
+      const probe = setInterval(() => {
+        if (cancelled || probing) return;
+        probing = true;
+        void writer.write(encoder2.encode(": keepalive\n\n")).catch(() => cancel()).finally(() => {
+          probing = false;
+        });
+      }, 250);
+      const publish = async (text2) => {
+        if (text2.startsWith(released) && text2.length > released.length) {
+          const delta = text2.slice(released.length);
+          released = text2;
+          await write({ type: "text_delta", delta });
+        }
+      };
+      events.start(async (batch) => {
+        for (const event of batch) {
+          if (event.type === "message_start" && event.message.role === "assistant") released = "";
+          const text2 = projectText(textBlocks, event);
+          if (text2 !== void 0) await publish(text2);
+          if (event.type === "message_end") {
+            const message = event.entry.model?.[0];
+            if (message?.role === "assistant" && message.stopReason === "error") {
+              failure = modelFailureCode(message.errorMessage);
+            }
+          }
+          if (event.type === "task_failed") failure ??= runtime.fatal(conversation.id) ?? "CLOUD_MODEL_REQUEST_FAILED";
+        }
+      });
+      const run = async () => {
+        let outcomeWriting = false;
+        let ownerReleased = false;
+        const release = async () => {
+          if (ownerReleased) return;
+          ownerReleased = true;
+          await runtime.release(execution);
+        };
+        try {
+          const submission = await conversation.submit({ type: "input", content: admitted.instruction, whenBusy: "reject", requestId: runtime.cloud.readRun(conversation.id).requestId }, BACKGROUND_CONTEXT);
+          runtime.recordSubmission(conversation.id, submission.id);
+          const settled = await submission.wait(BACKGROUND_CONTEXT);
+          await conversation.waitForIdle(BACKGROUND_CONTEXT);
+          const stopped = await events.stop();
+          const context = await conversation.context(BACKGROUND_CONTEXT);
+          const last = [...context.entries].reverse().find((entry) => entry.kind === "pi.assistant")?.model?.[0];
+          if (last?.role === "assistant" && last.stopReason === "error") failure = modelFailureCode(last.errorMessage);
+          failure = runtime.fatal(conversation.id) ?? failure;
+          if (settled.status !== "done" || stopped.reason === "listener_error") failure ??= "CLOUD_MODEL_REQUEST_FAILED";
+          const outcome = await committedRunOutcome(conversation, runtime, settled.status, settled.status === "unanswered" ? settled.detail : void 0);
+          if (failure) {
+            outcome.state = "failed";
+            outcome.errorCode = modelFailureCode(failure);
+            delete outcome.text;
+          }
+          outcomeWriting = true;
+          await runtime.settle(execution, outcome);
+          const committed = runtime.cloud.readRun(conversation.id);
+          if (committed?.state !== "completed") failure = committed?.errorCode ?? "CLOUD_MODEL_REQUEST_FAILED";
+          await release();
+          if (last?.role === "assistant") await publish(assistantText(last));
+          if (failure) await write({ type: "error", code: failure, retryable: false });
+          else await write({ type: "done", conversationId: conversation.id });
+        } catch (error) {
+          const code = runtime.fatal(conversation.id) ?? safeCloudError(error).code;
+          await events.stop();
+          if (!outcomeWriting && error instanceof CloudDoError && runtime.cloud.readRun(conversation.id)?.state === "running") {
+            runtime.cancel(execution, code);
+            await conversation.abort(BACKGROUND_CONTEXT, { background: true });
+            await conversation.waitForIdle(BACKGROUND_CONTEXT);
+            await runtime.settle(execution, { state: "failed", errorCode: code });
+          }
+          await release();
+          await write({ type: "error", code, retryable: false });
+        } finally {
+          try {
+            await release();
+            if (!cancelled) {
+              try {
+                await writer.close();
+              } catch {
+                void cancel();
+              }
+            }
+          } finally {
+            clearInterval(probe);
+            clearTimeout(deliveryTimer);
+            execution.controller.signal.removeEventListener("abort", boundAbortedDelivery);
+            if (!cancelled) stopDelivery();
+          }
+        }
+      };
+      this.ctx.waitUntil(run());
+      return new Response(body.readable, { headers: { "content-type": "text/event-stream", "cache-control": "no-store" } });
+    } catch (error) {
+      if (lease) await this.sessionRuntime().release(lease);
+      else guard?.dispose();
+      return cloudErrorResponse(error);
+    }
+  }
+};
+
+// src/identity.ts
+async function agentObjectName(identity) {
+  const ids = [identity.tenantId, identity.workspaceId, identity.agentId];
+  if (ids.some((id) => typeof id !== "string" || !id)) throw new Error("Agent identity requires three nonempty ids");
+  const digest2 = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(ids)));
+  return `agent:${Array.from(new Uint8Array(digest2), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+async function getAgentObject(namespace, identity) {
+  return namespace.getByName(await agentObjectName(identity));
+}
+async function sessionObjectName(identity) {
+  const ids = [identity.tenantId, identity.workspaceId, identity.agentId, identity.sessionId];
+  if (ids.some((id) => typeof id !== "string" || !id)) throw new Error("Session identity requires four nonempty ids");
+  const digest2 = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(ids)));
+  return `session:${Array.from(new Uint8Array(digest2), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+async function getSessionObject(namespace, identity) {
+  return namespace.getByName(await sessionObjectName(identity));
+}
+
+// src/index.ts
+var index_default = { fetch: () => new Response("Not found", { status: 404 }) };
+
+export { AgentDO, CLOUD_LIVE_IPO_TOOLS, CLOUD_SAFE_REPLAY_TOOLS, DurableObjectSqliteDatabase, agentObjectName, index_default as default, getAgentObject, getSessionObject, openDurableObjectStorage, sessionObjectName };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map