{"version":3,"file":"enums.mjs","names":[],"sources":["../../src/compat/enums.ts"],"sourcesContent":["/**\n * Shared enum schemas — single source of truth.\n *\n * Every agent-specific enum is defined here as a Zod schema.\n * TypeScript types derive via `z.infer`. Alignment with upstream\n * SDKs is verified by compile-time assertions at the bottom of this file.\n *\n * Each export is a PascalCase identifier used as both the runtime schema\n * and the inferred type (TypeScript declaration merging):\n *\n *   import { PermissionBehavior } from \"./enums.ts\"        // schema\n *   import type { PermissionBehavior } from \"./enums.ts\"   // type\n */\n\nimport * as z from \"zod\";\n\nimport type {\n  PermissionMode as ClaudeSdkPermissionMode,\n  PermissionBehavior as ClaudeSdkPermissionBehavior,\n} from \"@anthropic-ai/claude-agent-sdk\";\n\nimport type {\n  ApprovalMode as CodexSdkApprovalMode,\n  SandboxMode as CodexSdkSandboxMode,\n} from \"@openai/codex-sdk\";\n\nimport type { PermissionActionConfig as OpenCodeV2PermissionActionConfig } from \"@opencode-ai/sdk/v2\";\n\n// ---------------------------------------------------------------------------\n// Permission behaviour (allow / deny / ask)\n// ---------------------------------------------------------------------------\n\n/** Permission tier actions. Shared across Claude Code, OpenCode, and our schema. */\nexport const PermissionBehavior = z.enum([\"allow\", \"deny\", \"ask\"]);\n\nexport type PermissionBehavior = z.infer<typeof PermissionBehavior>;\n\n// ---------------------------------------------------------------------------\n// OpenCode — permission tool names\n// ---------------------------------------------------------------------------\n\n/**\n * Tool names that appear in OpenCode's `AgentConfig.permission` block.\n * Sourced from `@opencode-ai/sdk` `AgentConfig.permission` type.\n */\nexport const OpenCodePermissionTools = z.enum([\n  \"bash\",\n  \"doom_loop\",\n  \"edit\",\n  \"external_directory\",\n  \"glob\",\n  \"grep\",\n  \"list\",\n  \"lsp\",\n  \"question\",\n  \"read\",\n  \"skill\",\n  \"task\",\n  \"todowrite\",\n  \"webfetch\",\n  \"websearch\",\n]);\n\nexport type OpenCodePermissionTool = z.infer<typeof OpenCodePermissionTools>;\n\n// ---------------------------------------------------------------------------\n// Claude Code — PermissionMode\n// ---------------------------------------------------------------------------\n\n/**\n * Claude Code's permission mode values, sourced from\n * `@anthropic-ai/claude-agent-sdk` `PermissionMode` type.\n */\nexport const ClaudeCodePermissionMode = z.enum([\n  \"acceptEdits\",\n  \"auto\",\n  \"bypassPermissions\",\n  \"default\",\n  \"dontAsk\",\n  \"plan\",\n]);\n\nexport type ClaudeCodePermissionMode = z.infer<typeof ClaudeCodePermissionMode>;\n\n// ---------------------------------------------------------------------------\n// Codex — ApprovalMode\n// ---------------------------------------------------------------------------\n\n/**\n * Codex's approval policy values, sourced from\n * `@openai/codex-sdk` `ApprovalMode` type.\n */\nexport const CodexApprovalMode = z.enum([\n  \"never\",\n  \"on-failure\",\n  \"on-request\",\n  \"untrusted\",\n]);\n\nexport type CodexApprovalMode = z.infer<typeof CodexApprovalMode>;\n\n// ---------------------------------------------------------------------------\n// Codex — SandboxMode\n// ---------------------------------------------------------------------------\n\n/**\n * Codex's sandbox mode values, sourced from\n * `@openai/codex-sdk` `SandboxMode` type.\n */\nexport const CodexSandboxMode = z.enum([\n  \"danger-full-access\",\n  \"read-only\",\n  \"workspace-write\",\n]);\n\nexport type CodexSandboxMode = z.infer<typeof CodexSandboxMode>;\n\n// ---------------------------------------------------------------------------\n// Codex — FilesystemAccess\n// ---------------------------------------------------------------------------\n\nexport const CodexFilesystemAccess = z.enum([\"none\", \"read\", \"write\"]);\n\nexport type CodexFilesystemAccess = z.infer<typeof CodexFilesystemAccess>;\n\n// ---------------------------------------------------------------------------\n// Codex — DomainAccess (subset of PermissionBehavior)\n// ---------------------------------------------------------------------------\n// Codex domain rules only use allow/deny, not ask.\n\nexport const CodexDomainAccess = z.enum([\"allow\", \"deny\"]);\n\nexport type CodexDomainAccess = z.infer<typeof CodexDomainAccess>;\n\n// ---------------------------------------------------------------------------\n// Compile-time alignment assertions\n// ---------------------------------------------------------------------------\n// These produce compile errors if our Zod enums diverge from the upstream\n// SDK types. Each const forces evaluation of the conditional\n\ntype _AssertClaudeModes = [ClaudeCodePermissionMode] extends [\n  ClaudeSdkPermissionMode,\n]\n  ? [ClaudeSdkPermissionMode] extends [ClaudeCodePermissionMode]\n    ? true\n    : \"SDK has modes missing from ClaudeCodePermissionMode\"\n  : \"ClaudeCodePermissionMode has modes missing from SDK\";\nexport const _assertClaudeModes: _AssertClaudeModes = true;\n\ntype _AssertClaudeBehaviors = [PermissionBehavior] extends [\n  ClaudeSdkPermissionBehavior,\n]\n  ? [ClaudeSdkPermissionBehavior] extends [PermissionBehavior]\n    ? true\n    : \"SDK has behaviors missing from PermissionBehavior\"\n  : \"PermissionBehavior has behaviors missing from SDK\";\nexport const _assertClaudeBehaviors: _AssertClaudeBehaviors = true;\n\ntype _AssertCodexApproval = [CodexApprovalMode] extends [CodexSdkApprovalMode]\n  ? [CodexSdkApprovalMode] extends [CodexApprovalMode]\n    ? true\n    : \"SDK has approval modes missing from CodexApprovalMode\"\n  : \"CodexApprovalMode has approval modes missing from SDK\";\nexport const _assertCodexApproval: _AssertCodexApproval = true;\n\ntype _AssertCodexSandbox = [CodexSandboxMode] extends [CodexSdkSandboxMode]\n  ? [CodexSdkSandboxMode] extends [CodexSandboxMode]\n    ? true\n    : \"SDK has sandbox modes missing from CodexSandboxMode\"\n  : \"CodexSandboxMode has sandbox modes missing from SDK\";\nexport const _assertCodexSandbox: _AssertCodexSandbox = true;\n\n// ---------------------------------------------------------------------------\n// OpenCode alignment (v2 SDK)\n// ---------------------------------------------------------------------------\n// The v2 SDK PermissionConfig is a union of string | object-with-index-sig.\n// Bidirectional tool-name alignment is impossible because TypeScript's keyof\n// includes `string` from the index signature, so every string literal extends\n// every key. We can only verify the action type (allow/deny/ask) bidirectionally.\n// Tool coverage is maintained by manual review against the SDK source.\ntype OpenCodeAction = OpenCodeV2PermissionActionConfig;\n\ntype _AssertOpenCodeBehavior = [PermissionBehavior] extends [OpenCodeAction]\n  ? [OpenCodeAction] extends [PermissionBehavior]\n    ? true\n    : \"OpenCode SDK has actions missing from PermissionBehavior\"\n  : \"PermissionBehavior has actions missing from OpenCode SDK\";\nexport const _assertOpenCodeBehavior: _AssertOpenCodeBehavior = true;\n"],"mappings":";;;;;;;;;;;;;;;;;AAiCA,MAAa,qBAAqB,EAAE,KAAK;CAAC;CAAS;CAAQ;CAAM,CAAC;;;;;AAYlE,MAAa,0BAA0B,EAAE,KAAK;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;AAYF,MAAa,2BAA2B,EAAE,KAAK;CAC7C;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;AAYF,MAAa,oBAAoB,EAAE,KAAK;CACtC;CACA;CACA;CACA;CACD,CAAC;;;;;AAYF,MAAa,mBAAmB,EAAE,KAAK;CACrC;CACA;CACA;CACD,CAAC;AAQF,MAAa,wBAAwB,EAAE,KAAK;CAAC;CAAQ;CAAQ;CAAQ,CAAC;AAStE,MAAa,oBAAoB,EAAE,KAAK,CAAC,SAAS,OAAO,CAAC;AAiB1D,MAAa,qBAAyC;AAStD,MAAa,yBAAiD;AAO9D,MAAa,uBAA6C;AAO1D,MAAa,sBAA2C;AAiBxD,MAAa,0BAAmD"}