@irogane/kaji 0.2.0-beta.11

package/dist/integrations.cjs

@@ -0,0 +1,3370 @@
+'use strict';
+
+var z = require('zod');
+var Ajv2020 = require('ajv/dist/2020.js');
+var https = require('https');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var z__namespace = /*#__PURE__*/_interopNamespace(z);
+var Ajv2020__default = /*#__PURE__*/_interopDefault(Ajv2020);
+
+// 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";
+};
+function cloneAndFreezeJson(value) {
+  return cloneJsonValue(value, /* @__PURE__ */ new WeakSet());
+}
+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);
+}
+
+// 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)}`;
+}
+
+// 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/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 recoveryForReason(reasonCode) {
+  const value = INTEGRATION_RECOVERY[reasonCode];
+  if (value === void 0) throw new TypeError("unknown integration recovery reason");
+  return value;
+}
+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 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;
+}
+
+// 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__namespace.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__namespace.record(z__namespace.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__namespace.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__namespace.record(z__namespace.string(), z__namespace.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__namespace.string().min(1);
+var baseShape = {
+  id: nonEmptyId.default(() => defaultUuid()),
+  version: z__namespace.literal("1.0").default("1.0"),
+  timestamp: z__namespace.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__namespace.object(baseShape).extend(shape).strict();
+}
+var SessionCreated = event({
+  type: z__namespace.literal(EventType.SESSION_CREATED)
+});
+var SessionClosed = event({
+  type: z__namespace.literal(EventType.SESSION_CLOSED),
+  reason: z__namespace.string().nullish()
+});
+var UserMessage = event({
+  type: z__namespace.literal(EventType.USER_MESSAGE),
+  content: z__namespace.string()
+});
+var UserAudioChunk = event({
+  type: z__namespace.literal(EventType.USER_AUDIO_CHUNK),
+  chunk_size_bytes: z__namespace.number().int()
+});
+var TranscriptPartial = event({
+  type: z__namespace.literal(EventType.TRANSCRIPT_PARTIAL),
+  text: z__namespace.string()
+});
+var TranscriptFinal = event({
+  type: z__namespace.literal(EventType.TRANSCRIPT_FINAL),
+  text: z__namespace.string()
+});
+var MemoryRetrievalStarted = event({
+  type: z__namespace.literal(EventType.MEMORY_RETRIEVAL_STARTED),
+  query: z__namespace.string()
+});
+var MemoryRetrievalCompleted = event({
+  type: z__namespace.literal(EventType.MEMORY_RETRIEVAL_COMPLETED),
+  query: z__namespace.string(),
+  documents: z__namespace.array(durableSubjectObject("memory_document"))
+});
+var AgentReasoningStarted = event({
+  type: z__namespace.literal(EventType.AGENT_REASONING_STARTED)
+});
+var AgentMessageDelta = event({
+  type: z__namespace.literal(EventType.AGENT_MESSAGE_DELTA),
+  delta: z__namespace.string()
+});
+var AgentMessageCompleted = event({
+  type: z__namespace.literal(EventType.AGENT_MESSAGE_COMPLETED),
+  content: z__namespace.string(),
+  tokens: z__namespace.object({ input: z__namespace.number().int().nonnegative(), output: z__namespace.number().int().nonnegative() }).strict().nullish(),
+  cost_usd: z__namespace.number().nonnegative().nullish()
+});
+var AgentTurnExhausted = event({
+  type: z__namespace.literal(EventType.AGENT_TURN_EXHAUSTED),
+  max_iterations: z__namespace.number().int().nonnegative(),
+  pending_tool_calls: z__namespace.array(durableSubjectObject("pending_tool_call")),
+  reason: z__namespace.string().nullish()
+});
+var AgentTurnFailed = event({
+  type: z__namespace.literal(EventType.AGENT_TURN_FAILED),
+  turn_id: z__namespace.string().min(1),
+  error: z__namespace.string().min(1).superRefine(maxUnicodeCodePoints("error")),
+  error_code: z__namespace.string().optional(),
+  phase: z__namespace.enum(["queue", "provider_open", "provider_stream", "approval", "tool"]).optional(),
+  retryable: z__namespace.boolean().optional(),
+  outcome: z__namespace.enum(["not_started", "failed", "unknown"]).optional()
+});
+var ToolCallRequested = event({
+  type: z__namespace.literal(EventType.TOOL_CALL_REQUESTED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_args: durableToolArguments,
+  tool_call_id: z__namespace.string().min(1)
+});
+var ToolCallStarted = event({
+  type: z__namespace.literal(EventType.TOOL_CALL_STARTED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_call_id: z__namespace.string().min(1)
+});
+var ToolCallCompleted = event({
+  type: z__namespace.literal(EventType.TOOL_CALL_COMPLETED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_call_id: z__namespace.string().min(1),
+  result: durableSubjectValue("tool_result", MAX_DURABLE_TOOL_RESULT_BYTES),
+  tokens: z__namespace.object({ input: z__namespace.number().int().nonnegative(), output: z__namespace.number().int().nonnegative() }).strict().nullish(),
+  cost_usd: z__namespace.number().nonnegative().nullish()
+});
+var ToolCallFailed = event({
+  type: z__namespace.literal(EventType.TOOL_CALL_FAILED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_call_id: z__namespace.string().min(1),
+  error: z__namespace.string().min(1).superRefine(maxUnicodeCodePoints("error")),
+  error_code: z__namespace.string().optional(),
+  error_path: z__namespace.string().optional(),
+  retryable: z__namespace.boolean().optional(),
+  outcome: z__namespace.enum(["not_started", "failed", "unknown"]).optional(),
+  reason_code: z__namespace.string().optional(),
+  recovery_code: z__namespace.string().optional(),
+  doc_url: z__namespace.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__namespace.literal(EventType.TOOL_APPROVAL_REQUESTED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_call_id: z__namespace.string().min(1),
+  tool_args: durableToolArguments,
+  risk: z__namespace.enum(["read", "write", "external_effect", "destructive", "admin"])
+});
+var ToolApprovalApproved = event({
+  type: z__namespace.literal(EventType.TOOL_APPROVAL_APPROVED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_call_id: z__namespace.string().min(1)
+});
+var ToolApprovalRejected = event({
+  type: z__namespace.literal(EventType.TOOL_APPROVAL_REJECTED),
+  turn_id: z__namespace.string().min(1),
+  tool_name: z__namespace.string().min(1),
+  tool_call_id: z__namespace.string().min(1),
+  error_code: z__namespace.enum([
+    "APPROVAL_REJECTED",
+    "APPROVAL_TIMEOUT",
+    "TURN_TIMEOUT",
+    "TOOL_CANCELLED",
+    "APPROVAL_UNAVAILABLE"
+  ]),
+  reason: z__namespace.string().min(1).refine((value) => value.trim().length > 0, "reason must not be blank").superRefine(maxUnicodeCodePoints("reason"))
+});
+var WorkflowStarted = event({
+  type: z__namespace.literal(EventType.WORKFLOW_STARTED),
+  workflow_name: z__namespace.string()
+});
+var WorkflowCompleted = event({
+  type: z__namespace.literal(EventType.WORKFLOW_COMPLETED),
+  workflow_name: z__namespace.string(),
+  result: durableSubjectValue("workflow_result", MAX_DURABLE_EVENT_BYTES)
+});
+var WorkflowFailed = event({
+  type: z__namespace.literal(EventType.WORKFLOW_FAILED),
+  workflow_name: z__namespace.string(),
+  error: z__namespace.string()
+});
+var CancellationRequested = event({
+  type: z__namespace.literal(EventType.CANCELLATION_REQUESTED),
+  reason: z__namespace.string()
+});
+var CancellationCompleted = event({
+  type: z__namespace.literal(EventType.CANCELLATION_COMPLETED)
+});
+var KajiEvent = z__namespace.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
+]);
+z__namespace.object({ sequence: z__namespace.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__namespace.NEVER;
+  }
+  return cloneAndFreezeJson({ ...parsed.data, sequence });
+});
+new Set(Object.values(EventType));
+var wireAjv = new Ajv2020__default.default({ allErrors: true, strict: false });
+wireAjv.compile(new_kaji_event_v1_schema_default);
+wireAjv.compile(stored_kaji_event_v1_schema_default);
+
+// src/tools/execution-errors.ts
+var TOOL_EXECUTION_ERROR_BRAND = /* @__PURE__ */ Symbol.for("@kaji/sdk.ToolExecutionError.v1");
+function nativeInstanceOf(constructor, value) {
+  return Function.prototype[Symbol.hasInstance].call(constructor, value);
+}
+var ToolExecutionError = class _ToolExecutionError extends Error {
+  constructor(message, error_code, retryable, outcome, recovery2) {
+    super(message);
+    this.error_code = error_code;
+    this.retryable = retryable;
+    this.outcome = outcome;
+    this.name = "ToolExecutionError";
+    Object.defineProperty(this, TOOL_EXECUTION_ERROR_BRAND, { value: true });
+    if (recovery2 !== void 0) {
+      this.reason_code = recovery2.reason_code;
+      this.recovery_code = recovery2.recovery_code;
+      this.doc_url = recovery2.doc_url;
+    }
+  }
+  error_code;
+  retryable;
+  outcome;
+  static [Symbol.hasInstance](value) {
+    if (this !== _ToolExecutionError) return nativeInstanceOf(this, value);
+    return nativeInstanceOf(this, value) || value instanceof Error && Reflect.get(value, TOOL_EXECUTION_ERROR_BRAND) === true;
+  }
+  reason_code;
+  recovery_code;
+  doc_url;
+};
+
+// src/integrations/errors.ts
+function certified(kind, reasonCode, retryable) {
+  return Object.freeze({ kind, recovery: recoveryForReason(reasonCode), retryable });
+}
+var CERTIFIED_FAILURES = Object.freeze({
+  api_rejected: certified("api", "api_rejected", false),
+  github_token_missing: certified("auth_required", "github_token_missing", false),
+  gmail_grant_missing: certified("auth_required", "gmail_grant_missing", false),
+  gmail_scope_drift: certified("auth_required", "gmail_scope_drift", false),
+  keychain_missing: certified("auth", "keychain_missing", false),
+  keychain_locked: certified("auth", "keychain_locked", false),
+  keychain_corrupt: certified("auth", "keychain_corrupt", false),
+  keychain_unsupported: certified("auth", "keychain_unsupported", false),
+  rate_limited: certified("rate_limited", "rate_limited", true),
+  transient_read_failed: certified("transient_read", "transient_read_failed", true),
+  policy_rejected: certified("policy", "policy_rejected", false)
+});
+function certifiedFailure(reasonCode) {
+  const failure = CERTIFIED_FAILURES[reasonCode];
+  if (failure === void 0) throw new TypeError("uncertified integration failure reason");
+  return failure;
+}
+function constructorKind(constructor) {
+  if (constructor === IntegrationExecutionError) return "api";
+  if (constructor === IntegrationAuthRequiredError) return "auth_required";
+  if (constructor === IntegrationAuthError) return "auth";
+  if (constructor === IntegrationRateLimitedError) return "rate_limited";
+  if (constructor === IntegrationTransientReadError) return "transient_read";
+  if (constructor === IntegrationPolicyError) return "policy";
+  return void 0;
+}
+var IntegrationExecutionError = class extends ToolExecutionError {
+  constructor(reasonCode) {
+    const failure = certifiedFailure(reasonCode);
+    if (failure.kind !== constructorKind(new.target)) {
+      throw new TypeError("integration failure reason is not certified for this error class");
+    }
+    const { recovery: recovery2 } = failure;
+    super("Tool execution failed", recovery2.errorCode, failure.retryable, "failed", {
+      reason_code: reasonCode,
+      recovery_code: recovery2.recoveryCode,
+      doc_url: recovery2.docUrl
+    });
+    this.name = "IntegrationExecutionError";
+  }
+};
+var IntegrationAuthRequiredError = class extends IntegrationExecutionError {
+  constructor(reasonCode) {
+    super(reasonCode);
+    this.name = "IntegrationAuthRequiredError";
+  }
+};
+var IntegrationAuthError = class extends IntegrationExecutionError {
+  constructor(reasonCode) {
+    super(reasonCode);
+    this.name = "IntegrationAuthError";
+  }
+};
+var IntegrationRateLimitedError = class extends IntegrationExecutionError {
+  constructor() {
+    super("rate_limited");
+    this.name = "IntegrationRateLimitedError";
+  }
+};
+var IntegrationTransientReadError = class extends IntegrationExecutionError {
+  constructor() {
+    super("transient_read_failed");
+    this.name = "IntegrationTransientReadError";
+  }
+};
+var IntegrationPolicyError = class extends IntegrationExecutionError {
+  constructor() {
+    super("policy_rejected");
+    this.name = "IntegrationPolicyError";
+  }
+};
+var IntegrationTransportError = class extends Error {
+  constructor(error_code, reasonCode) {
+    super("Integration transport failed");
+    this.error_code = error_code;
+    this.name = "IntegrationTransportError";
+    if (reasonCode !== void 0) {
+      const recovery2 = recoveryForReason(reasonCode);
+      if (recovery2.errorCode !== error_code) {
+        throw new TypeError("integration recovery reason does not match error code");
+      }
+      this.reason_code = reasonCode;
+      this.recovery_code = recovery2.recoveryCode;
+      this.doc_url = recovery2.docUrl;
+    }
+  }
+  error_code;
+  reason_code;
+  recovery_code;
+  doc_url;
+};
+
+// 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"
+});
+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 {
+      }
+    }
+  };
+}
+
+// src/integrations/fixed-origin.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_RESPONSE_BYTES = 1048576;
+var MAX_RESPONSE_HEADER_FIELDS = 64;
+var MAX_RESPONSE_HEADER_BYTES = 64 * 1024;
+var FORBIDDEN_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "connection",
+  "content-length",
+  "host",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+function policyError() {
+  return new IntegrationPolicyError();
+}
+function responseLimit() {
+  return new IntegrationTransportError("INTEGRATION_RESPONSE_LIMIT", "response_limit_exceeded");
+}
+function positiveInteger(value, fallback) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < 1) throw policyError();
+  return resolved;
+}
+function validatedOrigin(input) {
+  const origin = new URL(input.href);
+  if (origin.protocol !== "https:" || origin.username !== "" || origin.password !== "" || origin.pathname !== "/" || origin.search !== "" || origin.hash !== "") {
+    throw policyError();
+  }
+  return origin;
+}
+function validatedPath(origin, pathAndQuery) {
+  if (typeof pathAndQuery !== "string" || !pathAndQuery.startsWith("/") || pathAndQuery.startsWith("//") || pathAndQuery.includes("\\") || pathAndQuery.includes("#")) {
+    throw policyError();
+  }
+  const rawPath = pathAndQuery.split("?", 1)[0];
+  let decodedPath;
+  try {
+    decodedPath = decodeURIComponent(rawPath);
+  } catch {
+    throw policyError();
+  }
+  if (decodedPath.startsWith("//") || decodedPath.includes("\\")) throw policyError();
+  const target = new URL(pathAndQuery, origin);
+  if (target.origin !== origin.origin) throw policyError();
+  return target;
+}
+function validatedRequestHeaders(input) {
+  let headers;
+  try {
+    headers = new Headers(input);
+  } catch {
+    throw policyError();
+  }
+  const result = {};
+  for (const [name, value] of headers) {
+    const normalized = name.toLowerCase();
+    if (FORBIDDEN_REQUEST_HEADERS.has(normalized) || normalized.startsWith("proxy-")) {
+      throw policyError();
+    }
+    result[normalized] = value;
+  }
+  return Object.freeze(result);
+}
+function boundedResponseHeaders(input) {
+  if (input.length > MAX_RESPONSE_HEADER_FIELDS) throw responseLimit();
+  const encoder = new TextEncoder();
+  let size = 0;
+  const result = {};
+  const contentLengths = [];
+  for (const [name, value] of input) {
+    size += encoder.encode(name).byteLength + encoder.encode(value).byteLength;
+    if (size > MAX_RESPONSE_HEADER_BYTES) throw responseLimit();
+    const normalized = name.toLowerCase();
+    if (normalized === "content-length") contentLengths.push(value);
+    result[normalized] = value;
+  }
+  if (contentLengths.length > 1 || contentLengths.length === 1 && !/^\d+$/.test(contentLengths[0])) {
+    throw responseLimit();
+  }
+  return Object.freeze(result);
+}
+function safeAbort(name) {
+  return new DOMException(
+    name === "AbortError" ? "Integration request cancelled" : "Integration request timed out",
+    name
+  );
+}
+function requestSignal(context, timeoutMs) {
+  if (context.signal.aborted) throw safeAbort("AbortError");
+  const remaining = context.deadlineMonotonicMs === void 0 ? timeoutMs : Math.min(timeoutMs, context.deadlineMonotonicMs - performance.now());
+  if (remaining <= 0) throw safeAbort("TimeoutError");
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(safeAbort("AbortError"));
+  context.signal.addEventListener("abort", onAbort, { once: true });
+  const timer = setTimeout(() => controller.abort(safeAbort("TimeoutError")), remaining);
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+      context.signal.removeEventListener("abort", onAbort);
+    }
+  };
+}
+async function withAbort(operation, signal) {
+  if (signal.aborted) throw signal.reason;
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    void operation.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+var NodeHttpsTransport = class {
+  agent = new https.Agent({ keepAlive: true });
+  request(url, init) {
+    return new Promise((resolve, reject) => {
+      const request = https.request(
+        url,
+        { method: init.method, headers: init.headers, agent: this.agent },
+        (response) => {
+          const headers = [];
+          for (let index = 0; index < response.rawHeaders.length; index += 2) {
+            headers.push([response.rawHeaders[index], response.rawHeaders[index + 1] ?? ""]);
+          }
+          resolve({
+            status: response.statusCode ?? 0,
+            headers,
+            body: response,
+            close: () => response.destroy()
+          });
+        }
+      );
+      const onAbort = () => request.destroy(init.signal.reason);
+      init.signal.addEventListener("abort", onAbort, { once: true });
+      request.once("error", reject);
+      request.once("close", () => init.signal.removeEventListener("abort", onAbort));
+      request.end(init.body);
+    });
+  }
+  close() {
+    this.agent.destroy();
+  }
+};
+var FixedOriginRequesterImpl = class {
+  constructor(policy, transport, observability = {}) {
+    this.transport = transport;
+    this.origin = validatedOrigin(policy.origin);
+    this.integration = policy.integration;
+    this.timeoutMs = positiveInteger(policy.timeoutMs, DEFAULT_TIMEOUT_MS);
+    this.maxResponseBytes = positiveInteger(policy.maxResponseBytes, DEFAULT_MAX_RESPONSE_BYTES);
+    const allowedMethods = policy.allowedMethods ?? ["GET", "POST"];
+    if (allowedMethods.length === 0 || allowedMethods.some((method) => method !== "GET" && method !== "POST")) {
+      throw policyError();
+    }
+    this.allowedMethods = new Set(allowedMethods);
+    this.metrics = observability.metricsSink ?? NOOP_METRICS;
+    this.trace = observability.traceSink ?? NOOP_TRACE;
+    this.monotonicNow = observability.monotonicNow ?? (() => performance.now());
+  }
+  transport;
+  origin;
+  timeoutMs;
+  maxResponseBytes;
+  allowedMethods;
+  integration;
+  metrics;
+  trace;
+  monotonicNow;
+  closed = false;
+  async request(pathAndQuery, init, context) {
+    const started = this.monotonicNow();
+    const operation = init.method === "GET" ? "read" : "mutation";
+    const span = startSpan(this.trace, "kaji.integration.request", {
+      "session.id": context.sessionId,
+      "turn.id": context.turnId,
+      "request.id": context.requestId,
+      "trace.id": context.traceId,
+      "tool.call_id": context.toolCallId,
+      "integration.name": this.integration,
+      "integration.operation": operation,
+      "http.status_family": "none"
+    });
+    let outcome = "error";
+    let scope;
+    let response;
+    try {
+      if (this.closed) throw policyError();
+      if (!this.allowedMethods.has(init.method)) throw policyError();
+      if (init.body !== void 0 && !(init.body instanceof Uint8Array)) throw policyError();
+      const url = validatedPath(this.origin, pathAndQuery);
+      const headers = validatedRequestHeaders(init.headers);
+      scope = requestSignal(context, this.timeoutMs);
+      const signal = scope.signal;
+      const pendingResponse = this.transport.request(url, {
+        method: init.method,
+        headers,
+        ...init.body === void 0 ? {} : { body: init.body },
+        signal
+      });
+      void pendingResponse.then((lateResponse) => {
+        if (signal.aborted && response === void 0) lateResponse.close();
+      }).catch(() => void 0);
+      response = await withAbort(pendingResponse, signal);
+      const boundedHeaders = boundedResponseHeaders(response.headers);
+      if (response.status >= 300 && response.status < 400) {
+        throw new IntegrationTransportError("INTEGRATION_REDIRECT_REJECTED", "redirect_rejected");
+      }
+      const contentLength = boundedHeaders["content-length"];
+      if (contentLength !== void 0 && Number(contentLength) > this.maxResponseBytes) {
+        throw responseLimit();
+      }
+      const iterator = response.body[Symbol.asyncIterator]();
+      const chunks = [];
+      let size = 0;
+      while (true) {
+        const next = await withAbort(iterator.next(), scope.signal);
+        if (next.done) break;
+        if (!(next.value instanceof Uint8Array)) throw responseLimit();
+        size += next.value.byteLength;
+        if (size > this.maxResponseBytes) {
+          throw responseLimit();
+        }
+        chunks.push(next.value);
+      }
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+      }
+      const family = Math.floor(response.status / 100);
+      span.setAttribute("http.status_family", family >= 1 && family <= 5 ? `${family}xx` : "none");
+      outcome = response.status >= 200 && response.status < 300 ? "success" : "error";
+      return { status: response.status, headers: boundedHeaders, bytes };
+    } catch (error) {
+      response?.close();
+      if (error instanceof DOMException && error.name === "AbortError") outcome = "cancelled";
+      span.recordError(error);
+      throw error;
+    } finally {
+      scope?.dispose();
+      recordMetric(
+        this.metrics,
+        "kaji.integration.request_ms",
+        Math.max(0, this.monotonicNow() - started),
+        { integration: this.integration, operation, outcome }
+      );
+      span.end();
+    }
+  }
+  close() {
+    if (this.closed) return;
+    this.transport.close?.();
+    this.closed = true;
+  }
+};
+var productionTransport = () => new NodeHttpsTransport();
+function createGitHubRequester(observability = {}) {
+  return new FixedOriginRequesterImpl(
+    { origin: new URL("https://api.github.com/"), integration: "github" },
+    productionTransport(),
+    observability
+  );
+}
+function createGmailRequester(observability = {}) {
+  return new FixedOriginRequesterImpl(
+    { origin: new URL("https://gmail.googleapis.com/"), integration: "gmail" },
+    productionTransport(),
+    observability
+  );
+}
+
+// src/integrations/public.ts
+function snapshotIntegrationResult(value) {
+  return durableJsonSnapshot(value, "tool_result", MAX_DURABLE_TOOL_RESULT_BYTES);
+}
+
+exports.INTEGRATION_RECOVERY = INTEGRATION_RECOVERY;
+exports.IntegrationAuthRequiredError = IntegrationAuthRequiredError;
+exports.IntegrationExecutionError = IntegrationExecutionError;
+exports.IntegrationPolicyError = IntegrationPolicyError;
+exports.IntegrationRateLimitedError = IntegrationRateLimitedError;
+exports.IntegrationTransientReadError = IntegrationTransientReadError;
+exports.closedRecoveryFields = closedRecoveryFields;
+exports.createGitHubRequester = createGitHubRequester;
+exports.createGmailRequester = createGmailRequester;
+exports.snapshotIntegrationResult = snapshotIntegrationResult;
+//# sourceMappingURL=integrations.cjs.map
+//# sourceMappingURL=integrations.cjs.map