@irogane/kaji 0.2.0-beta.11

package/dist/integrations.js

@@ -0,0 +1,2650 @@
+import { canonicalJsonValue, cloneAndFreezeJson, durableJsonSnapshot } from './chunk-KAJ6BM64.js';
+import { defaultUuid, isClosedRecoveryTuple, IntegrationTransportError, IntegrationPolicyError } from './chunk-KCAXIOZS.js';
+export { INTEGRATION_RECOVERY, IntegrationAuthRequiredError, IntegrationExecutionError, IntegrationPolicyError, IntegrationRateLimitedError, IntegrationTransientReadError, closedRecoveryFields } from './chunk-KCAXIOZS.js';
+import { NOOP_METRICS, NOOP_TRACE, startSpan, recordMetric } from './chunk-LSJ4AVO2.js';
+import * as z from 'zod';
+import Ajv2020 from 'ajv/dist/2020.js';
+import { Agent, request } from 'https';
+
+// 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"
+};
+
+// contracts/events/new-kaji-event-v1.schema.json
+var new_kaji_event_v1_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://kaji.dev/contracts/events/new-kaji-event-v1.schema.json",
+  title: "New Kaji event",
+  "x-maxSerializedBytes": 1048576,
+  $defs: {
+    nonEmptyId: {
+      type: "string",
+      minLength: 1
+    },
+    integrationRecoveryFields: {
+      oneOf: [
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "github_token_missing" }, recovery_code: { const: "CONFIGURE_GITHUB_TOKEN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-token" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_grant_missing" }, recovery_code: { const: "CONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-grant" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_missing" }, recovery_code: { const: "RESTORE_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-missing" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_locked" }, recovery_code: { const: "UNLOCK_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-locked" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_corrupt" }, recovery_code: { const: "RESET_GMAIL_GRANT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-corrupt" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_unsupported" }, recovery_code: { const: "USE_SUPPORTED_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-unsupported" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_scope_drift" }, recovery_code: { const: "RECONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-scope-drift" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_POLICY_REJECTED" }, reason_code: { const: "policy_rejected" }, recovery_code: { const: "REVIEW_INTEGRATION_POLICY" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#policy-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "api_rejected" }, recovery_code: { const: "REVIEW_PROVIDER_REJECTION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#api-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "transient_read_failed" }, recovery_code: { const: "RETRY_INTEGRATION_READ" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#transient-read" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RATE_LIMITED" }, reason_code: { const: "rate_limited" }, recovery_code: { const: "RETRY_AFTER_RATE_LIMIT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#rate-limited" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_REDIRECT_REJECTED" }, reason_code: { const: "redirect_rejected" }, recovery_code: { const: "REJECT_PROVIDER_REDIRECT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#redirect-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RESPONSE_LIMIT" }, reason_code: { const: "response_limit_exceeded" }, recovery_code: { const: "REDUCE_INTEGRATION_RESPONSE" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#response-limit" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "github_mutation_unknown" }, recovery_code: { const: "RECONCILE_GITHUB_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "gmail_mutation_unknown" }, recovery_code: { const: "RECONCILE_GMAIL_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] }
+      ]
+    },
+    safeInteger: {
+      type: "integer",
+      minimum: -9007199254740991,
+      maximum: 9007199254740991
+    },
+    positiveInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 1
+        }
+      ]
+    },
+    nonNegativeInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonNumber: {
+      oneOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          type: "number",
+          not: {
+            type: "integer"
+          }
+        }
+      ]
+    },
+    nonNegativeNumber: {
+      allOf: [
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonValue: {
+      oneOf: [
+        {
+          type: "null"
+        },
+        {
+          type: "boolean"
+        },
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          type: "string"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/$defs/jsonValue"
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/jsonValue"
+          }
+        }
+      ]
+    },
+    jsonObject: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/jsonValue"
+      }
+    },
+    tokenUsage: {
+      type: "object",
+      properties: {
+        input: {
+          $ref: "#/$defs/nonNegativeInteger"
+        },
+        output: {
+          $ref: "#/$defs/nonNegativeInteger"
+        }
+      },
+      required: [
+        "input",
+        "output"
+      ],
+      additionalProperties: false
+    },
+    base: {
+      type: "object",
+      properties: {
+        id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        version: {
+          const: "1.0"
+        },
+        timestamp: {
+          $ref: "#/$defs/jsonNumber"
+        },
+        session_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        turn_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        metadata: {
+          $ref: "#/$defs/jsonObject"
+        }
+      },
+      required: [
+        "id",
+        "version",
+        "timestamp",
+        "session_id"
+      ]
+    },
+    sessionCreated: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.created"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    sessionClosed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.closed"
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userMessage: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.message"
+            },
+            content: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userAudioChunk: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.audio.chunk"
+            },
+            chunk_size_bytes: {
+              $ref: "#/$defs/safeInteger"
+            }
+          },
+          required: [
+            "type",
+            "chunk_size_bytes"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptPartial: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.partial"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptFinal: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.final"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.started"
+            },
+            query: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "query"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.completed"
+            },
+            query: {
+              type: "string"
+            },
+            documents: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            }
+          },
+          required: [
+            "type",
+            "query",
+            "documents"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentReasoningStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.reasoning.started"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageDelta: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.delta"
+            },
+            delta: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "delta"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.completed"
+            },
+            content: {
+              type: "string"
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnExhausted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.exhausted"
+            },
+            max_iterations: {
+              $ref: "#/$defs/nonNegativeInteger"
+            },
+            pending_tool_calls: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "max_iterations",
+            "pending_tool_calls"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            phase: {
+              enum: [
+                "queue",
+                "provider_open",
+                "provider_stream",
+                "approval",
+                "tool"
+              ]
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_args",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.started"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.completed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue",
+              "x-maxSerializedBytes": 65536
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            error_path: {
+              type: "string"
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            },
+            reason_code: {
+              type: "string"
+            },
+            recovery_code: {
+              type: "string"
+            },
+            doc_url: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error"
+          ]
+        },
+        {
+          if: {
+            anyOf: [
+              { required: ["reason_code"] },
+              { required: ["recovery_code"] },
+              { required: ["doc_url"] }
+            ]
+          },
+          then: {
+            $ref: "#/$defs/integrationRecoveryFields"
+          }
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            risk: {
+              enum: [
+                "read",
+                "write",
+                "external_effect",
+                "destructive",
+                "admin"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "tool_args",
+            "risk"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalApproved: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.approved"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRejected: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.rejected"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error_code: {
+              enum: [
+                "APPROVAL_REJECTED",
+                "APPROVAL_TIMEOUT",
+                "TURN_TIMEOUT",
+                "TOOL_CANCELLED",
+                "APPROVAL_UNAVAILABLE"
+              ]
+            },
+            reason: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200,
+              pattern: "\\S"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error_code",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.started"
+            },
+            workflow_name: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.completed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.failed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            error: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.requested"
+            },
+            reason: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.completed"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    }
+  },
+  oneOf: [
+    {
+      $ref: "#/$defs/sessionCreated"
+    },
+    {
+      $ref: "#/$defs/sessionClosed"
+    },
+    {
+      $ref: "#/$defs/userMessage"
+    },
+    {
+      $ref: "#/$defs/userAudioChunk"
+    },
+    {
+      $ref: "#/$defs/transcriptPartial"
+    },
+    {
+      $ref: "#/$defs/transcriptFinal"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalStarted"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalCompleted"
+    },
+    {
+      $ref: "#/$defs/agentReasoningStarted"
+    },
+    {
+      $ref: "#/$defs/agentMessageDelta"
+    },
+    {
+      $ref: "#/$defs/agentMessageCompleted"
+    },
+    {
+      $ref: "#/$defs/agentTurnExhausted"
+    },
+    {
+      $ref: "#/$defs/agentTurnFailed"
+    },
+    {
+      $ref: "#/$defs/toolCallRequested"
+    },
+    {
+      $ref: "#/$defs/toolCallStarted"
+    },
+    {
+      $ref: "#/$defs/toolCallCompleted"
+    },
+    {
+      $ref: "#/$defs/toolCallFailed"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRequested"
+    },
+    {
+      $ref: "#/$defs/toolApprovalApproved"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRejected"
+    },
+    {
+      $ref: "#/$defs/workflowStarted"
+    },
+    {
+      $ref: "#/$defs/workflowCompleted"
+    },
+    {
+      $ref: "#/$defs/workflowFailed"
+    },
+    {
+      $ref: "#/$defs/cancellationRequested"
+    },
+    {
+      $ref: "#/$defs/cancellationCompleted"
+    }
+  ]
+};
+
+// contracts/events/stored-kaji-event-v1.schema.json
+var stored_kaji_event_v1_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://kaji.dev/contracts/events/stored-kaji-event-v1.schema.json",
+  title: "Stored Kaji event",
+  "x-maxSerializedBytes": 1048576,
+  $defs: {
+    nonEmptyId: {
+      type: "string",
+      minLength: 1
+    },
+    integrationRecoveryFields: {
+      oneOf: [
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "github_token_missing" }, recovery_code: { const: "CONFIGURE_GITHUB_TOKEN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-token" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_grant_missing" }, recovery_code: { const: "CONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-grant" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_missing" }, recovery_code: { const: "RESTORE_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-missing" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_locked" }, recovery_code: { const: "UNLOCK_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-locked" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_corrupt" }, recovery_code: { const: "RESET_GMAIL_GRANT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-corrupt" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_ERROR" }, reason_code: { const: "keychain_unsupported" }, recovery_code: { const: "USE_SUPPORTED_KEYCHAIN" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#keychain-unsupported" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_AUTH_REQUIRED" }, reason_code: { const: "gmail_scope_drift" }, recovery_code: { const: "RECONNECT_GMAIL" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-scope-drift" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_POLICY_REJECTED" }, reason_code: { const: "policy_rejected" }, recovery_code: { const: "REVIEW_INTEGRATION_POLICY" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#policy-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "api_rejected" }, recovery_code: { const: "REVIEW_PROVIDER_REJECTION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#api-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_API_ERROR" }, reason_code: { const: "transient_read_failed" }, recovery_code: { const: "RETRY_INTEGRATION_READ" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#transient-read" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RATE_LIMITED" }, reason_code: { const: "rate_limited" }, recovery_code: { const: "RETRY_AFTER_RATE_LIMIT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#rate-limited" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_REDIRECT_REJECTED" }, reason_code: { const: "redirect_rejected" }, recovery_code: { const: "REJECT_PROVIDER_REDIRECT" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#redirect-rejected" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "INTEGRATION_RESPONSE_LIMIT" }, reason_code: { const: "response_limit_exceeded" }, recovery_code: { const: "REDUCE_INTEGRATION_RESPONSE" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#response-limit" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "github_mutation_unknown" }, recovery_code: { const: "RECONCILE_GITHUB_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#github-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] },
+        { properties: { error_code: { const: "TOOL_EXECUTION_FAILED" }, reason_code: { const: "gmail_mutation_unknown" }, recovery_code: { const: "RECONCILE_GMAIL_MUTATION" }, doc_url: { const: "https://kaji.dev/docs/integrations/recovery-v1#gmail-mutation-unknown" } }, required: ["error_code", "reason_code", "recovery_code", "doc_url"] }
+      ]
+    },
+    safeInteger: {
+      type: "integer",
+      minimum: -9007199254740991,
+      maximum: 9007199254740991
+    },
+    positiveInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 1
+        }
+      ]
+    },
+    nonNegativeInteger: {
+      allOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonNumber: {
+      oneOf: [
+        {
+          $ref: "#/$defs/safeInteger"
+        },
+        {
+          type: "number",
+          not: {
+            type: "integer"
+          }
+        }
+      ]
+    },
+    nonNegativeNumber: {
+      allOf: [
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          minimum: 0
+        }
+      ]
+    },
+    jsonValue: {
+      oneOf: [
+        {
+          type: "null"
+        },
+        {
+          type: "boolean"
+        },
+        {
+          $ref: "#/$defs/jsonNumber"
+        },
+        {
+          type: "string"
+        },
+        {
+          type: "array",
+          items: {
+            $ref: "#/$defs/jsonValue"
+          }
+        },
+        {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/jsonValue"
+          }
+        }
+      ]
+    },
+    jsonObject: {
+      type: "object",
+      additionalProperties: {
+        $ref: "#/$defs/jsonValue"
+      }
+    },
+    tokenUsage: {
+      type: "object",
+      properties: {
+        input: {
+          $ref: "#/$defs/nonNegativeInteger"
+        },
+        output: {
+          $ref: "#/$defs/nonNegativeInteger"
+        }
+      },
+      required: [
+        "input",
+        "output"
+      ],
+      additionalProperties: false
+    },
+    base: {
+      type: "object",
+      properties: {
+        id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        version: {
+          const: "1.0"
+        },
+        timestamp: {
+          $ref: "#/$defs/jsonNumber"
+        },
+        session_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        turn_id: {
+          $ref: "#/$defs/nonEmptyId"
+        },
+        metadata: {
+          $ref: "#/$defs/jsonObject"
+        },
+        sequence: {
+          $ref: "#/$defs/positiveInteger"
+        }
+      },
+      required: [
+        "id",
+        "version",
+        "timestamp",
+        "session_id",
+        "sequence"
+      ]
+    },
+    sessionCreated: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.created"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    sessionClosed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "session.closed"
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userMessage: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.message"
+            },
+            content: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    userAudioChunk: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "user.audio.chunk"
+            },
+            chunk_size_bytes: {
+              $ref: "#/$defs/safeInteger"
+            }
+          },
+          required: [
+            "type",
+            "chunk_size_bytes"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptPartial: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.partial"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    transcriptFinal: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "transcript.final"
+            },
+            text: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "text"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.started"
+            },
+            query: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "query"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    memoryRetrievalCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "memory.retrieval.completed"
+            },
+            query: {
+              type: "string"
+            },
+            documents: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            }
+          },
+          required: [
+            "type",
+            "query",
+            "documents"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentReasoningStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.reasoning.started"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageDelta: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.delta"
+            },
+            delta: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "delta"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentMessageCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.message.completed"
+            },
+            content: {
+              type: "string"
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "content"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnExhausted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.exhausted"
+            },
+            max_iterations: {
+              $ref: "#/$defs/nonNegativeInteger"
+            },
+            pending_tool_calls: {
+              type: "array",
+              items: {
+                $ref: "#/$defs/jsonObject"
+              }
+            },
+            reason: {
+              type: [
+                "string",
+                "null"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "max_iterations",
+            "pending_tool_calls"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    agentTurnFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "agent.turn.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            phase: {
+              enum: [
+                "queue",
+                "provider_open",
+                "provider_stream",
+                "approval",
+                "tool"
+              ]
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_args",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.started"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.completed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue",
+              "x-maxSerializedBytes": 65536
+            },
+            tokens: {
+              oneOf: [
+                { $ref: "#/$defs/tokenUsage" },
+                { type: "null" }
+              ]
+            },
+            cost_usd: {
+              oneOf: [
+                { $ref: "#/$defs/nonNegativeNumber" },
+                { type: "null" }
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolCallFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.call.failed"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200
+            },
+            error_code: {
+              type: "string"
+            },
+            error_path: {
+              type: "string"
+            },
+            retryable: {
+              type: "boolean"
+            },
+            outcome: {
+              enum: [
+                "not_started",
+                "failed",
+                "unknown"
+              ]
+            },
+            reason_code: {
+              type: "string"
+            },
+            recovery_code: {
+              type: "string"
+            },
+            doc_url: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error"
+          ]
+        },
+        {
+          if: {
+            anyOf: [
+              { required: ["reason_code"] },
+              { required: ["recovery_code"] },
+              { required: ["doc_url"] }
+            ]
+          },
+          then: {
+            $ref: "#/$defs/integrationRecoveryFields"
+          }
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.requested"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_args: {
+              $ref: "#/$defs/jsonObject",
+              "x-maxSerializedBytes": 65536
+            },
+            risk: {
+              enum: [
+                "read",
+                "write",
+                "external_effect",
+                "destructive",
+                "admin"
+              ]
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "tool_args",
+            "risk"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalApproved: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.approved"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    toolApprovalRejected: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "tool.approval.rejected"
+            },
+            turn_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_name: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            tool_call_id: {
+              $ref: "#/$defs/nonEmptyId"
+            },
+            error_code: {
+              enum: [
+                "APPROVAL_REJECTED",
+                "APPROVAL_TIMEOUT",
+                "TURN_TIMEOUT",
+                "TOOL_CANCELLED",
+                "APPROVAL_UNAVAILABLE"
+              ]
+            },
+            reason: {
+              type: "string",
+              minLength: 1,
+              maxLength: 200,
+              pattern: "\\S"
+            }
+          },
+          required: [
+            "type",
+            "turn_id",
+            "tool_name",
+            "tool_call_id",
+            "error_code",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowStarted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.started"
+            },
+            workflow_name: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.completed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            result: {
+              $ref: "#/$defs/jsonValue"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "result"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    workflowFailed: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "workflow.failed"
+            },
+            workflow_name: {
+              type: "string"
+            },
+            error: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "workflow_name",
+            "error"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationRequested: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.requested"
+            },
+            reason: {
+              type: "string"
+            }
+          },
+          required: [
+            "type",
+            "reason"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    cancellationCompleted: {
+      allOf: [
+        {
+          $ref: "#/$defs/base"
+        },
+        {
+          type: "object",
+          properties: {
+            type: {
+              const: "cancellation.completed"
+            }
+          },
+          required: [
+            "type"
+          ]
+        }
+      ],
+      unevaluatedProperties: false
+    }
+  },
+  oneOf: [
+    {
+      $ref: "#/$defs/sessionCreated"
+    },
+    {
+      $ref: "#/$defs/sessionClosed"
+    },
+    {
+      $ref: "#/$defs/userMessage"
+    },
+    {
+      $ref: "#/$defs/userAudioChunk"
+    },
+    {
+      $ref: "#/$defs/transcriptPartial"
+    },
+    {
+      $ref: "#/$defs/transcriptFinal"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalStarted"
+    },
+    {
+      $ref: "#/$defs/memoryRetrievalCompleted"
+    },
+    {
+      $ref: "#/$defs/agentReasoningStarted"
+    },
+    {
+      $ref: "#/$defs/agentMessageDelta"
+    },
+    {
+      $ref: "#/$defs/agentMessageCompleted"
+    },
+    {
+      $ref: "#/$defs/agentTurnExhausted"
+    },
+    {
+      $ref: "#/$defs/agentTurnFailed"
+    },
+    {
+      $ref: "#/$defs/toolCallRequested"
+    },
+    {
+      $ref: "#/$defs/toolCallStarted"
+    },
+    {
+      $ref: "#/$defs/toolCallCompleted"
+    },
+    {
+      $ref: "#/$defs/toolCallFailed"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRequested"
+    },
+    {
+      $ref: "#/$defs/toolApprovalApproved"
+    },
+    {
+      $ref: "#/$defs/toolApprovalRejected"
+    },
+    {
+      $ref: "#/$defs/workflowStarted"
+    },
+    {
+      $ref: "#/$defs/workflowCompleted"
+    },
+    {
+      $ref: "#/$defs/workflowFailed"
+    },
+    {
+      $ref: "#/$defs/cancellationRequested"
+    },
+    {
+      $ref: "#/$defs/cancellationCompleted"
+    }
+  ]
+};
+
+// src/events/schemas.ts
+var MAX_DURABLE_TOOL_ARGUMENT_BYTES = 64 * 1024;
+var MAX_DURABLE_TOOL_RESULT_BYTES = 64 * 1024;
+var MAX_DURABLE_EVENT_BYTES = 1024 * 1024;
+function durableToolArgumentsSize(value) {
+  return new TextEncoder().encode(canonicalJsonValue(value, "tool arguments")).byteLength;
+}
+var durableJsonValue = z.unknown().superRefine((value, ctx) => {
+  try {
+    canonicalJsonValue(value, "event value");
+  } catch {
+    ctx.addIssue({ code: "custom", message: "event value must contain only JSON values" });
+  }
+});
+var durableJsonObject = z.record(z.string(), durableJsonValue).superRefine((value, ctx) => {
+  try {
+    canonicalJsonValue(value, "event value");
+  } catch {
+    ctx.addIssue({ code: "custom", message: "event value must contain only JSON values" });
+  }
+});
+function durableSubjectValue(subject, maxBytes) {
+  return z.unknown().superRefine((value, ctx) => {
+    try {
+      durableJsonSnapshot(value, subject, maxBytes);
+    } catch {
+      ctx.addIssue({ code: "custom", message: `${subject} must be bounded durable JSON` });
+    }
+  });
+}
+function durableSubjectObject(subject) {
+  return z.record(z.string(), z.unknown()).superRefine((value, ctx) => {
+    try {
+      durableJsonSnapshot(value, subject, MAX_DURABLE_EVENT_BYTES);
+    } catch {
+      ctx.addIssue({ code: "custom", message: `${subject} must be bounded durable JSON` });
+    }
+  });
+}
+var durableToolArguments = durableJsonObject.superRefine((value, ctx) => {
+  let size;
+  try {
+    size = durableToolArgumentsSize(value);
+  } catch {
+    ctx.addIssue({ code: "custom", message: "tool_args must contain only JSON values" });
+    return;
+  }
+  if (size > MAX_DURABLE_TOOL_ARGUMENT_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      message: "tool_args cannot exceed 65536 serialized bytes; payload redacted"
+    });
+  }
+});
+var nonEmptyId = z.string().min(1);
+var baseShape = {
+  id: nonEmptyId.default(() => defaultUuid()),
+  version: z.literal("1.0").default("1.0"),
+  timestamp: z.number().default(() => Date.now() / 1e3),
+  session_id: nonEmptyId,
+  turn_id: nonEmptyId.optional(),
+  metadata: durableSubjectObject("event_metadata").default(() => ({}))
+};
+function maxUnicodeCodePoints(field) {
+  return (value, ctx) => {
+    if (Array.from(value).length > 200) {
+      ctx.addIssue({ code: "custom", message: `${field} must contain at most 200 characters` });
+    }
+  };
+}
+function event(shape) {
+  return z.object(baseShape).extend(shape).strict();
+}
+var SessionCreated = event({
+  type: z.literal(EventType.SESSION_CREATED)
+});
+var SessionClosed = event({
+  type: z.literal(EventType.SESSION_CLOSED),
+  reason: z.string().nullish()
+});
+var UserMessage = event({
+  type: z.literal(EventType.USER_MESSAGE),
+  content: z.string()
+});
+var UserAudioChunk = event({
+  type: z.literal(EventType.USER_AUDIO_CHUNK),
+  chunk_size_bytes: z.number().int()
+});
+var TranscriptPartial = event({
+  type: z.literal(EventType.TRANSCRIPT_PARTIAL),
+  text: z.string()
+});
+var TranscriptFinal = event({
+  type: z.literal(EventType.TRANSCRIPT_FINAL),
+  text: z.string()
+});
+var MemoryRetrievalStarted = event({
+  type: z.literal(EventType.MEMORY_RETRIEVAL_STARTED),
+  query: z.string()
+});
+var MemoryRetrievalCompleted = event({
+  type: z.literal(EventType.MEMORY_RETRIEVAL_COMPLETED),
+  query: z.string(),
+  documents: z.array(durableSubjectObject("memory_document"))
+});
+var AgentReasoningStarted = event({
+  type: z.literal(EventType.AGENT_REASONING_STARTED)
+});
+var AgentMessageDelta = event({
+  type: z.literal(EventType.AGENT_MESSAGE_DELTA),
+  delta: z.string()
+});
+var AgentMessageCompleted = event({
+  type: z.literal(EventType.AGENT_MESSAGE_COMPLETED),
+  content: z.string(),
+  tokens: z.object({ input: z.number().int().nonnegative(), output: z.number().int().nonnegative() }).strict().nullish(),
+  cost_usd: z.number().nonnegative().nullish()
+});
+var AgentTurnExhausted = event({
+  type: z.literal(EventType.AGENT_TURN_EXHAUSTED),
+  max_iterations: z.number().int().nonnegative(),
+  pending_tool_calls: z.array(durableSubjectObject("pending_tool_call")),
+  reason: z.string().nullish()
+});
+var AgentTurnFailed = event({
+  type: z.literal(EventType.AGENT_TURN_FAILED),
+  turn_id: z.string().min(1),
+  error: z.string().min(1).superRefine(maxUnicodeCodePoints("error")),
+  error_code: z.string().optional(),
+  phase: z.enum(["queue", "provider_open", "provider_stream", "approval", "tool"]).optional(),
+  retryable: z.boolean().optional(),
+  outcome: z.enum(["not_started", "failed", "unknown"]).optional()
+});
+var ToolCallRequested = event({
+  type: z.literal(EventType.TOOL_CALL_REQUESTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_args: durableToolArguments,
+  tool_call_id: z.string().min(1)
+});
+var ToolCallStarted = event({
+  type: z.literal(EventType.TOOL_CALL_STARTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1)
+});
+var ToolCallCompleted = event({
+  type: z.literal(EventType.TOOL_CALL_COMPLETED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  result: durableSubjectValue("tool_result", MAX_DURABLE_TOOL_RESULT_BYTES),
+  tokens: z.object({ input: z.number().int().nonnegative(), output: z.number().int().nonnegative() }).strict().nullish(),
+  cost_usd: z.number().nonnegative().nullish()
+});
+var ToolCallFailed = event({
+  type: z.literal(EventType.TOOL_CALL_FAILED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  error: z.string().min(1).superRefine(maxUnicodeCodePoints("error")),
+  error_code: z.string().optional(),
+  error_path: z.string().optional(),
+  retryable: z.boolean().optional(),
+  outcome: z.enum(["not_started", "failed", "unknown"]).optional(),
+  reason_code: z.string().optional(),
+  recovery_code: z.string().optional(),
+  doc_url: z.string().optional()
+}).superRefine((value, ctx) => {
+  if (!isClosedRecoveryTuple(value.reason_code, value.recovery_code, value.doc_url, value.error_code)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["reason_code"],
+      message: "integration recovery metadata must be a closed tuple"
+    });
+  }
+});
+var ToolApprovalRequested = event({
+  type: z.literal(EventType.TOOL_APPROVAL_REQUESTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  tool_args: durableToolArguments,
+  risk: z.enum(["read", "write", "external_effect", "destructive", "admin"])
+});
+var ToolApprovalApproved = event({
+  type: z.literal(EventType.TOOL_APPROVAL_APPROVED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1)
+});
+var ToolApprovalRejected = event({
+  type: z.literal(EventType.TOOL_APPROVAL_REJECTED),
+  turn_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  tool_call_id: z.string().min(1),
+  error_code: z.enum([
+    "APPROVAL_REJECTED",
+    "APPROVAL_TIMEOUT",
+    "TURN_TIMEOUT",
+    "TOOL_CANCELLED",
+    "APPROVAL_UNAVAILABLE"
+  ]),
+  reason: z.string().min(1).refine((value) => value.trim().length > 0, "reason must not be blank").superRefine(maxUnicodeCodePoints("reason"))
+});
+var WorkflowStarted = event({
+  type: z.literal(EventType.WORKFLOW_STARTED),
+  workflow_name: z.string()
+});
+var WorkflowCompleted = event({
+  type: z.literal(EventType.WORKFLOW_COMPLETED),
+  workflow_name: z.string(),
+  result: durableSubjectValue("workflow_result", MAX_DURABLE_EVENT_BYTES)
+});
+var WorkflowFailed = event({
+  type: z.literal(EventType.WORKFLOW_FAILED),
+  workflow_name: z.string(),
+  error: z.string()
+});
+var CancellationRequested = event({
+  type: z.literal(EventType.CANCELLATION_REQUESTED),
+  reason: z.string()
+});
+var CancellationCompleted = event({
+  type: z.literal(EventType.CANCELLATION_COMPLETED)
+});
+var KajiEvent = z.discriminatedUnion("type", [
+  SessionCreated,
+  SessionClosed,
+  UserMessage,
+  UserAudioChunk,
+  TranscriptPartial,
+  TranscriptFinal,
+  MemoryRetrievalStarted,
+  MemoryRetrievalCompleted,
+  AgentReasoningStarted,
+  AgentMessageDelta,
+  AgentMessageCompleted,
+  AgentTurnExhausted,
+  AgentTurnFailed,
+  ToolCallRequested,
+  ToolCallStarted,
+  ToolCallCompleted,
+  ToolCallFailed,
+  ToolApprovalRequested,
+  ToolApprovalApproved,
+  ToolApprovalRejected,
+  WorkflowStarted,
+  WorkflowCompleted,
+  WorkflowFailed,
+  CancellationRequested,
+  CancellationCompleted
+]);
+z.object({ sequence: z.number().int().positive() }).loose().transform((value, ctx) => {
+  const { sequence, ...candidate } = value;
+  const parsed = KajiEvent.safeParse(candidate);
+  if (!parsed.success) {
+    for (const issue of parsed.error.issues) ctx.addIssue({ ...issue });
+    return z.NEVER;
+  }
+  return cloneAndFreezeJson({ ...parsed.data, sequence });
+});
+new Set(Object.values(EventType));
+var wireAjv = new Ajv2020({ allErrors: true, strict: false });
+wireAjv.compile(new_kaji_event_v1_schema_default);
+wireAjv.compile(stored_kaji_event_v1_schema_default);
+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 Agent({ keepAlive: true });
+  request(url, init) {
+    return new Promise((resolve, reject) => {
+      const request$1 = 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$1.destroy(init.signal.reason);
+      init.signal.addEventListener("abort", onAbort, { once: true });
+      request$1.once("error", reject);
+      request$1.once("close", () => init.signal.removeEventListener("abort", onAbort));
+      request$1.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);
+}
+
+export { createGitHubRequester, createGmailRequester, snapshotIntegrationResult };
+//# sourceMappingURL=integrations.js.map
+//# sourceMappingURL=integrations.js.map