@irogane/kaji 0.2.0-beta.11

package/dist/chunk-AAM33KAO.js

@@ -0,0 +1,4367 @@
+import * as z from 'zod';
+import Ajv2020 from 'ajv/dist/2020.js';
+
+// src/events/types.ts
+var EventType = {
+  SESSION_CREATED: "session.created",
+  SESSION_CLOSED: "session.closed",
+  USER_MESSAGE: "user.message",
+  USER_AUDIO_CHUNK: "user.audio.chunk",
+  TRANSCRIPT_PARTIAL: "transcript.partial",
+  TRANSCRIPT_FINAL: "transcript.final",
+  MEMORY_RETRIEVAL_STARTED: "memory.retrieval.started",
+  MEMORY_RETRIEVAL_COMPLETED: "memory.retrieval.completed",
+  AGENT_REASONING_STARTED: "agent.reasoning.started",
+  AGENT_MESSAGE_DELTA: "agent.message.delta",
+  AGENT_MESSAGE_COMPLETED: "agent.message.completed",
+  AGENT_TURN_EXHAUSTED: "agent.turn.exhausted",
+  AGENT_TURN_FAILED: "agent.turn.failed",
+  TOOL_CALL_REQUESTED: "tool.call.requested",
+  TOOL_CALL_STARTED: "tool.call.started",
+  TOOL_CALL_COMPLETED: "tool.call.completed",
+  TOOL_CALL_FAILED: "tool.call.failed",
+  TOOL_APPROVAL_REQUESTED: "tool.approval.requested",
+  TOOL_APPROVAL_APPROVED: "tool.approval.approved",
+  TOOL_APPROVAL_REJECTED: "tool.approval.rejected",
+  WORKFLOW_STARTED: "workflow.started",
+  WORKFLOW_COMPLETED: "workflow.completed",
+  WORKFLOW_FAILED: "workflow.failed",
+  CANCELLATION_REQUESTED: "cancellation.requested",
+  CANCELLATION_COMPLETED: "cancellation.completed"
+};
+
+// src/events/errors.ts
+var DURABLE_JSON_SUBJECTS = /* @__PURE__ */ new Set([
+  "tool_result",
+  "workflow_result",
+  "event_metadata",
+  "memory_document",
+  "pending_tool_call",
+  "event"
+]);
+var InvalidDurableValueError = class extends Error {
+  constructor(subject) {
+    super(`Invalid durable JSON value for ${subject}`);
+    this.subject = subject;
+    this.name = "InvalidDurableValueError";
+  }
+  subject;
+  code = "INVALID_DURABLE_VALUE";
+};
+var DurableJsonLimitError = class extends Error {
+  constructor(subject, maxBytes) {
+    super(`Durable JSON value for ${subject} exceeds ${maxBytes} UTF-8 bytes`);
+    this.subject = subject;
+    this.maxBytes = maxBytes;
+    this.name = "DurableJsonLimitError";
+  }
+  subject;
+  maxBytes;
+  code = "EVENT_PAYLOAD_TOO_LARGE";
+};
+var EventSchemaIncompatibleError = class extends Error {
+  constructor(path) {
+    super(`Event schema is incompatible at ${path}`);
+    this.path = path;
+    this.name = "EventSchemaIncompatibleError";
+  }
+  path;
+  code = "EVENT_SCHEMA_INCOMPATIBLE";
+};
+var EventIdConflictError = class extends Error {
+  constructor(eventId) {
+    super(`Event id ${eventId} already belongs to a different event`);
+    this.eventId = eventId;
+    this.name = "EventIdConflictError";
+  }
+  eventId;
+  code = "EVENT_ID_CONFLICT";
+};
+var EventStoreCapacityError = class extends Error {
+  constructor(sessionId, message) {
+    super(message);
+    this.sessionId = sessionId;
+    this.name = "EventStoreCapacityError";
+  }
+  sessionId;
+  code = "EVENT_STORE_CAPACITY_EXCEEDED";
+};
+var SessionPurgeBusyError = class extends Error {
+  constructor(sessionId) {
+    super(`Session ${sessionId} cannot be purged while work is active`);
+    this.sessionId = sessionId;
+    this.name = "SessionPurgeBusyError";
+  }
+  sessionId;
+  code = "SESSION_PURGE_BUSY";
+};
+var SessionPurgeUnsupportedError = class extends Error {
+  constructor(sessionId, component = "event_store") {
+    super(`Session ${sessionId} cannot be purged by ${component.replaceAll("_", " ")}`);
+    this.sessionId = sessionId;
+    this.component = component;
+    this.name = "SessionPurgeUnsupportedError";
+  }
+  sessionId;
+  component;
+  code = "SESSION_PURGE_UNSUPPORTED";
+};
+var EventBufferOverflowError = class extends Error {
+  constructor(lastSequence, latestSequence) {
+    super(
+      `Subscriber buffer overflowed after sequence ${lastSequence}; latest sequence is ${latestSequence}`
+    );
+    this.lastSequence = lastSequence;
+    this.latestSequence = latestSequence;
+    this.name = "EventBufferOverflowError";
+  }
+  lastSequence;
+  latestSequence;
+  code = "EVENT_BUFFER_OVERFLOW";
+};
+var EventDeliveryError = class extends Error {
+  constructor(phase, eventId, persisted, options) {
+    super(`Event ${phase} failed for ${eventId}`, options);
+    this.phase = phase;
+    this.eventId = eventId;
+    this.persisted = persisted;
+    this.name = "EventDeliveryError";
+    this.code = phase === "append" ? "EVENT_APPEND_FAILED" : "EVENT_PUBLISH_FAILED";
+  }
+  phase;
+  eventId;
+  persisted;
+  code;
+};
+
+// src/internal/uuid.ts
+function defaultUuid() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const hex = (bytes) => Math.floor(Math.random() * 16 ** (bytes * 2)).toString(16).padStart(bytes * 2, "0");
+  return `${hex(4)}-${hex(2)}-${hex(2)}-${hex(2)}-${hex(6)}`;
+}
+var systemIdFactory = Object.freeze({
+  next: (_scope) => defaultUuid()
+});
+var systemClock = Object.freeze({
+  nowWallSeconds: () => Date.now() / 1e3,
+  nowMonotonic: () => globalThis.performance.now()
+});
+var systemTimerScheduler = Object.freeze({
+  schedule: (delayMs, callback) => {
+    if (!Number.isFinite(delayMs) || delayMs < 0) {
+      throw new RangeError("delayMs must be a finite non-negative number");
+    }
+    let remaining = Math.max(0, delayMs);
+    let timer;
+    let cancelled = false;
+    const arm = () => {
+      const step = Math.min(remaining, 2147483647);
+      timer = setTimeout(() => {
+        if (cancelled) return;
+        remaining -= step;
+        if (remaining <= 0) callback();
+        else arm();
+      }, step);
+    };
+    arm();
+    return {
+      cancel: () => {
+        cancelled = true;
+        if (timer !== void 0) clearTimeout(timer);
+      }
+    };
+  }
+});
+
+// src/contracts/integration-recovery.ts
+var DOCS = "https://kaji.dev/docs/integrations/recovery-v1";
+function recovery(errorCode, recoveryCode, anchor, problem, cause, fix) {
+  return Object.freeze({
+    errorCode,
+    recoveryCode,
+    docUrl: `${DOCS}#${anchor}`,
+    problem,
+    cause,
+    fix
+  });
+}
+var INTEGRATION_RECOVERY = Object.freeze({
+  github_token_missing: recovery(
+    "INTEGRATION_AUTH_REQUIRED",
+    "CONFIGURE_GITHUB_TOKEN",
+    "github-token",
+    "GitHub authentication is required.",
+    "The configured GitHub token is unavailable.",
+    "Set the manifest-declared GitHub token environment variable and retry."
+  ),
+  gmail_grant_missing: recovery(
+    "INTEGRATION_AUTH_REQUIRED",
+    "CONNECT_GMAIL",
+    "gmail-grant",
+    "Gmail authorization is required.",
+    "No Gmail grant exists for this principal.",
+    "Use the package-qualified connect command for this runtime and principal, then retry."
+  ),
+  keychain_missing: recovery(
+    "INTEGRATION_AUTH_ERROR",
+    "RESTORE_KEYCHAIN",
+    "keychain-missing",
+    "The macOS Keychain is unavailable.",
+    "The Keychain command could not be found.",
+    "Restore `/usr/bin/security` on a supported macOS host and retry."
+  ),
+  keychain_locked: recovery(
+    "INTEGRATION_AUTH_ERROR",
+    "UNLOCK_KEYCHAIN",
+    "keychain-locked",
+    "The macOS Keychain is locked.",
+    "The stored integration grant cannot be read while Keychain is locked.",
+    "Unlock the login Keychain and retry."
+  ),
+  keychain_corrupt: recovery(
+    "INTEGRATION_AUTH_ERROR",
+    "RESET_GMAIL_GRANT",
+    "keychain-corrupt",
+    "The stored Gmail grant is invalid.",
+    "The Keychain entry is corrupt or incomplete.",
+    "Disconnect Gmail locally, then reconnect with the same principal."
+  ),
+  keychain_unsupported: recovery(
+    "INTEGRATION_AUTH_ERROR",
+    "USE_SUPPORTED_KEYCHAIN",
+    "keychain-unsupported",
+    "Secure Gmail grant storage is unsupported.",
+    "This host cannot provide the required macOS Keychain boundary.",
+    "Use a supported macOS host; do not fall back to plaintext storage."
+  ),
+  gmail_scope_drift: recovery(
+    "INTEGRATION_AUTH_REQUIRED",
+    "RECONNECT_GMAIL",
+    "gmail-scope-drift",
+    "The Gmail grant no longer has the required scopes.",
+    "Stored and required OAuth scopes differ.",
+    "Use the package-qualified connect command for this runtime and principal, then consent again."
+  ),
+  policy_rejected: recovery(
+    "INTEGRATION_POLICY_REJECTED",
+    "REVIEW_INTEGRATION_POLICY",
+    "policy-rejected",
+    "The integration request was rejected before dispatch.",
+    "A fixed-origin, repository, recipient, or schema policy did not match.",
+    "Review the integration allowlist and request shape before retrying."
+  ),
+  api_rejected: recovery(
+    "INTEGRATION_API_ERROR",
+    "REVIEW_PROVIDER_REJECTION",
+    "api-rejected",
+    "The provider rejected the integration request.",
+    "The provider returned a confirmed non-retryable API rejection.",
+    "Review the request against the provider response guidance before retrying manually."
+  ),
+  transient_read_failed: recovery(
+    "INTEGRATION_API_ERROR",
+    "RETRY_INTEGRATION_READ",
+    "transient-read",
+    "The integration read did not complete.",
+    "The provider returned a transient failure before any external effect.",
+    "Retry the idempotent read with bounded backoff."
+  ),
+  rate_limited: recovery(
+    "INTEGRATION_RATE_LIMITED",
+    "RETRY_AFTER_RATE_LIMIT",
+    "rate-limited",
+    "The provider rate limit was reached.",
+    "The provider confirmed that this request was rate limited.",
+    "Reduce parallelism and retry only after the bounded provider delay."
+  ),
+  redirect_rejected: recovery(
+    "INTEGRATION_REDIRECT_REJECTED",
+    "REJECT_PROVIDER_REDIRECT",
+    "redirect-rejected",
+    "The provider returned a redirect that Kaji will not follow.",
+    "Fixed-origin integration requests reject every redirect.",
+    "Verify the provider endpoint; do not retry an ambiguous mutation blindly."
+  ),
+  response_limit_exceeded: recovery(
+    "INTEGRATION_RESPONSE_LIMIT",
+    "REDUCE_INTEGRATION_RESPONSE",
+    "response-limit",
+    "The integration response exceeded a safety bound.",
+    "Provider headers or body were malformed or too large.",
+    "Narrow the read request; reconcile a mutation before any retry."
+  ),
+  github_mutation_unknown: recovery(
+    "TOOL_EXECUTION_FAILED",
+    "RECONCILE_GITHUB_MUTATION",
+    "github-mutation-unknown",
+    "The GitHub mutation outcome is unknown.",
+    "The connection failed after dispatch without a confirmed provider result.",
+    "Reconcile the GitHub issue or comment marker before any manual retry."
+  ),
+  gmail_mutation_unknown: recovery(
+    "TOOL_EXECUTION_FAILED",
+    "RECONCILE_GMAIL_MUTATION",
+    "gmail-mutation-unknown",
+    "The Gmail mutation outcome is unknown.",
+    "The connection failed after dispatch without a confirmed provider result.",
+    "Reconcile the Gmail draft key or sent message before any manual retry."
+  )
+});
+function closedRecoveryFields(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const candidate = value;
+  if (typeof candidate.reason_code !== "string" || typeof candidate.recovery_code !== "string" || typeof candidate.doc_url !== "string") {
+    return void 0;
+  }
+  const recovery2 = INTEGRATION_RECOVERY[candidate.reason_code];
+  if (recovery2 === void 0 || recovery2.recoveryCode !== candidate.recovery_code || recovery2.docUrl !== candidate.doc_url || "error_code" in candidate && recovery2.errorCode !== candidate.error_code) {
+    return void 0;
+  }
+  return Object.freeze({
+    reason_code: candidate.reason_code,
+    recovery_code: candidate.recovery_code,
+    doc_url: candidate.doc_url
+  });
+}
+function closedTransportFailureFields(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const candidate = value;
+  const fields = closedRecoveryFields(candidate);
+  if (fields === void 0 || typeof candidate.error_code !== "string") return void 0;
+  const recovery2 = INTEGRATION_RECOVERY[fields.reason_code];
+  if (candidate.error_code !== recovery2.errorCode) return void 0;
+  return Object.freeze({ error_code: recovery2.errorCode, ...fields });
+}
+function isClosedRecoveryTuple(reasonCode, recoveryCode, docUrl, errorCode) {
+  if (reasonCode === void 0 && recoveryCode === void 0 && docUrl === void 0) return true;
+  return closedRecoveryFields({
+    error_code: errorCode,
+    reason_code: reasonCode,
+    recovery_code: recoveryCode,
+    doc_url: docUrl
+  }) !== void 0;
+}
+function cloneAndFreezeJson(value) {
+  return cloneJsonValue(value, /* @__PURE__ */ new WeakSet());
+}
+function structurallyEqualJson(left, right) {
+  return canonicalJsonValue(left) === canonicalJsonValue(right);
+}
+function canonicalJsonValue(value, subject = "JSON value") {
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  const assertUnicodeScalarString = (text) => {
+    for (let index = 0; index < text.length; index += 1) {
+      const unit = text.charCodeAt(index);
+      if (unit >= 55296 && unit <= 56319) {
+        const next = text.charCodeAt(index + 1);
+        if (!(next >= 56320 && next <= 57343)) {
+          throw new TypeError(`${subject} contains an unpaired Unicode surrogate`);
+        }
+        index += 1;
+      } else if (unit >= 56320 && unit <= 57343) {
+        throw new TypeError(`${subject} contains an unpaired Unicode surrogate`);
+      }
+    }
+  };
+  const encode = (item) => {
+    if (item === null) return "null";
+    switch (typeof item) {
+      case "boolean":
+        return item ? "true" : "false";
+      case "string":
+        assertUnicodeScalarString(item);
+        return JSON.stringify(item);
+      case "number":
+        if (!Number.isFinite(item)) throw new TypeError(`${subject} contains a non-finite number`);
+        if (Number.isInteger(item) && !Number.isSafeInteger(item)) {
+          throw new TypeError(`${subject} contains an integer outside the I-JSON safe range`);
+        }
+        return Object.is(item, -0) ? "0" : item.toString();
+      case "object": {
+        if (ancestors.has(item)) throw new TypeError(`${subject} must be acyclic`);
+        if (Object.getOwnPropertySymbols(item).length > 0) {
+          throw new TypeError(`${subject} JSON object keys must be strings`);
+        }
+        ancestors.add(item);
+        try {
+          if (Array.isArray(item)) {
+            const descriptors = Object.getOwnPropertyDescriptors(item);
+            const values = [];
+            for (let index = 0; index < item.length; index += 1) {
+              const descriptor = descriptors[String(index)];
+              if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+                throw new TypeError(`${subject} array values must be enumerable data values`);
+              }
+              values.push(encode(descriptor.value));
+            }
+            for (const key of Object.keys(descriptors)) {
+              if (key === "length") continue;
+              const index = Number(key);
+              if (Number.isInteger(index) && index >= 0 && index < item.length && String(index) === key) {
+                continue;
+              }
+              throw new TypeError(`${subject} arrays cannot carry named properties`);
+            }
+            return `[${values.join(",")}]`;
+          }
+          const prototype = Object.getPrototypeOf(item);
+          if (prototype !== Object.prototype && prototype !== null) {
+            throw new TypeError(`${subject} contains a non-plain object`);
+          }
+          const keys = Object.getOwnPropertyNames(item);
+          for (const key of keys) {
+            assertUnicodeScalarString(key);
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+              throw new TypeError(
+                `${subject} JSON object properties must be enumerable data values`
+              );
+            }
+          }
+          return `{${keys.sort().map((key) => {
+            const descriptor = Object.getOwnPropertyDescriptor(item, key);
+            return `${JSON.stringify(key)}:${encode(descriptor.value)}`;
+          }).join(",")}}`;
+        } finally {
+          ancestors.delete(item);
+        }
+      }
+      default:
+        throw new TypeError(`${subject} contains non-JSON value ${typeof item}`);
+    }
+  };
+  return encode(value);
+}
+function durableJsonSnapshot(value, subject, maxBytes) {
+  if (!DURABLE_JSON_SUBJECTS.has(subject)) {
+    throw new RangeError("Durable JSON subject must use the closed vocabulary");
+  }
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
+    throw new RangeError("maxBytes must be a non-negative safe integer");
+  }
+  let encoded;
+  try {
+    encoded = canonicalJsonValue(value, subject);
+  } catch {
+    throw new InvalidDurableValueError(subject);
+  }
+  if (new TextEncoder().encode(encoded).byteLength > maxBytes) {
+    throw new DurableJsonLimitError(subject, maxBytes);
+  }
+  return cloneAndFreezeJson(JSON.parse(encoded));
+}
+function cloneJsonValue(value, ancestors) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)) {
+      throw new TypeError("Event values must be JSON-safe");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    enter(value, ancestors);
+    const clone = value.map((item) => cloneJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return Object.freeze(clone);
+  }
+  if (typeof value === "object") {
+    assertJsonObject(value);
+    enter(value, ancestors);
+    const clone = {};
+    for (const [key, child] of Object.entries(value)) {
+      Object.defineProperty(clone, key, {
+        value: cloneJsonValue(child, ancestors),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    ancestors.delete(value);
+    return Object.freeze(clone);
+  }
+  throw new TypeError("Event values must be JSON-safe");
+}
+function assertJsonObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null || Object.getOwnPropertySymbols(value).length > 0) {
+    throw new TypeError("Event values must be JSON-safe");
+  }
+}
+function enter(value, ancestors) {
+  if (ancestors.has(value)) throw new TypeError("Event values must be JSON-safe and acyclic");
+  ancestors.add(value);
+}
+
+// contracts/events/new-kaji-event-v1.schema.json
+var new_kaji_event_v1_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://kaji.dev/contracts/events/new-kaji-event-v1.schema.json",
+  title: "New Kaji event",
+  "x-maxSerializedBytes": 1048576,
+  $defs: {
+    nonEmptyId: {
+      type: "string",
+      minLength: 1
+    },
+    integrationRecoveryFields: {
+      oneOf: [
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "github_token_missing" }, recovery_code: { const: "CONFIGURE_GITHUB_TOKEN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-token" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_grant_missing" }, recovery_code: { const: "CONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-grant" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_missing" }, recovery_code: { const: "RESTORE_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-missing" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_locked" }, recovery_code: { const: "UNLOCK_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-locked" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_corrupt" }, recovery_code: { const: "RESET_GMAIL_GRANT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-corrupt" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_unsupported" }, recovery_code: { const: "USE_SUPPORTED_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-unsupported" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_scope_drift" }, recovery_code: { const: "RECONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-scope-drift" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_POLICY_REJECTED" }, reason_code: { const: "policy_rejected" }, recovery_code: { const: "REVIEW_INTEGRATION_POLICY" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#policy-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "api_rejected" }, recovery_code: { const: "REVIEW_PROVIDER_REJECTION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#api-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "transient_read_failed" }, recovery_code: { const: "RETRY_INTEGRATION_READ" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#transient-read" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RATE_LIMITED" }, reason_code: { const: "rate_limited" }, recovery_code: { const: "RETRY_AFTER_RATE_LIMIT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#rate-limited" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_REDIRECT_REJECTED" }, reason_code: { const: "redirect_rejected" }, recovery_code: { const: "REJECT_PROVIDER_REDIRECT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#redirect-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RESPONSE_LIMIT" }, reason_code: { const: "response_limit_exceeded" }, recovery_code: { const: "REDUCE_INTEGRATION_RESPONSE" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#response-limit" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "github_mutation_unknown" }, recovery_code: { const: "RECONCILE_GITHUB_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "gmail_mutation_unknown" }, recovery_code: { const: "RECONCILE_GMAIL_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] }
+      ]
+    },
+    safeInteger: {
+      type: "integer",
+      minimum: -9007199254740991,
+      maximum: 9007199254740991
+    },
+    positiveInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 1
+        }
+      ]
+    },
+    nonNegativeInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonNumber: {
+      oneOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          type: "number",
+          not: {
+            type: "integer"
+          }
+        }
+      ]
+    },
+    nonNegativeNumber: {
+      allOf: [
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonValue: {
+      oneOf: [
+        {
+          type: "null"
+        },
+        {
+          type: "boolean"
+        },
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          type: "string"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/$defs/jsonValue"
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/jsonValue"
+          }
+        }
+      ]
+    },
+    jsonObject: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/jsonValue"
+      }
+    },
+    tokenUsage: {
+      type: "object",
+      properties: {
+        input: {
+          $ref: "#/$defs/nonNegativeInteger"
+        },
+        output: {
+          $ref: "#/$defs/nonNegativeInteger"
+        }
+      },
+      required: [
+        "input",
+        "output"
+      ],
+      additionalProperties: false
+    },
+    base: {
+      type: "object",
+      properties: {
+        id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        version: {
+          const: "1.0"
+        },
+        timestamp: {
+          $ref: "#/$defs/jsonNumber"
+        },
+        session_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        turn_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        metadata: {
+          $ref: "#/$defs/jsonObject"
+        }
+      },
+      required: [
+        "id",
+        "version",
+        "timestamp",
+        "session_id"
+      ]
+    },
+    sessionCreated: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.created"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    sessionClosed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.closed"
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userMessage: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.message"
+            },
+            content: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userAudioChunk: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.audio.chunk"
+            },
+            chunk_size_bytes: {
+              $ref: "#/$defs/safeInteger"
+            }
+          },
+          required: [
+            "type",
+            "chunk_size_bytes"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptPartial: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.partial"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptFinal: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.final"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.started"
+            },
+            query: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "query"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.completed"
+            },
+            query: {
+              type: "string"
+            },
+            documents: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            }
+          },
+          required: [
+            "type",
+            "query",
+            "documents"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentReasoningStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.reasoning.started"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageDelta: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.delta"
+            },
+            delta: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "delta"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.completed"
+            },
+            content: {
+              type: "string"
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnExhausted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.exhausted"
+            },
+            max_iterations: {
+              $ref: "#/$defs/nonNegativeInteger"
+            },
+            pending_tool_calls: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "max_iterations",
+            "pending_tool_calls"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            phase: {
+              enum: [
+                "queue",
+                "provider_open",
+                "provider_stream",
+                "approval",
+                "tool"
+              ]
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_args",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.started"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.completed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue",
+              "x-maxSerializedBytes": 65536
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            error_path: {
+              type: "string"
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            },
+            reason_code: {
+              type: "string"
+            },
+            recovery_code: {
+              type: "string"
+            },
+            doc_url: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error"
+          ]
+        },
+        {
+          if: {
+            anyOf: [
+              { required: ["reason_code"] },
+              { required: ["recovery_code"] },
+              { required: ["doc_url"] }
+            ]
+          },
+          then: {
+            $ref: "#/$defs/integrationRecoveryFields"
+          }
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            risk: {
+              enum: [
+                "read",
+                "write",
+                "external_effect",
+                "destructive",
+                "admin"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "tool_args",
+            "risk"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalApproved: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.approved"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRejected: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.rejected"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error_code: {
+              enum: [
+                "APPROVAL_REJECTED",
+                "APPROVAL_TIMEOUT",
+                "TURN_TIMEOUT",
+                "TOOL_CANCELLED",
+                "APPROVAL_UNAVAILABLE"
+              ]
+            },
+            reason: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200,
+              pattern: "\\S"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error_code",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.started"
+            },
+            workflow_name: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.completed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.failed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            error: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.requested"
+            },
+            reason: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.completed"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    }
+  },
+  oneOf: [
+    {
+      $ref: "#/$defs/sessionCreated"
+    },
+    {
+      $ref: "#/$defs/sessionClosed"
+    },
+    {
+      $ref: "#/$defs/userMessage"
+    },
+    {
+      $ref: "#/$defs/userAudioChunk"
+    },
+    {
+      $ref: "#/$defs/transcriptPartial"
+    },
+    {
+      $ref: "#/$defs/transcriptFinal"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalStarted"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalCompleted"
+    },
+    {
+      $ref: "#/$defs/agentReasoningStarted"
+    },
+    {
+      $ref: "#/$defs/agentMessageDelta"
+    },
+    {
+      $ref: "#/$defs/agentMessageCompleted"
+    },
+    {
+      $ref: "#/$defs/agentTurnExhausted"
+    },
+    {
+      $ref: "#/$defs/agentTurnFailed"
+    },
+    {
+      $ref: "#/$defs/toolCallRequested"
+    },
+    {
+      $ref: "#/$defs/toolCallStarted"
+    },
+    {
+      $ref: "#/$defs/toolCallCompleted"
+    },
+    {
+      $ref: "#/$defs/toolCallFailed"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRequested"
+    },
+    {
+      $ref: "#/$defs/toolApprovalApproved"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRejected"
+    },
+    {
+      $ref: "#/$defs/workflowStarted"
+    },
+    {
+      $ref: "#/$defs/workflowCompleted"
+    },
+    {
+      $ref: "#/$defs/workflowFailed"
+    },
+    {
+      $ref: "#/$defs/cancellationRequested"
+    },
+    {
+      $ref: "#/$defs/cancellationCompleted"
+    }
+  ]
+};
+
+// contracts/events/stored-kaji-event-v1.schema.json
+var stored_kaji_event_v1_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://kaji.dev/contracts/events/stored-kaji-event-v1.schema.json",
+  title: "Stored Kaji event",
+  "x-maxSerializedBytes": 1048576,
+  $defs: {
+    nonEmptyId: {
+      type: "string",
+      minLength: 1
+    },
+    integrationRecoveryFields: {
+      oneOf: [
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "github_token_missing" }, recovery_code: { const: "CONFIGURE_GITHUB_TOKEN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-token" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_grant_missing" }, recovery_code: { const: "CONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-grant" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_missing" }, recovery_code: { const: "RESTORE_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-missing" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_locked" }, recovery_code: { const: "UNLOCK_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-locked" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_corrupt" }, recovery_code: { const: "RESET_GMAIL_GRANT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-corrupt" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_unsupported" }, recovery_code: { const: "USE_SUPPORTED_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-unsupported" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_scope_drift" }, recovery_code: { const: "RECONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-scope-drift" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_POLICY_REJECTED" }, reason_code: { const: "policy_rejected" }, recovery_code: { const: "REVIEW_INTEGRATION_POLICY" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#policy-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "api_rejected" }, recovery_code: { const: "REVIEW_PROVIDER_REJECTION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#api-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "transient_read_failed" }, recovery_code: { const: "RETRY_INTEGRATION_READ" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#transient-read" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RATE_LIMITED" }, reason_code: { const: "rate_limited" }, recovery_code: { const: "RETRY_AFTER_RATE_LIMIT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#rate-limited" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_REDIRECT_REJECTED" }, reason_code: { const: "redirect_rejected" }, recovery_code: { const: "REJECT_PROVIDER_REDIRECT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#redirect-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RESPONSE_LIMIT" }, reason_code: { const: "response_limit_exceeded" }, recovery_code: { const: "REDUCE_INTEGRATION_RESPONSE" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#response-limit" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "github_mutation_unknown" }, recovery_code: { const: "RECONCILE_GITHUB_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "gmail_mutation_unknown" }, recovery_code: { const: "RECONCILE_GMAIL_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] }
+      ]
+    },
+    safeInteger: {
+      type: "integer",
+      minimum: -9007199254740991,
+      maximum: 9007199254740991
+    },
+    positiveInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 1
+        }
+      ]
+    },
+    nonNegativeInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonNumber: {
+      oneOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          type: "number",
+          not: {
+            type: "integer"
+          }
+        }
+      ]
+    },
+    nonNegativeNumber: {
+      allOf: [
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonValue: {
+      oneOf: [
+        {
+          type: "null"
+        },
+        {
+          type: "boolean"
+        },
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          type: "string"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/$defs/jsonValue"
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/jsonValue"
+          }
+        }
+      ]
+    },
+    jsonObject: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/jsonValue"
+      }
+    },
+    tokenUsage: {
+      type: "object",
+      properties: {
+        input: {
+          $ref: "#/$defs/nonNegativeInteger"
+        },
+        output: {
+          $ref: "#/$defs/nonNegativeInteger"
+        }
+      },
+      required: [
+        "input",
+        "output"
+      ],
+      additionalProperties: false
+    },
+    base: {
+      type: "object",
+      properties: {
+        id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        version: {
+          const: "1.0"
+        },
+        timestamp: {
+          $ref: "#/$defs/jsonNumber"
+        },
+        session_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        turn_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        metadata: {
+          $ref: "#/$defs/jsonObject"
+        },
+        sequence: {
+          $ref: "#/$defs/positiveInteger"
+        }
+      },
+      required: [
+        "id",
+        "version",
+        "timestamp",
+        "session_id",
+        "sequence"
+      ]
+    },
+    sessionCreated: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.created"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    sessionClosed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.closed"
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userMessage: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.message"
+            },
+            content: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userAudioChunk: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.audio.chunk"
+            },
+            chunk_size_bytes: {
+              $ref: "#/$defs/safeInteger"
+            }
+          },
+          required: [
+            "type",
+            "chunk_size_bytes"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptPartial: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.partial"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptFinal: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.final"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.started"
+            },
+            query: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "query"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.completed"
+            },
+            query: {
+              type: "string"
+            },
+            documents: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            }
+          },
+          required: [
+            "type",
+            "query",
+            "documents"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentReasoningStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.reasoning.started"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageDelta: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.delta"
+            },
+            delta: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "delta"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.completed"
+            },
+            content: {
+              type: "string"
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnExhausted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.exhausted"
+            },
+            max_iterations: {
+              $ref: "#/$defs/nonNegativeInteger"
+            },
+            pending_tool_calls: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "max_iterations",
+            "pending_tool_calls"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            phase: {
+              enum: [
+                "queue",
+                "provider_open",
+                "provider_stream",
+                "approval",
+                "tool"
+              ]
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_args",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.started"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.completed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue",
+              "x-maxSerializedBytes": 65536
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            error_path: {
+              type: "string"
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            },
+            reason_code: {
+              type: "string"
+            },
+            recovery_code: {
+              type: "string"
+            },
+            doc_url: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error"
+          ]
+        },
+        {
+          if: {
+            anyOf: [
+              { required: ["reason_code"] },
+              { required: ["recovery_code"] },
+              { required: ["doc_url"] }
+            ]
+          },
+          then: {
+            $ref: "#/$defs/integrationRecoveryFields"
+          }
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            risk: {
+              enum: [
+                "read",
+                "write",
+                "external_effect",
+                "destructive",
+                "admin"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "tool_args",
+            "risk"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalApproved: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.approved"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRejected: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.rejected"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error_code: {
+              enum: [
+                "APPROVAL_REJECTED",
+                "APPROVAL_TIMEOUT",
+                "TURN_TIMEOUT",
+                "TOOL_CANCELLED",
+                "APPROVAL_UNAVAILABLE"
+              ]
+            },
+            reason: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200,
+              pattern: "\\S"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error_code",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.started"
+            },
+            workflow_name: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.completed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.failed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            error: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.requested"
+            },
+            reason: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.completed"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    }
+  },
+  oneOf: [
+    {
+      $ref: "#/$defs/sessionCreated"
+    },
+    {
+      $ref: "#/$defs/sessionClosed"
+    },
+    {
+      $ref: "#/$defs/userMessage"
+    },
+    {
+      $ref: "#/$defs/userAudioChunk"
+    },
+    {
+      $ref: "#/$defs/transcriptPartial"
+    },
+    {
+      $ref: "#/$defs/transcriptFinal"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalStarted"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalCompleted"
+    },
+    {
+      $ref: "#/$defs/agentReasoningStarted"
+    },
+    {
+      $ref: "#/$defs/agentMessageDelta"
+    },
+    {
+      $ref: "#/$defs/agentMessageCompleted"
+    },
+    {
+      $ref: "#/$defs/agentTurnExhausted"
+    },
+    {
+      $ref: "#/$defs/agentTurnFailed"
+    },
+    {
+      $ref: "#/$defs/toolCallRequested"
+    },
+    {
+      $ref: "#/$defs/toolCallStarted"
+    },
+    {
+      $ref: "#/$defs/toolCallCompleted"
+    },
+    {
+      $ref: "#/$defs/toolCallFailed"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRequested"
+    },
+    {
+      $ref: "#/$defs/toolApprovalApproved"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRejected"
+    },
+    {
+      $ref: "#/$defs/workflowStarted"
+    },
+    {
+      $ref: "#/$defs/workflowCompleted"
+    },
+    {
+      $ref: "#/$defs/workflowFailed"
+    },
+    {
+      $ref: "#/$defs/cancellationRequested"
+    },
+    {
+      $ref: "#/$defs/cancellationCompleted"
+    }
+  ]
+};
+
+// src/events/schemas.ts
+var MAX_DURABLE_TOOL_ARGUMENT_BYTES = 64 * 1024;
+var MAX_DURABLE_TOOL_RESULT_BYTES = 64 * 1024;
+var MAX_DURABLE_EVENT_BYTES = 1024 * 1024;
+function durableToolArgumentsSize(value) {
+  return new TextEncoder().encode(canonicalJsonValue(value, "tool arguments")).byteLength;
+}
+var durableJsonValue = z.unknown().superRefine((value, ctx) => {
+  try {
+    canonicalJsonValue(value, "event value");
+  } catch {
+    ctx.addIssue({ code: "custom", message: "event value must contain only JSON values" });
+  }
+});
+var durableJsonObject = z.record(z.string(), durableJsonValue).superRefine((value, ctx) => {
+  try {
+    canonicalJsonValue(value, "event value");
+  } catch {
+    ctx.addIssue({ code: "custom", message: "event value must contain only JSON values" });
+  }
+});
+function durableSubjectValue(subject, maxBytes) {
+  return z.unknown().superRefine((value, ctx) => {
+    try {
+      durableJsonSnapshot(value, subject, maxBytes);
+    } catch {
+      ctx.addIssue({ code: "custom", message: `${subject} must be bounded durable JSON` });
+    }
+  });
+}
+function durableSubjectObject(subject) {
+  return z.record(z.string(), z.unknown()).superRefine((value, ctx) => {
+    try {
+      durableJsonSnapshot(value, subject, MAX_DURABLE_EVENT_BYTES);
+    } catch {
+      ctx.addIssue({ code: "custom", message: `${subject} must be bounded durable JSON` });
+    }
+  });
+}
+var durableToolArguments = durableJsonObject.superRefine((value, ctx) => {
+  let size;
+  try {
+    size = durableToolArgumentsSize(value);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "tool_args must contain only JSON values" });
+    return;
+  }
+  if (size > MAX_DURABLE_TOOL_ARGUMENT_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      message: "tool_args cannot exceed 65536 serialized bytes; payload redacted"
+    });
+  }
+});
+var nonEmptyId = z.string().min(1);
+var baseShape = {
+  id: nonEmptyId.default(() => defaultUuid()),
+  version: z.literal("1.0").default("1.0"),
+  timestamp: z.number().default(() => Date.now() / 1e3),
+  session_id: nonEmptyId,
+  turn_id: nonEmptyId.optional(),
+  metadata: durableSubjectObject("event_metadata").default(() => ({}))
+};
+function maxUnicodeCodePoints(field) {
+  return (value, ctx) => {
+    if (Array.from(value).length > 200) {
+      ctx.addIssue({ code: "custom", message: `${field} must contain at most 200 characters` });
+    }
+  };
+}
+function event(shape) {
+  return z.object(baseShape).extend(shape).strict();
+}
+var SessionCreated = event({
+  type: z.literal(EventType.SESSION_CREATED)
+});
+var SessionClosed = event({
+  type: z.literal(EventType.SESSION_CLOSED),
+  reason: z.string().nullish()
+});
+var UserMessage = event({
+  type: z.literal(EventType.USER_MESSAGE),
+  content: z.string()
+});
+var UserAudioChunk = event({
+  type: z.literal(EventType.USER_AUDIO_CHUNK),
+  chunk_size_bytes: z.number().int()
+});
+var TranscriptPartial = event({
+  type: z.literal(EventType.TRANSCRIPT_PARTIAL),
+  text: z.string()
+});
+var TranscriptFinal = event({
+  type: z.literal(EventType.TRANSCRIPT_FINAL),
+  text: z.string()
+});
+var MemoryRetrievalStarted = event({
+  type: z.literal(EventType.MEMORY_RETRIEVAL_STARTED),
+  query: z.string()
+});
+var MemoryRetrievalCompleted = event({
+  type: z.literal(EventType.MEMORY_RETRIEVAL_COMPLETED),
+  query: z.string(),
+  documents: z.array(durableSubjectObject("memory_document"))
+});
+var AgentReasoningStarted = event({
+  type: z.literal(EventType.AGENT_REASONING_STARTED)
+});
+var AgentMessageDelta = event({
+  type: z.literal(EventType.AGENT_MESSAGE_DELTA),
+  delta: z.string()
+});
+var AgentMessageCompleted = event({
+  type: z.literal(EventType.AGENT_MESSAGE_COMPLETED),
+  content: z.string(),
+  tokens: z.object({ input: z.number().int().nonnegative(), output: z.number().int().nonnegative() }).strict().nullish(),
+  cost_usd: z.number().nonnegative().nullish()
+});
+var AgentTurnExhausted = event({
+  type: z.literal(EventType.AGENT_TURN_EXHAUSTED),
+  max_iterations: z.number().int().nonnegative(),
+  pending_tool_calls: z.array(durableSubjectObject("pending_tool_call")),
+  reason: z.string().nullish()
+});
+var AgentTurnFailed = event({
+  type: z.literal(EventType.AGENT_TURN_FAILED),
+  turn_id: z.string().min(1),
+  error: z.string().min(1).superRefine(maxUnicodeCodePoints("error")),
+  error_code: z.string().optional(),
+  phase: z.enum(["queue", "provider_open", "provider_stream", "approval", "tool"]).optional(),
+  retryable: z.boolean().optional(),
+  outcome: z.enum(["not_started", "failed", "unknown"]).optional()
+});
+var ToolCallRequested = event({
+  type: z.literal(EventType.TOOL_CALL_REQUESTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_args: durableToolArguments,
+  tool_call_id: z.string().min(1)
+});
+var ToolCallStarted = event({
+  type: z.literal(EventType.TOOL_CALL_STARTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1)
+});
+var ToolCallCompleted = event({
+  type: z.literal(EventType.TOOL_CALL_COMPLETED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  result: durableSubjectValue("tool_result", MAX_DURABLE_TOOL_RESULT_BYTES),
+  tokens: z.object({ input: z.number().int().nonnegative(), output: z.number().int().nonnegative() }).strict().nullish(),
+  cost_usd: z.number().nonnegative().nullish()
+});
+var ToolCallFailed = event({
+  type: z.literal(EventType.TOOL_CALL_FAILED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  error: z.string().min(1).superRefine(maxUnicodeCodePoints("error")),
+  error_code: z.string().optional(),
+  error_path: z.string().optional(),
+  retryable: z.boolean().optional(),
+  outcome: z.enum(["not_started", "failed", "unknown"]).optional(),
+  reason_code: z.string().optional(),
+  recovery_code: z.string().optional(),
+  doc_url: z.string().optional()
+}).superRefine((value, ctx) => {
+  if (!isClosedRecoveryTuple(value.reason_code, value.recovery_code, value.doc_url, value.error_code)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["reason_code"],
+      message: "integration recovery metadata must be a closed tuple"
+    });
+  }
+});
+var ToolApprovalRequested = event({
+  type: z.literal(EventType.TOOL_APPROVAL_REQUESTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  tool_args: durableToolArguments,
+  risk: z.enum(["read", "write", "external_effect", "destructive", "admin"])
+});
+var ToolApprovalApproved = event({
+  type: z.literal(EventType.TOOL_APPROVAL_APPROVED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1)
+});
+var ToolApprovalRejected = event({
+  type: z.literal(EventType.TOOL_APPROVAL_REJECTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  error_code: z.enum([
+    "APPROVAL_REJECTED",
+    "APPROVAL_TIMEOUT",
+    "TURN_TIMEOUT",
+    "TOOL_CANCELLED",
+    "APPROVAL_UNAVAILABLE"
+  ]),
+  reason: z.string().min(1).refine((value) => value.trim().length > 0, "reason must not be blank").superRefine(maxUnicodeCodePoints("reason"))
+});
+var WorkflowStarted = event({
+  type: z.literal(EventType.WORKFLOW_STARTED),
+  workflow_name: z.string()
+});
+var WorkflowCompleted = event({
+  type: z.literal(EventType.WORKFLOW_COMPLETED),
+  workflow_name: z.string(),
+  result: durableSubjectValue("workflow_result", MAX_DURABLE_EVENT_BYTES)
+});
+var WorkflowFailed = event({
+  type: z.literal(EventType.WORKFLOW_FAILED),
+  workflow_name: z.string(),
+  error: z.string()
+});
+var CancellationRequested = event({
+  type: z.literal(EventType.CANCELLATION_REQUESTED),
+  reason: z.string()
+});
+var CancellationCompleted = event({
+  type: z.literal(EventType.CANCELLATION_COMPLETED)
+});
+var KajiEvent = z.discriminatedUnion("type", [
+  SessionCreated,
+  SessionClosed,
+  UserMessage,
+  UserAudioChunk,
+  TranscriptPartial,
+  TranscriptFinal,
+  MemoryRetrievalStarted,
+  MemoryRetrievalCompleted,
+  AgentReasoningStarted,
+  AgentMessageDelta,
+  AgentMessageCompleted,
+  AgentTurnExhausted,
+  AgentTurnFailed,
+  ToolCallRequested,
+  ToolCallStarted,
+  ToolCallCompleted,
+  ToolCallFailed,
+  ToolApprovalRequested,
+  ToolApprovalApproved,
+  ToolApprovalRejected,
+  WorkflowStarted,
+  WorkflowCompleted,
+  WorkflowFailed,
+  CancellationRequested,
+  CancellationCompleted
+]);
+var NewKajiEvent = KajiEvent;
+var StoredKajiEvent = z.object({ sequence: z.number().int().positive() }).loose().transform((value, ctx) => {
+  const { sequence, ...candidate } = value;
+  const parsed = KajiEvent.safeParse(candidate);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) ctx.addIssue({ ...issue });
+    return z.NEVER;
+  }
+  return cloneAndFreezeJson({ ...parsed.data, sequence });
+});
+var EVENT_TYPES = new Set(Object.values(EventType));
+var wireAjv = new Ajv2020({ allErrors: true, strict: false });
+var newWireValidator = wireAjv.compile(new_kaji_event_v1_schema_default);
+var storedWireValidator = wireAjv.compile(stored_kaji_event_v1_schema_default);
+var variantValidators = /* @__PURE__ */ new Map();
+function pointerSegment(value) {
+  return String(value).replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function schemaDefName(eventType) {
+  const [head, ...tail] = eventType.split(".");
+  return `${head}${tail.map((part) => part[0].toUpperCase() + part.slice(1)).join("")}`;
+}
+function selectedWireValidator(stored, eventType) {
+  const key = `${stored ? "stored" : "new"}:${eventType}`;
+  const existing = variantValidators.get(key);
+  if (existing !== void 0) return existing;
+  const schema = stored ? stored_kaji_event_v1_schema_default : new_kaji_event_v1_schema_default;
+  const compiled = wireAjv.compile({
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $defs: schema.$defs,
+    $ref: `#/$defs/${schemaDefName(eventType)}`
+  });
+  variantValidators.set(key, compiled);
+  return compiled;
+}
+function schemaErrorPointer(error) {
+  if (error.keyword === "required") {
+    return `${error.instancePath}/${pointerSegment(error.params.missingProperty)}`;
+  }
+  if (error.keyword === "unevaluatedProperties" || error.keyword === "additionalProperties") {
+    const property = error.params.unevaluatedProperty ?? error.params.additionalProperty;
+    if (property !== void 0) return `${error.instancePath}/${pointerSegment(property)}`;
+  }
+  return error.instancePath || "/";
+}
+function firstSchemaErrorPointer(errors) {
+  const pointers = (errors ?? []).filter((error) => error.keyword !== "allOf" && error.keyword !== "oneOf").map(schemaErrorPointer).sort(
+    (left, right) => Number(left === "/") - Number(right === "/") || left.localeCompare(right)
+  );
+  return pointers[0] ?? "/";
+}
+function wirePreflight(value, stored) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EventSchemaIncompatibleError("/");
+  }
+  const document = value;
+  if ([document.reason_code, document.recovery_code, document.doc_url].some(
+    (field) => field !== void 0
+  ) && !isClosedRecoveryTuple(
+    document.reason_code,
+    document.recovery_code,
+    document.doc_url,
+    document.error_code
+  )) {
+    throw new EventSchemaIncompatibleError("/reason_code");
+  }
+  for (const field of ["id", "version", "timestamp", "type", "session_id"]) {
+    if (!(field in document)) throw new EventSchemaIncompatibleError(`/${field}`);
+  }
+  for (const field of ["id", "session_id", "turn_id"]) {
+    if (document[field] === "") throw new EventSchemaIncompatibleError(`/${field}`);
+  }
+  if (stored && !("sequence" in document)) throw new EventSchemaIncompatibleError("/sequence");
+  if (!stored && "sequence" in document) throw new EventSchemaIncompatibleError("/sequence");
+  if (typeof document.type !== "string" || !EVENT_TYPES.has(document.type)) {
+    throw new EventSchemaIncompatibleError("/type");
+  }
+  return document;
+}
+function zodIssuePointer(error) {
+  const issue = error.issues[0];
+  if (issue === void 0 || issue.path.length === 0) return "/";
+  const path = [...issue.path];
+  if (typeof path[0] === "string" && EVENT_TYPES.has(path[0])) path.shift();
+  return `/${path.map(pointerSegment).join("/")}`;
+}
+function durableErrorPointer(error) {
+  const pointers = {
+    tool_result: "/result",
+    workflow_result: "/result",
+    event_metadata: "/metadata",
+    memory_document: "/documents",
+    pending_tool_call: "/pending_tool_calls",
+    event: "/"
+  };
+  return pointers[error.subject];
+}
+function ownDataValue(document, key, subject) {
+  const descriptor = Object.getOwnPropertyDescriptor(document, key);
+  if (descriptor === void 0) return { present: false };
+  if (!descriptor.enumerable || !("value" in descriptor)) {
+    throw new InvalidDurableValueError(subject);
+  }
+  return { present: true, value: descriptor.value };
+}
+function snapshotArrayItems(value, subject) {
+  if (!Array.isArray(value)) throw new InvalidDurableValueError(subject);
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (let index = 0; index < value.length; index++) {
+    const descriptor = descriptors[String(index)];
+    if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+      throw new InvalidDurableValueError(subject);
+    }
+    durableJsonSnapshot(descriptor.value, subject, MAX_DURABLE_EVENT_BYTES);
+  }
+}
+function snapshotEventSubjects(document) {
+  const metadata = ownDataValue(document, "metadata", "event_metadata");
+  if (metadata.present) {
+    durableJsonSnapshot(metadata.value, "event_metadata", MAX_DURABLE_EVENT_BYTES);
+  }
+  const type = ownDataValue(document, "type", "event");
+  if (!type.present) return;
+  if (type.value === EventType.TOOL_CALL_COMPLETED) {
+    const result = ownDataValue(document, "result", "tool_result");
+    if (result.present) {
+      durableJsonSnapshot(result.value, "tool_result", MAX_DURABLE_TOOL_RESULT_BYTES);
+    }
+  } else if (type.value === EventType.WORKFLOW_COMPLETED) {
+    const result = ownDataValue(document, "result", "workflow_result");
+    if (result.present) {
+      durableJsonSnapshot(result.value, "workflow_result", MAX_DURABLE_EVENT_BYTES);
+    }
+  } else if (type.value === EventType.MEMORY_RETRIEVAL_COMPLETED) {
+    const documents = ownDataValue(document, "documents", "event");
+    if (documents.present) snapshotArrayItems(documents.value, "memory_document");
+  } else if (type.value === EventType.AGENT_TURN_EXHAUSTED) {
+    const pending = ownDataValue(document, "pending_tool_calls", "event");
+    if (pending.present) snapshotArrayItems(pending.value, "pending_tool_call");
+  }
+}
+function durableEventSnapshot(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    snapshotEventSubjects(value);
+  }
+  return durableJsonSnapshot(value, "event", MAX_DURABLE_EVENT_BYTES);
+}
+function descriptorSafeWireSnapshot(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") return value;
+  if (ancestors.has(value)) throw new InvalidDurableValueError("event");
+  const isArray = Array.isArray(value);
+  const prototype = Object.getPrototypeOf(value);
+  if (!isArray && prototype !== Object.prototype && prototype !== null) {
+    throw new InvalidDurableValueError("event");
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new InvalidDurableValueError("event");
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const clone = isArray ? [] : Object.create(prototype);
+  ancestors.add(value);
+  try {
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (isArray && key === "length") continue;
+      if (!descriptor.enumerable || !("value" in descriptor)) {
+        throw new InvalidDurableValueError("event");
+      }
+      Object.defineProperty(clone, key, {
+        value: descriptorSafeWireSnapshot(descriptor.value, ancestors),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
+    }
+    if (isArray && clone.length !== value.length) {
+      throw new InvalidDurableValueError("event");
+    }
+    return Object.freeze(clone);
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function validateWireEvent(value, stored) {
+  let durableFailure;
+  let snapshot;
+  try {
+    snapshot = durableEventSnapshot(value);
+  } catch (error) {
+    if (error instanceof InvalidDurableValueError || error instanceof DurableJsonLimitError) {
+      durableFailure = error;
+      try {
+        snapshot = descriptorSafeWireSnapshot(value);
+      } catch {
+        throw new EventSchemaIncompatibleError(durableErrorPointer(error));
+      }
+    } else {
+      throw new EventSchemaIncompatibleError("/");
+    }
+  }
+  if (typeof snapshot !== "object" || snapshot === null || Array.isArray(snapshot)) {
+    throw new EventSchemaIncompatibleError("/");
+  }
+  const document = wirePreflight(snapshot, stored);
+  const validator = stored ? storedWireValidator : newWireValidator;
+  const eventType = document.type;
+  if (!validator(document)) {
+    const selected = selectedWireValidator(stored, eventType);
+    selected(document);
+    throw new EventSchemaIncompatibleError(
+      firstSchemaErrorPointer(selected.errors ?? validator.errors)
+    );
+  }
+  if (durableFailure !== void 0) {
+    throw new EventSchemaIncompatibleError(durableErrorPointer(durableFailure));
+  }
+  const candidate = stored ? Object.fromEntries(Object.entries(document).filter(([key]) => key !== "sequence")) : document;
+  const parsed = KajiEvent.safeParse(candidate);
+  if (!parsed.success) throw new EventSchemaIncompatibleError(zodIssuePointer(parsed.error));
+  return { event: parsed.data, document };
+}
+function validateNewEvent(value) {
+  return validateWireEvent(value, false).event;
+}
+function snapshotNewEvent(value) {
+  return validateNewEvent(durableEventSnapshot(value));
+}
+function snapshotStoredEventForAppend(value) {
+  return validateStoredEvent(durableEventSnapshot(value));
+}
+function validateStoredEvent(value) {
+  const { event: event2, document } = validateWireEvent(value, true);
+  const sequence = document.sequence;
+  return cloneAndFreezeJson({ ...event2, sequence });
+}
+
+// src/observability.ts
+var SPAN_NAMES = /* @__PURE__ */ new Set([
+  "kaji.turn",
+  "kaji.provider",
+  "kaji.tool",
+  "kaji.integration.auth",
+  "kaji.integration.request"
+]);
+var TRACE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "session.id",
+  "turn.id",
+  "request.id",
+  "trace.id",
+  "tool.call_id",
+  "provider.family",
+  "integration.name",
+  "integration.operation",
+  "http.status_family"
+]);
+var METRIC_UNITS = Object.freeze({
+  "kaji.turn.queue_wait_ms": "ms",
+  "kaji.turn.duration_ms": "ms",
+  "kaji.turn.iterations": "count",
+  "kaji.provider.duration_ms": "ms",
+  "kaji.provider.retries": "count",
+  "kaji.replay.input_events": "count",
+  "kaji.context.messages": "count",
+  "kaji.context.characters": "count",
+  "kaji.tool.queue_wait_ms": "ms",
+  "kaji.tool.active": "gauge",
+  "kaji.tool.duration_ms": "ms",
+  "kaji.journal.failures": "count",
+  "kaji.subscriber.lag_events": "count",
+  "kaji.subscriber.overflow": "count",
+  "kaji.integration.auth_ms": "ms",
+  "kaji.integration.request_ms": "ms"
+});
+var METRIC_NAMES = Object.freeze(
+  Object.keys(METRIC_UNITS)
+);
+var ALLOWED_LABELS = Object.freeze({
+  "kaji.turn.queue_wait_ms": [],
+  "kaji.turn.duration_ms": ["outcome"],
+  "kaji.turn.iterations": ["outcome"],
+  "kaji.provider.duration_ms": ["provider_family", "status"],
+  "kaji.provider.retries": ["provider_family"],
+  "kaji.replay.input_events": [],
+  "kaji.context.messages": [],
+  "kaji.context.characters": [],
+  "kaji.tool.queue_wait_ms": ["outcome"],
+  "kaji.tool.active": [],
+  "kaji.tool.duration_ms": ["outcome", "error_code"],
+  "kaji.journal.failures": ["stage"],
+  "kaji.subscriber.lag_events": [],
+  "kaji.subscriber.overflow": ["stage"],
+  "kaji.integration.auth_ms": ["integration", "operation", "outcome"],
+  "kaji.integration.request_ms": ["integration", "operation", "outcome"]
+});
+var STABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "NONE",
+  "OTHER",
+  "INVALID_TOOL_SCHEMA",
+  "INVALID_TOOL_ARGUMENTS",
+  "UNCLASSIFIED_TOOL_RISK",
+  "MISSING_TOOL_IDENTITY",
+  "TOOL_NOT_ALLOWED",
+  "APPROVAL_UNAVAILABLE",
+  "APPROVAL_REJECTED",
+  "APPROVAL_TIMEOUT",
+  "TOOL_CANCELLED",
+  "TOOL_TIMEOUT",
+  "TURN_TIMEOUT",
+  "TOOL_EXECUTION_FAILED",
+  "TOOL_START_RECORD_FAILED",
+  "IDEMPOTENCY_CAPACITY_EXCEEDED",
+  "IDEMPOTENCY_CONFLICT",
+  "INTEGRATION_AUTH_ERROR",
+  "INTEGRATION_AUTH_REQUIRED",
+  "INTEGRATION_API_ERROR",
+  "INTEGRATION_POLICY_REJECTED",
+  "INTEGRATION_RATE_LIMITED",
+  "INTEGRATION_REDIRECT_REJECTED",
+  "INTEGRATION_RESPONSE_LIMIT"
+]);
+function validLabel(key, value) {
+  if (typeof value !== "string") return false;
+  const text = value;
+  if (key === "provider_family") {
+    return text === "openai" || text === "anthropic" || text === "custom";
+  }
+  if (key === "status") {
+    return text === "success" || text === "cancelled" || text === "error";
+  }
+  if (key === "stage") {
+    return ["append", "publish", "lag", "overflow"].includes(text);
+  }
+  if (key === "error_code") return STABLE_ERROR_CODES.has(text);
+  if (key === "outcome") {
+    return [
+      "acquired",
+      "completed",
+      "failed",
+      "cancelled",
+      "timeout",
+      "not_started",
+      "unknown",
+      "success",
+      "error"
+    ].includes(text);
+  }
+  if (key === "integration") return text === "github" || text === "gmail";
+  if (key === "operation") return ["read", "mutation", "token"].includes(text);
+  return false;
+}
+function recordMetric(sink, name, value, labels) {
+  if (!Number.isFinite(value)) return;
+  if (sink === NOOP_METRICS) return;
+  if (!Object.hasOwn(METRIC_UNITS, name)) return;
+  const sanitized = {};
+  const allowed = ALLOWED_LABELS[name];
+  const supplied = Object.keys(labels);
+  if (supplied.length !== allowed.length || supplied.some((key) => !allowed.includes(key))) return;
+  for (const key of allowed) {
+    const raw = labels[key];
+    if (!validLabel(key, raw)) return;
+    sanitized[key] = raw;
+  }
+  const measurement = Object.freeze({
+    name,
+    value,
+    unit: METRIC_UNITS[name],
+    labels: Object.freeze(sanitized)
+  });
+  try {
+    const pending = sink.record(measurement);
+    if (pending !== void 0) void Promise.resolve(pending).catch(() => void 0);
+  } catch {
+  }
+}
+var NOOP_SPAN = Object.freeze({
+  setAttribute: () => {
+  },
+  recordError: () => {
+  },
+  end: () => {
+  }
+});
+var NOOP_METRICS = Object.freeze({ record: () => {
+} });
+var NOOP_TRACE = Object.freeze({ startSpan: () => NOOP_SPAN });
+function validTraceAttribute(name, value) {
+  if (typeof value !== "string") return false;
+  if (name === "integration.name") return value === "github" || value === "gmail";
+  if (name === "integration.operation") {
+    return value === "read" || value === "mutation" || value === "token";
+  }
+  if (name === "http.status_family") return /^(?:[1-5]xx|none)$/.test(value);
+  return true;
+}
+function startSpan(sink, name, attributes = {}) {
+  if (sink === NOOP_TRACE) return NOOP_SPAN;
+  if (!SPAN_NAMES.has(name)) return NOOP_SPAN;
+  let safeAttributes;
+  try {
+    const entries = Object.entries(attributes);
+    if (entries.some(
+      ([key, value]) => !TRACE_ATTRIBUTES.has(key) || !validTraceAttribute(key, value)
+    )) {
+      return NOOP_SPAN;
+    }
+    safeAttributes = Object.freeze(Object.fromEntries(entries));
+  } catch {
+    return NOOP_SPAN;
+  }
+  let inner;
+  try {
+    inner = sink.startSpan(name, safeAttributes);
+  } catch {
+    return NOOP_SPAN;
+  }
+  let ended = false;
+  return {
+    setAttribute(attributeName, value) {
+      if (ended) return;
+      if (!TRACE_ATTRIBUTES.has(attributeName) || !validTraceAttribute(attributeName, value))
+        return;
+      try {
+        inner.setAttribute(attributeName, value);
+      } catch {
+      }
+    },
+    recordError(error) {
+      if (ended) return;
+      try {
+        const kind = error instanceof Error ? error.name : typeof error;
+        inner.recordError(new Error(`${kind}: details redacted`));
+      } catch {
+      }
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      try {
+        inner.end();
+      } catch {
+      }
+    }
+  };
+}
+function providerFamily(provider) {
+  try {
+    const declared = provider.providerFamily;
+    if (declared === "openai" || declared === "anthropic" || declared === "custom") {
+      return declared;
+    }
+    const name = provider.constructor?.name.toLowerCase() ?? "";
+    if (name.includes("openai")) return "openai";
+    if (name.includes("anthropic")) return "anthropic";
+  } catch {
+  }
+  return "custom";
+}
+
+// src/sessions/replay.ts
+function approvalKey(turnId, toolCallId, toolName) {
+  return JSON.stringify([turnId, toolCallId, toolName]);
+}
+var lastAssistantIndexes = /* @__PURE__ */ new WeakMap();
+function cloneSessionState(state) {
+  const snapshot = structuredClone(state);
+  const lastAssistantIndex = lastAssistantIndexes.get(state);
+  if (lastAssistantIndex !== void 0) {
+    lastAssistantIndexes.set(snapshot, lastAssistantIndex);
+  }
+  return snapshot;
+}
+function createSessionState(sessionId) {
+  return {
+    sessionId,
+    isActive: false,
+    messages: [],
+    pendingApprovals: /* @__PURE__ */ new Set(),
+    approvedApprovals: /* @__PURE__ */ new Set(),
+    rejectedApprovals: /* @__PURE__ */ new Map(),
+    totalTokens: { input: 0, output: 0 },
+    totalCostUsd: 0
+  };
+}
+function replaySession(events) {
+  const validated = events.map(validateStoredEvent);
+  const first = validated[0];
+  if (first === void 0) {
+    throw new Error("Cannot replay empty event log");
+  }
+  if (validated.some((event2) => event2.session_id !== first.session_id)) {
+    throw new Error("Cannot replay events from mixed sessions");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let previous = 0;
+  for (const event2 of validated) {
+    if (!Number.isInteger(event2.sequence) || event2.sequence <= 0) {
+      throw new Error("Stored event sequence must be a positive integer");
+    }
+    if (seen.has(event2.sequence)) throw new Error(`Duplicate event sequence ${event2.sequence}`);
+    if (event2.sequence < previous) {
+      throw new Error(`Non-monotonic event sequence ${event2.sequence} after ${previous}`);
+    }
+    seen.add(event2.sequence);
+    previous = event2.sequence;
+  }
+  const state = createSessionState(first.session_id);
+  for (const event2 of validated) applyEvent(state, event2);
+  return state;
+}
+function applyEvent(state, event2) {
+  if (event2.session_id !== state.sessionId) {
+    throw new Error("Cannot project events from mixed sessions");
+  }
+  return applyKajiEvent(state, event2);
+}
+function applyKajiEvent(state, event2) {
+  switch (event2.type) {
+    case EventType.SESSION_CREATED:
+      state.isActive = true;
+      break;
+    case EventType.SESSION_CLOSED:
+      state.isActive = false;
+      break;
+    case EventType.AGENT_REASONING_STARTED:
+      lastAssistantIndexes.delete(state);
+      break;
+    case EventType.USER_MESSAGE:
+      state.messages.push({ role: "user", content: event2.content });
+      lastAssistantIndexes.delete(state);
+      return state.messages.length - 1;
+    case EventType.AGENT_MESSAGE_COMPLETED:
+      {
+        const lastAssistant = { role: "assistant", content: event2.content };
+        state.messages.push(lastAssistant);
+        lastAssistantIndexes.set(state, state.messages.length - 1);
+      }
+      if (event2.tokens) {
+        state.totalTokens.input += event2.tokens.input;
+        state.totalTokens.output += event2.tokens.output;
+      }
+      if (event2.cost_usd) {
+        state.totalCostUsd += event2.cost_usd;
+      }
+      return state.messages.length - 1;
+    case EventType.TRANSCRIPT_FINAL:
+      state.messages.push({ role: "user", content: event2.text });
+      lastAssistantIndexes.delete(state);
+      return state.messages.length - 1;
+    case EventType.TOOL_CALL_REQUESTED: {
+      let lastAssistantIndex = lastAssistantIndexes.get(state);
+      if (lastAssistantIndex === void 0) {
+        state.messages.push({ role: "assistant", content: "", toolCalls: [] });
+        lastAssistantIndex = state.messages.length - 1;
+        lastAssistantIndexes.set(state, lastAssistantIndex);
+      }
+      const lastAssistant = state.messages[lastAssistantIndex];
+      lastAssistant.toolCalls ??= [];
+      lastAssistant.toolCalls.push({
+        id: event2.tool_call_id,
+        name: event2.tool_name,
+        args: structuredClone(event2.tool_args)
+      });
+      return lastAssistantIndex;
+    }
+    case EventType.TOOL_CALL_COMPLETED:
+      state.messages.push({
+        role: "tool",
+        name: event2.tool_name,
+        content: stringifyResult(event2.result),
+        // H3: carry the real tool_call_id through so buildMessages can
+        // reference it; a real provider rejects a tool result whose id does
+        // not match the originating request.
+        toolCallId: event2.tool_call_id
+      });
+      return state.messages.length - 1;
+    case EventType.TOOL_CALL_FAILED:
+      state.messages.push({
+        role: "tool",
+        name: event2.tool_name,
+        content: `Error: ${event2.error}`,
+        toolCallId: event2.tool_call_id
+      });
+      if (event2.turn_id !== void 0) {
+        state.pendingApprovals.delete(
+          approvalKey(event2.turn_id, event2.tool_call_id, event2.tool_name)
+        );
+      }
+      return state.messages.length - 1;
+    case EventType.TOOL_APPROVAL_REQUESTED:
+      {
+        const key = approvalKey(event2.turn_id, event2.tool_call_id, event2.tool_name);
+        if (!state.approvedApprovals.has(key) && !state.rejectedApprovals.has(key)) {
+          state.pendingApprovals.add(key);
+        }
+      }
+      break;
+    case EventType.TOOL_APPROVAL_APPROVED:
+      {
+        const key = approvalKey(event2.turn_id, event2.tool_call_id, event2.tool_name);
+        if (state.pendingApprovals.delete(key)) state.approvedApprovals.add(key);
+      }
+      break;
+    case EventType.TOOL_APPROVAL_REJECTED:
+      {
+        const key = approvalKey(event2.turn_id, event2.tool_call_id, event2.tool_name);
+        if (state.pendingApprovals.delete(key)) {
+          state.rejectedApprovals.set(key, event2.error_code);
+        }
+      }
+      break;
+  }
+  return null;
+}
+function stringifyResult(result) {
+  return canonicalJsonValue(result, "tool result");
+}
+
+// src/runtime/limits.ts
+var DEFAULT_TURN_EXECUTION_LIMITS = Object.freeze({
+  turnTimeoutMs: 12e4,
+  providerCancellationGraceMs: 5e3,
+  providerTextMaxBytes: 262144,
+  providerToolArgumentsMaxBytes: 65536,
+  providerResponseMaxBytes: 524288,
+  providerToolCallsMax: 64
+});
+function resolveTurnExecutionLimits(overrides = {}) {
+  const limits = { ...DEFAULT_TURN_EXECUTION_LIMITS, ...overrides };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isInteger(value) || value < 1) {
+      throw new RangeError(`${name} must be a positive integer`);
+    }
+  }
+  return Object.freeze(limits);
+}
+var TurnTimeoutError = class extends Error {
+  constructor(phase, retryable, outcome) {
+    super(`Turn deadline exceeded during ${phase}`);
+    this.phase = phase;
+    this.retryable = retryable;
+    this.outcome = outcome;
+    if (typeof retryable !== "boolean") throw new TypeError("retryable must be a boolean");
+    if (!["queue", "provider_open", "provider_stream", "approval", "tool"].includes(phase)) {
+      throw new TypeError("phase must be a supported turn phase");
+    }
+    if (!["not_started", "failed", "unknown"].includes(outcome)) {
+      throw new TypeError("outcome must be a supported turn outcome");
+    }
+    this.name = "TurnTimeoutError";
+  }
+  phase;
+  retryable;
+  outcome;
+  code = "TURN_TIMEOUT";
+};
+var ProviderCancellationContractViolation = class extends Error {
+  constructor(phase = "provider_stream") {
+    super("Provider did not stop after cancellation");
+    this.phase = phase;
+    this.name = "ProviderCancellationContractViolation";
+  }
+  phase;
+  code = "PROVIDER_CANCELLATION_CONTRACT_VIOLATION";
+  retryable = false;
+  outcome = "unknown";
+};
+var PROVIDER_VIOLATION_DETAILS = /* @__PURE__ */ new WeakMap();
+function attachProviderViolationSettlement(error, settlement) {
+  PROVIDER_VIOLATION_DETAILS.set(error, { settlement });
+  return error;
+}
+function providerViolationSettlement(error) {
+  return PROVIDER_VIOLATION_DETAILS.get(error)?.settlement;
+}
+
+// src/runtime/cancellation.ts
+var CancellationError = class extends Error {
+  constructor(message = "Agent run was cancelled") {
+    super(message);
+    this.name = "CancellationError";
+  }
+};
+function throwIfCancellationRequested(token) {
+  if (!token?.isCancelled) return;
+  if (typeof token.throwIfCancelled === "function") {
+    token.throwIfCancelled();
+  }
+  throw new CancellationError();
+}
+function isCancellationCompatible(error) {
+  return error instanceof CancellationError || typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+var CancellationToken = class {
+  controller = new AbortController();
+  /** Whether `cancel()` has been called. */
+  get isCancelled() {
+    return this.controller.signal.aborted;
+  }
+  /**
+   * The underlying `AbortSignal`. Pass this directly to APIs that accept
+   * one (the OpenAI / Anthropic SDKs, `fetch`, etc.) so the network call
+   * aborts on cancel instead of just polling out at the next yield point.
+   */
+  get signal() {
+    return this.controller.signal;
+  }
+  cancel() {
+    if (!this.controller.signal.aborted) {
+      this.controller.abort();
+    }
+  }
+  throwIfCancelled() {
+    if (this.controller.signal.aborted) {
+      throw new CancellationError();
+    }
+  }
+};
+var DeadlineCancellationScope = class {
+  constructor(parent, deadlineMonotonicMs, cancellationGraceMs, clock, scheduler) {
+    this.parent = parent;
+    this.deadlineMonotonicMs = deadlineMonotonicMs;
+    this.cancellationGraceMs = cancellationGraceMs;
+    this.clock = clock;
+    this.scheduler = scheduler;
+    if (!Number.isFinite(deadlineMonotonicMs) || deadlineMonotonicMs < 0) {
+      throw new RangeError("deadlineMonotonicMs must be a finite non-negative number");
+    }
+    if (!Number.isFinite(cancellationGraceMs) || cancellationGraceMs <= 0) {
+      throw new RangeError("cancellationGraceMs must be a positive finite number");
+    }
+    this.deadlineWake = new Promise((resolve) => {
+      this.resolveDeadline = resolve;
+    });
+    this.parentWake = new Promise((resolve) => {
+      this.resolveParent = resolve;
+    });
+    this.parentAbort = () => {
+      this.requestCancellation("parent");
+      this.resolveParent();
+    };
+    parent.signal.addEventListener("abort", this.parentAbort, { once: true });
+    if (parent.isCancelled) this.parentAbort();
+    this.deadlineTimer = scheduler.schedule(
+      Math.max(0, deadlineMonotonicMs - clock.nowMonotonic()),
+      () => {
+        this.requestCancellation("deadline");
+        this.resolveDeadline();
+      }
+    );
+  }
+  parent;
+  deadlineMonotonicMs;
+  cancellationGraceMs;
+  clock;
+  scheduler;
+  token = new CancellationToken();
+  deadlineWake;
+  parentWake;
+  resolveDeadline;
+  resolveParent;
+  parentAbort;
+  deadlineTimer;
+  iterator;
+  activeNext;
+  closePromise;
+  transferred = false;
+  yielded = false;
+  dispatched = false;
+  cancellationRequestedAtMs;
+  cancellationSource;
+  async *consume(stream) {
+    this.iterator = stream[Symbol.asyncIterator]();
+    let providerError;
+    try {
+      while (true) {
+        if (this.parent.isCancelled) await this.abort(void 0, true, "parent");
+        if (this.clock.nowMonotonic() >= this.deadlineMonotonicMs) {
+          await this.abort(void 0, false, "deadline");
+        }
+        if (this.token.isCancelled && this.cancellationSource === void 0) {
+          await this.abort(void 0, true, "provider");
+        }
+        this.dispatched = true;
+        const next = this.iterator.next();
+        this.activeNext = next;
+        const settlementEvidence = () => ({
+          settledAtMs: this.clock.nowMonotonic(),
+          cancellationSource: this.cancellationSource,
+          parentCancelled: this.parent.isCancelled,
+          tokenCancelled: this.token.isCancelled
+        });
+        const providerResult = next.then(
+          (result) => ({ status: "settled", result, ...settlementEvidence() }),
+          (error) => ({ status: "failed", error, ...settlementEvidence() })
+        );
+        const wake = await Promise.race([
+          providerResult,
+          this.deadlineWake.then(() => ({ status: "deadline" })),
+          this.parentWake.then(() => ({ status: "parent" }))
+        ]);
+        if (wake.status === "failed") {
+          if ((wake.parentCancelled || wake.cancellationSource === "parent") && isCancellationCompatible(wake.error)) {
+            await this.abort(next, true, "parent");
+          }
+          if (wake.cancellationSource === "deadline" || wake.settledAtMs >= this.deadlineMonotonicMs) {
+            await this.abort(next, false, "deadline");
+          }
+          if (wake.cancellationSource === "provider" || wake.tokenCancelled && wake.cancellationSource === void 0) {
+            await this.abort(next, true, "provider");
+          }
+          this.activeNext = void 0;
+          throw wake.error;
+        }
+        if (this.parent.isCancelled) await this.abort(next, true, "parent");
+        if (wake.status === "deadline" || this.clock.nowMonotonic() >= this.deadlineMonotonicMs) {
+          await this.abort(next, false, "deadline");
+        }
+        if (this.token.isCancelled && this.cancellationSource === void 0) {
+          await this.abort(next, true, "provider");
+        }
+        if (wake.status !== "settled") continue;
+        this.activeNext = void 0;
+        if (wake.result.done) return;
+        this.yielded = true;
+        yield wake.result.value;
+      }
+    } catch (error) {
+      if (error instanceof ProviderCancellationContractViolation) {
+        this.transferred = true;
+      } else {
+        providerError = error;
+      }
+      throw error;
+    } finally {
+      if (!this.transferred) {
+        try {
+          await this.finishClose();
+        } catch (closeError) {
+          if (closeError instanceof ProviderCancellationContractViolation) {
+            this.transferred = true;
+            if (providerError !== void 0 && closeError.cause === void 0) {
+              Object.defineProperty(closeError, "cause", {
+                value: providerError,
+                configurable: true
+              });
+            }
+            throw closeError;
+          }
+          if (providerError === void 0) throw closeError;
+        }
+      }
+    }
+  }
+  dispose() {
+    this.deadlineTimer.cancel();
+    this.parent.signal.removeEventListener("abort", this.parentAbort);
+  }
+  async abort(active, callerCancelled, source) {
+    this.requestCancellation(source);
+    const settlement = Promise.resolve(active).catch(() => void 0).then(() => this.closeOnce());
+    let graceTimer;
+    const grace = new Promise((resolve) => {
+      const requestedAt = this.cancellationRequestedAtMs ?? this.clock.nowMonotonic();
+      const remaining = Math.max(
+        0,
+        requestedAt + this.cancellationGraceMs - this.clock.nowMonotonic()
+      );
+      graceTimer = this.scheduler.schedule(remaining, () => resolve({ status: "grace" }));
+    });
+    try {
+      const result = await Promise.race([
+        settlement.then(
+          () => ({ status: "settled" }),
+          () => ({ status: "failed" })
+        ),
+        grace
+      ]);
+      if (result.status === "settled") {
+        if (callerCancelled) throw new CancellationError();
+        throw new TurnTimeoutError(
+          this.yielded ? "provider_stream" : "provider_open",
+          true,
+          this.dispatched ? "unknown" : "not_started"
+        );
+      }
+      if (result.status === "failed") {
+        this.transferred = true;
+        throw this.contractViolation(settlement);
+      }
+      this.transferred = true;
+      throw this.contractViolation(settlement);
+    } finally {
+      graceTimer?.cancel();
+    }
+  }
+  closeOnce() {
+    if (this.closePromise !== void 0) return this.closePromise;
+    const iterator = this.iterator;
+    this.closePromise = (async () => {
+      if (this.activeNext !== void 0) {
+        try {
+          await this.activeNext;
+        } catch {
+        }
+      }
+      await iterator?.return?.();
+    })();
+    return this.closePromise;
+  }
+  async finishClose() {
+    if (this.iterator === void 0) return;
+    const close = this.closeOnce();
+    const settled = close.then(
+      () => ({ status: "settled" }),
+      () => ({ status: "failed" })
+    );
+    const wake = await Promise.race([
+      settled,
+      this.deadlineWake.then(() => ({ status: "deadline" })),
+      this.parentWake.then(() => ({ status: "parent" }))
+    ]);
+    if (wake.status === "settled") return;
+    if (wake.status === "failed") {
+      this.transferred = true;
+      throw this.contractViolation(close);
+    }
+    if (this.parent.isCancelled) await this.abort(this.activeNext, true, "parent");
+    if (wake.status === "deadline" || this.clock.nowMonotonic() >= this.deadlineMonotonicMs) {
+      await this.abort(this.activeNext, false, "deadline");
+    }
+    await close;
+  }
+  requestCancellation(source) {
+    if (this.cancellationRequestedAtMs === void 0) {
+      this.cancellationRequestedAtMs = this.clock.nowMonotonic();
+    }
+    this.cancellationSource ??= source;
+    this.token.cancel();
+  }
+  contractViolation(settlement) {
+    const phase = this.yielded ? "provider_stream" : "provider_open";
+    return attachProviderViolationSettlement(
+      new ProviderCancellationContractViolation(phase),
+      settlement
+    );
+  }
+};
+function createDeadlineCancellationScope(parent, deadlineMonotonicMs, cancellationGraceMs, clock, scheduler) {
+  return new DeadlineCancellationScope(
+    parent,
+    deadlineMonotonicMs,
+    cancellationGraceMs,
+    clock,
+    scheduler
+  );
+}
+
+// src/providers/base.ts
+var PROVIDER_RESPONSE_DIAGNOSTICS = /* @__PURE__ */ Symbol.for(
+  "kaji.provider.responseDiagnostics"
+);
+function withProviderResponseDiagnostics(options, sink) {
+  const internal = { ...options };
+  Object.defineProperty(internal, PROVIDER_RESPONSE_DIAGNOSTICS, {
+    value: sink,
+    enumerable: false
+  });
+  return internal;
+}
+function getProviderResponseDiagnostics(options) {
+  return options?.[PROVIDER_RESPONSE_DIAGNOSTICS];
+}
+var DEFAULT_PROVIDER_RESPONSE_LIMITS = Object.freeze({
+  textMaxBytes: 262144,
+  toolArgumentsMaxBytes: 65536,
+  responseMaxBytes: 524288,
+  toolCallsMax: 64
+});
+function resolveProviderResponseLimits(limits) {
+  const resolved = { ...DEFAULT_PROVIDER_RESPONSE_LIMITS, ...limits };
+  for (const [name, value] of Object.entries(resolved)) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+      throw new RangeError(`${name} must be a positive safe integer`);
+    }
+  }
+  return Object.freeze(resolved);
+}
+function parseRetryAfterMs(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const headers = "headers" in error ? error.headers : "response" in error && typeof error.response === "object" ? error.response?.headers ?? null : null;
+  if (typeof headers !== "object" || headers === null) return void 0;
+  const retryAfter = headers["retry-after"];
+  if (!retryAfter) return void 0;
+  const seconds = Number(retryAfter);
+  return Number.isFinite(seconds) ? seconds * 1e3 : void 0;
+}
+async function withRetry(fn, retry, cancellationToken, metricsSink = NOOP_METRICS, providerFamily2 = "custom") {
+  const { maxAttempts, baseDelayMs } = retry;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    throwIfCancellationRequested(cancellationToken);
+    try {
+      return await fn();
+    } catch (error) {
+      const statusCode = typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
+      if (statusCode !== 429 || attempt === maxAttempts) {
+        throw error;
+      }
+      const retryAfterMs = parseRetryAfterMs(error) ?? baseDelayMs * 2 ** (attempt - 1);
+      recordMetric(metricsSink, "kaji.provider.retries", 1, {
+        provider_family: providerFamily2
+      });
+      lastError = error;
+      await cancellableDelay(retryAfterMs, cancellationToken);
+    }
+  }
+  throw lastError;
+}
+async function openStreamWithRetry(create, retry, cancellationToken, metricsSink = NOOP_METRICS, providerFamily2 = "custom") {
+  const opened = await withRetry(
+    async () => {
+      const stream = await create();
+      const iterator = stream[Symbol.asyncIterator]();
+      try {
+        return { iterator, first: await iterator.next() };
+      } catch (error) {
+        try {
+          await iterator.return?.();
+        } catch {
+        }
+        throw error;
+      }
+    },
+    retry,
+    cancellationToken,
+    metricsSink,
+    providerFamily2
+  );
+  return new BufferedAsyncIterator(opened.iterator, opened.first);
+}
+var BufferedAsyncIterator = class {
+  constructor(inner, first) {
+    this.inner = inner;
+    this.first = first;
+  }
+  inner;
+  first;
+  firstPending = true;
+  closed = false;
+  closePromise;
+  async next() {
+    if (this.closed) return { value: void 0, done: true };
+    if (this.firstPending) {
+      this.firstPending = false;
+      if (this.first.done) this.markNaturallyClosed();
+      return this.first;
+    }
+    try {
+      const next = await this.inner.next();
+      if (next.done) this.markNaturallyClosed();
+      return next;
+    } catch (error) {
+      try {
+        await this.close();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async return(value) {
+    await this.close();
+    return { value, done: true };
+  }
+  async throw(error) {
+    await this.close();
+    throw error;
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  markNaturallyClosed() {
+    this.closed = true;
+    this.closePromise = Promise.resolve();
+  }
+  close() {
+    if (this.closePromise !== void 0) return this.closePromise;
+    this.closed = true;
+    this.firstPending = false;
+    try {
+      const result = this.inner.return?.();
+      this.closePromise = Promise.resolve(result).then(() => void 0);
+    } catch (error) {
+      this.closePromise = Promise.reject(error);
+    }
+    return this.closePromise;
+  }
+};
+async function cancellableDelay(delayMs, cancellationToken) {
+  throwIfCancellationRequested(cancellationToken);
+  if (cancellationToken === void 0) {
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+    return;
+  }
+  const signal = cancellationToken?.signal;
+  if (signal === void 0) {
+    const deadline = globalThis.performance.now() + delayMs;
+    while (globalThis.performance.now() < deadline) {
+      throwIfCancellationRequested(cancellationToken);
+      await new Promise(
+        (resolve) => setTimeout(resolve, Math.min(10, deadline - globalThis.performance.now()))
+      );
+    }
+    throwIfCancellationRequested(cancellationToken);
+    return;
+  }
+  if (signal.aborted) throw new CancellationError();
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", onAbort);
+      reject(new CancellationError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/providers/errors.ts
+var PROVIDER_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderError.v1");
+var PROVIDER_CONFIG_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderConfigError.v1");
+var PROVIDER_API_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderAPIError.v1");
+var PROVIDER_CONNECTION_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderConnectionError.v1");
+var PROVIDER_RATE_LIMITED_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderRateLimitedError.v1");
+var PROVIDER_OUTPUT_LIMIT_ERROR_BRAND = /* @__PURE__ */ Symbol.for("kaji.ProviderOutputLimitError.v1");
+function brand(value, key) {
+  Object.defineProperty(value, key, { value: true });
+}
+function hasBrand(value, key) {
+  return typeof value === "object" && value !== null && Reflect.get(value, key) === true;
+}
+var ProviderError = class extends Error {
+  service;
+  action;
+  statusCode;
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message);
+    brand(this, PROVIDER_ERROR_BRAND);
+    this.name = new.target.name;
+    this.service = options.service ?? "provider";
+    this.action = options.action ?? "request";
+    if (options.statusCode !== void 0) this.statusCode = options.statusCode;
+  }
+};
+var ProviderConfigError = class extends ProviderError {
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_CONFIG_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message, { ...options, action: "configure" });
+    brand(this, PROVIDER_CONFIG_ERROR_BRAND);
+  }
+};
+var ProviderAPIError = class extends ProviderError {
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_API_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message, { ...options, action: options.action ?? "api call" });
+    brand(this, PROVIDER_API_ERROR_BRAND);
+  }
+};
+var ProviderConnectionError = class extends ProviderError {
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_CONNECTION_ERROR_BRAND);
+  }
+  constructor(message, options = {}) {
+    super(message, { ...options, action: options.action ?? "connect" });
+    brand(this, PROVIDER_CONNECTION_ERROR_BRAND);
+  }
+};
+var ProviderRateLimitedError = class extends ProviderError {
+  retryAfterMs;
+  attempts;
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_RATE_LIMITED_ERROR_BRAND);
+  }
+  constructor(message, options) {
+    super(message, { ...options, action: "api call", statusCode: 429 });
+    brand(this, PROVIDER_RATE_LIMITED_ERROR_BRAND);
+    this.retryAfterMs = options.retryAfterMs;
+    this.attempts = options.attempts;
+  }
+};
+var ProviderOutputLimitError = class extends Error {
+  constructor(dimension, limit) {
+    if (!["text", "tool_arguments", "total_response", "tool_calls"].includes(dimension)) {
+      throw new TypeError("unknown provider output dimension");
+    }
+    if (!Number.isSafeInteger(limit) || limit < 1) {
+      throw new RangeError("provider output limit must be a positive safe integer");
+    }
+    const unit = dimension === "tool_calls" ? "calls" : "bytes";
+    super(`Provider output exceeded ${dimension} limit of ${limit} ${unit}`);
+    this.dimension = dimension;
+    this.limit = limit;
+    brand(this, PROVIDER_OUTPUT_LIMIT_ERROR_BRAND);
+    this.name = "ProviderOutputLimitError";
+  }
+  dimension;
+  limit;
+  code = "PROVIDER_OUTPUT_LIMIT";
+  phase = "provider_stream";
+  retryable = false;
+  outcome = "unknown";
+  static [Symbol.hasInstance](value) {
+    return hasBrand(value, PROVIDER_OUTPUT_LIMIT_ERROR_BRAND);
+  }
+};
+function errorStatusCode(error) {
+  if (typeof error !== "object" || error === null) return void 0;
+  const status = "status" in error ? error.status : void 0;
+  const statusCode = "statusCode" in error ? error.statusCode : void 0;
+  return typeof status === "number" ? status : typeof statusCode === "number" ? statusCode : void 0;
+}
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "EAI_AGAIN",
+  "ECONNABORTED",
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENETUNREACH",
+  "ENOTFOUND",
+  "ETIMEDOUT",
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+var NETWORK_ERROR_TYPE_NAMES = /* @__PURE__ */ new Set([
+  "APIConnectionError",
+  "APIConnectionTimeoutError",
+  "APITimeoutError"
+]);
+function isNetworkError(error) {
+  if (typeof error !== "object" || error === null) return false;
+  const code = "code" in error ? error.code : void 0;
+  const constructorName = error.constructor?.name;
+  return typeof code === "string" && NETWORK_ERROR_CODES.has(code) || typeof constructorName === "string" && NETWORK_ERROR_TYPE_NAMES.has(constructorName);
+}
+function providerAPIErrorFromUnknown(service, error, action = "request") {
+  if (error instanceof ProviderConfigError) {
+    return new ProviderConfigError(`${service} configuration failed`, {
+      service,
+      statusCode: error.statusCode
+    });
+  }
+  if (error instanceof ProviderConnectionError) {
+    return new ProviderConnectionError(`${service} ${action} failed due to a network error`, {
+      service,
+      action,
+      statusCode: error.statusCode
+    });
+  }
+  if (error instanceof ProviderRateLimitedError) {
+    return new ProviderRateLimitedError(`${service} rate limit exceeded`, {
+      service,
+      retryAfterMs: error.retryAfterMs,
+      attempts: error.attempts
+    });
+  }
+  if (error instanceof ProviderError) {
+    return new ProviderAPIError(`${service} ${action} failed`, {
+      service,
+      action,
+      statusCode: error.statusCode
+    });
+  }
+  if (isNetworkError(error)) {
+    return new ProviderConnectionError(`${service} ${action} failed due to a network error`, {
+      service,
+      action
+    });
+  }
+  return new ProviderAPIError(`${service} ${action} failed`, {
+    service,
+    action,
+    statusCode: errorStatusCode(error)
+  });
+}
+function normalizeProviderError(error) {
+  const status = error.statusCode ?? null;
+  if (error instanceof ProviderConfigError) {
+    return {
+      type: "config",
+      code: "PROVIDER_CONFIG_ERROR",
+      service: error.service,
+      action: error.action,
+      status,
+      retryable: false
+    };
+  }
+  if (error instanceof ProviderConnectionError) {
+    return {
+      type: "network",
+      code: "PROVIDER_NETWORK_ERROR",
+      service: error.service,
+      action: error.action,
+      status,
+      retryable: true
+    };
+  }
+  if (error instanceof ProviderRateLimitedError || status === 429) {
+    return {
+      type: "rate_limit",
+      code: "PROVIDER_RATE_LIMITED",
+      service: error.service,
+      action: error.action,
+      status,
+      retryable: true
+    };
+  }
+  if (status === 401 || status === 403) {
+    return {
+      type: "auth",
+      code: "PROVIDER_AUTH_ERROR",
+      service: error.service,
+      action: error.action,
+      status,
+      retryable: false
+    };
+  }
+  return {
+    type: "api",
+    code: "PROVIDER_API_ERROR",
+    service: error.service,
+    action: error.action,
+    status,
+    retryable: status !== null && status >= 500
+  };
+}
+
+// src/providers/response-budget.ts
+function scanUtf8Scalars(fragment, pendingHighSurrogate) {
+  if (typeof fragment !== "string")
+    throw new TypeError("provider output fragments must be strings");
+  const input = `${pendingHighSurrogate ?? ""}${fragment}`;
+  const scalars = [];
+  let bytes = 0;
+  let pending;
+  for (let index = 0; index < input.length; index += 1) {
+    const unit = input.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      if (index + 1 >= input.length) {
+        pending = input[index];
+        break;
+      }
+      const low = input.charCodeAt(index + 1);
+      if (!(low >= 56320 && low <= 57343)) {
+        throw new TypeError("provider output contains an unpaired Unicode surrogate");
+      }
+      scalars.push({ text: input.slice(index, index + 2), bytes: 4 });
+      bytes += 4;
+      index += 1;
+      continue;
+    }
+    if (unit >= 56320 && unit <= 57343) {
+      throw new TypeError("provider output contains an unpaired Unicode surrogate");
+    }
+    const scalarBytes = unit <= 127 ? 1 : unit <= 2047 ? 2 : 3;
+    scalars.push({ text: input[index], bytes: scalarBytes });
+    bytes += scalarBytes;
+  }
+  return pending === void 0 ? { scalars, bytes } : { scalars, bytes, pendingHighSurrogate: pending };
+}
+function utf8ByteLength(value) {
+  const scan = scanUtf8Scalars(value);
+  if (scan.pendingHighSurrogate !== void 0) {
+    throw new TypeError("provider output contains an unpaired Unicode surrogate");
+  }
+  return scan.bytes;
+}
+var LinearStringParts = class {
+  parts = [];
+  _fragmentCount = 0;
+  _joinOperations = 0;
+  get fragmentCount() {
+    return this._fragmentCount;
+  }
+  get joinOperations() {
+    return this._joinOperations;
+  }
+  append(fragment) {
+    if (!fragment) return;
+    this.parts.push(fragment);
+    this._fragmentCount += 1;
+  }
+  join() {
+    this._joinOperations += 1;
+    return this.parts.join("");
+  }
+};
+var ProviderResponseBudget = class {
+  limits;
+  textBytes = 0;
+  totalBytes = 0;
+  callCount = 0;
+  rawFragments = 0;
+  argumentJoins = 0;
+  textPendingHighSurrogate;
+  rawToolCalls = /* @__PURE__ */ new Map();
+  constructor(limits) {
+    this.limits = resolveProviderResponseLimits(limits);
+  }
+  get diagnostics() {
+    return Object.freeze({
+      textBytes: this.textBytes,
+      totalResponseBytes: this.totalBytes,
+      toolCalls: this.callCount,
+      rawFragments: this.rawFragments,
+      toolArgumentJoinOperations: this.argumentJoins
+    });
+  }
+  get providerDiagnostics() {
+    return Object.freeze({
+      rawFragments: this.rawFragments,
+      toolArgumentJoinOperations: this.argumentJoins
+    });
+  }
+  acceptRaw(input) {
+    const text = input.text ?? "";
+    const textScan = scanUtf8Scalars(text, this.textPendingHighSurrogate);
+    const nextTextBytes = this.textBytes + textScan.bytes;
+    if (nextTextBytes > this.limits.textMaxBytes) {
+      throw new ProviderOutputLimitError("text", this.limits.textMaxBytes);
+    }
+    const nextStates = new Map([...this.rawToolCalls].map(([key, state]) => [key, { ...state }]));
+    let addedTotal = textScan.bytes;
+    let addedCalls = 0;
+    let addedFragments = text ? 1 : 0;
+    for (const fragment of input.toolFragments ?? []) {
+      let state = nextStates.get(fragment.key);
+      if (fragment.startsCall) {
+        if (state !== void 0) throw new TypeError("provider tool call started more than once");
+        state = { argumentBytes: 0 };
+        nextStates.set(fragment.key, state);
+        addedCalls += 1;
+      } else if (state === void 0) {
+        throw new TypeError("provider tool fragment must start a call before appending");
+      }
+      const id = scanUtf8Scalars(fragment.idFragment ?? "", state.idPending);
+      const name = scanUtf8Scalars(fragment.nameFragment ?? "", state.namePending);
+      const args = scanUtf8Scalars(fragment.argumentsFragment ?? "", state.argumentsPending);
+      state.idPending = id.pendingHighSurrogate;
+      state.namePending = name.pendingHighSurrogate;
+      state.argumentsPending = args.pendingHighSurrogate;
+      state.argumentBytes += args.bytes;
+      if (state.argumentBytes > this.limits.toolArgumentsMaxBytes) {
+        throw new ProviderOutputLimitError("tool_arguments", this.limits.toolArgumentsMaxBytes);
+      }
+      addedTotal += id.bytes + name.bytes + args.bytes;
+      addedFragments += Number(Boolean(fragment.idFragment));
+      addedFragments += Number(Boolean(fragment.nameFragment));
+      addedFragments += Number(Boolean(fragment.argumentsFragment));
+    }
+    const nextCalls = this.callCount + addedCalls;
+    if (nextCalls > this.limits.toolCallsMax) {
+      throw new ProviderOutputLimitError("tool_calls", this.limits.toolCallsMax);
+    }
+    const nextTotal = this.totalBytes + addedTotal;
+    if (nextTotal > this.limits.responseMaxBytes) {
+      throw new ProviderOutputLimitError("total_response", this.limits.responseMaxBytes);
+    }
+    this.textBytes = nextTextBytes;
+    this.totalBytes = nextTotal;
+    this.callCount = nextCalls;
+    this.rawFragments += addedFragments;
+    this.textPendingHighSurrogate = textScan.pendingHighSurrogate;
+    this.rawToolCalls = nextStates;
+  }
+  acceptNormalized(delta, toolCalls) {
+    const textScan = scanUtf8Scalars(delta, this.textPendingHighSurrogate);
+    const nextTextBytes = this.textBytes + textScan.bytes;
+    if (nextTextBytes > this.limits.textMaxBytes) {
+      throw new ProviderOutputLimitError("text", this.limits.textMaxBytes);
+    }
+    let addedTotal = textScan.bytes;
+    const serializedCalls = [];
+    for (const call of toolCalls) {
+      const descriptors = Object.getOwnPropertyDescriptors(call);
+      const id = dataProperty(descriptors, "id");
+      const name = dataProperty(descriptors, "name");
+      const args = dataProperty(descriptors, "args");
+      if (typeof id !== "string" || typeof name !== "string") {
+        throw new TypeError("provider tool call id and name must be strings");
+      }
+      const encodedArguments = canonicalJsonValue(args ?? {}, "tool arguments");
+      const argumentBytes = utf8ByteLength(encodedArguments);
+      if (argumentBytes > this.limits.toolArgumentsMaxBytes) {
+        throw new ProviderOutputLimitError("tool_arguments", this.limits.toolArgumentsMaxBytes);
+      }
+      addedTotal += utf8ByteLength(id) + utf8ByteLength(name) + argumentBytes;
+      serializedCalls.push({ id, name, encodedArguments });
+    }
+    const nextCalls = this.callCount + serializedCalls.length;
+    if (nextCalls > this.limits.toolCallsMax) {
+      throw new ProviderOutputLimitError("tool_calls", this.limits.toolCallsMax);
+    }
+    const nextTotal = this.totalBytes + addedTotal;
+    if (nextTotal > this.limits.responseMaxBytes) {
+      throw new ProviderOutputLimitError("total_response", this.limits.responseMaxBytes);
+    }
+    const detached = serializedCalls.map(
+      ({ id, name, encodedArguments }) => Object.freeze({
+        id,
+        name,
+        args: cloneAndFreezeJson(JSON.parse(encodedArguments))
+      })
+    );
+    this.textBytes = nextTextBytes;
+    this.totalBytes = nextTotal;
+    this.callCount = nextCalls;
+    this.textPendingHighSurrogate = textScan.pendingHighSurrogate;
+    return Object.freeze({ delta, toolCalls: Object.freeze(detached) });
+  }
+  finishRawTool(key) {
+    const state = this.rawToolCalls.get(key);
+    if (state === void 0) throw new TypeError("unknown provider tool call");
+    assertNoPendingSurrogate(state.idPending);
+    assertNoPendingSurrogate(state.namePending);
+    assertNoPendingSurrogate(state.argumentsPending);
+  }
+  finish() {
+    assertNoPendingSurrogate(this.textPendingHighSurrogate);
+    for (const key of this.rawToolCalls.keys()) this.finishRawTool(key);
+  }
+  recordToolArgumentJoin() {
+    this.argumentJoins += 1;
+  }
+};
+function dataProperty(descriptors, key) {
+  const descriptor = descriptors[key];
+  if (descriptor === void 0) return void 0;
+  if (!descriptor.enumerable || !("value" in descriptor)) {
+    throw new TypeError("provider tool calls must contain enumerable data properties");
+  }
+  return descriptor.value;
+}
+function assertNoPendingSurrogate(pending) {
+  if (pending !== void 0) {
+    throw new TypeError("provider output contains an unpaired Unicode surrogate");
+  }
+}
+async function closeProviderStream(stream) {
+  if (typeof stream !== "object" || stream === null) return;
+  const candidate = stream;
+  const close = candidate.controller?.abort?.bind(candidate.controller) ?? candidate.abort?.bind(candidate) ?? candidate.return?.bind(candidate) ?? candidate.close?.bind(candidate);
+  if (close === void 0) return;
+  try {
+    await close();
+  } catch {
+  }
+}
+
+export { AgentTurnFailed, CancellationError, CancellationToken, DEFAULT_PROVIDER_RESPONSE_LIMITS, DEFAULT_TURN_EXECUTION_LIMITS, DurableJsonLimitError, EventBufferOverflowError, EventDeliveryError, EventIdConflictError, EventSchemaIncompatibleError, EventStoreCapacityError, EventType, InvalidDurableValueError, KajiEvent, LinearStringParts, MAX_DURABLE_TOOL_ARGUMENT_BYTES, MAX_DURABLE_TOOL_RESULT_BYTES, METRIC_NAMES, NOOP_METRICS, NOOP_TRACE, NewKajiEvent, ProviderAPIError, ProviderCancellationContractViolation, ProviderConfigError, ProviderConnectionError, ProviderError, ProviderOutputLimitError, ProviderRateLimitedError, ProviderResponseBudget, SessionCreated, SessionPurgeBusyError, SessionPurgeUnsupportedError, StoredKajiEvent, TurnTimeoutError, applyEvent, approvalKey, canonicalJsonValue, cloneAndFreezeJson, cloneSessionState, closeProviderStream, closedRecoveryFields, closedTransportFailureFields, createDeadlineCancellationScope, createSessionState, durableJsonSnapshot, durableToolArgumentsSize, getProviderResponseDiagnostics, normalizeProviderError, openStreamWithRetry, providerAPIErrorFromUnknown, providerFamily, providerViolationSettlement, recordMetric, replaySession, resolveProviderResponseLimits, resolveTurnExecutionLimits, scanUtf8Scalars, snapshotNewEvent, snapshotStoredEventForAppend, startSpan, structurallyEqualJson, systemClock, systemIdFactory, systemTimerScheduler, throwIfCancellationRequested, validateNewEvent, validateStoredEvent, withProviderResponseDiagnostics, withRetry };
+//# sourceMappingURL=chunk-AAM33KAO.js.map
+//# sourceMappingURL=chunk-AAM33KAO.js.map