{"version":3,"file":"enums.cjs","names":["z"],"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. TypeScript types derive via `z.infer`.\n * Alignment with upstream 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 and the inferred type\n * (TypeScript declaration merging):\n *\n * Import { PermissionBehavior } from \"./enums.ts\" // schema import type { PermissionBehavior } from\n * \"./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. Sourced from\n * `@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 `@anthropic-ai/claude-agent-sdk`\n * `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/** Codex's approval policy values, sourced from `@openai/codex-sdk` `ApprovalMode` type. */\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/** Codex's sandbox mode values, sourced from `@openai/codex-sdk` `SandboxMode` type. */\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\n/**\n * Codex's filesystem access values, from `FileSystemAccessMode` in Codex's protocol crate. `deny` is the name Codex writes; it still reads `none` as a legacy alias for it.\n */\nexport const CodexFilesystemAccess = z.enum([\"read\", \"write\", \"deny\", \"none\"]);\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":";;;;;;;;;;;;;;;;;;;AAgCA,MAAa,qBAAqBA,IAAE,KAAK;CAAC;CAAS;CAAQ;AAAK,CAAC;;;;;AAYjE,MAAa,0BAA0BA,IAAE,KAAK;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;AAYD,MAAa,2BAA2BA,IAAE,KAAK;CAC7C;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;AASD,MAAa,oBAAoBA,IAAE,KAAK;CACtC;CACA;CACA;CACA;AACF,CAAC;;AASD,MAAa,mBAAmBA,IAAE,KAAK;CACrC;CACA;CACA;AACF,CAAC;;;;AAWD,MAAa,wBAAwBA,IAAE,KAAK;CAAC;CAAQ;CAAS;CAAQ;AAAM,CAAC;AAS7E,MAAa,oBAAoBA,IAAE,KAAK,CAAC,SAAS,MAAM,CAAC;AAiBzD,MAAa,qBAAyC;AAStD,MAAa,yBAAiD;AAO9D,MAAa,uBAA6C;AAO1D,MAAa,sBAA2C;AAiBxD,MAAa,0BAAmD"}