@alpacakit/agents 0.2.0-beta.2 → 0.2.0-beta.3

package/dist/agents/claude/index.js

@@ -0,0 +1,134 @@
+/**
+ * The built-in claude agent: the one-shot run contract
+ * (`claude -p [--model m] [--effort e] --output-format stream-json
+ *  --permission-mode <mode> [tool args] --verbose`, prompt on stdin;
+ * read-only grants map to `--allowedTools`, `Bash(cmd:*)` for shell
+ * grants, no grants means `--tools ""`) composed with the session adapter
+ * and the host plane. Vocabulary lives in `cli.ts`.
+ */
+import { AGENT_ERROR_CODE } from "../../core/error.js";
+import { readBoolean, readJsonRecord, readNumber, readRecord, readString, } from "../../core/json.js";
+import { cliAvailability } from "../../host/availability.js";
+import { parseEpochTimestamp, } from "../../kernel/classify.js";
+import { defineCliAgent } from "../../kernel/cli-agent.js";
+import { GRANT_KIND, SANDBOX_MODE } from "../../kernel/options.js";
+import { CLAUDE, CLAUDE_PERMISSION_MODE, parseClaudeLine, parseClaudeResult, permissionModeArgs, } from "./cli.js";
+import { claudeAuth, claudeLogin, claudeMcp, claudeSkills } from "./host.js";
+import { claudeSessions } from "./session.js";
+function grantToToolArg(grant) {
+    return grant.kind === GRANT_KIND.shell
+        ? `Bash(${grant.command}:*)`
+        : grant.name;
+}
+function sharedArgs(ctx, customizations) {
+    return [
+        CLAUDE.cli.prompt,
+        ...(ctx.model === null ? [] : [CLAUDE.cli.model, ctx.model]),
+        ...(ctx.effort === null ? [] : [CLAUDE.cli.effort, ctx.effort]),
+        CLAUDE.cli.outputFormat,
+        CLAUDE.cli.streamJson,
+        ...(customizations === "disabled"
+            ? [
+                CLAUDE.cli.safeMode,
+                CLAUDE.cli.strictMcpConfig,
+                CLAUDE.cli.noSessionPersistence,
+            ]
+            : []),
+    ];
+}
+/**
+ * Structured quota signals in Claude CLI NDJSON output (v1 F2), scanned
+ * per line: rate_limit_event rejected (with resetsAt), api_error_status
+ * 429, and error === "rate_limit". Exported for custom agents that speak
+ * the same stream format.
+ */
+export function structuredQuotaMatcher() {
+    return (evidence) => {
+        let fallbackCooldownUntil = null;
+        for (const line of evidence.stdout.split(/\r?\n/)) {
+            const record = readJsonRecord(line.trim());
+            if (record === null) {
+                continue;
+            }
+            const rateLimitInfo = readRecord(record, "rate_limit_info");
+            const resetsAt = rateLimitInfo === null ? null : readNumber(rateLimitInfo, "resetsAt");
+            const cooldownUntil = resetsAt === null ? null : parseEpochTimestamp(resetsAt);
+            const rejected = rateLimitInfo !== null &&
+                readString(rateLimitInfo, "status") === "rejected";
+            if (readString(record, "type") === "rate_limit_event" && rejected) {
+                return {
+                    code: AGENT_ERROR_CODE.quota,
+                    message: "Provider rejected the request for rate limiting",
+                    data: { cooldownUntil },
+                };
+            }
+            if (cooldownUntil !== null) {
+                fallbackCooldownUntil = cooldownUntil;
+            }
+            const apiError = readBoolean(record, "is_error") === true &&
+                readNumber(record, "api_error_status") === 429;
+            const rateLimitError = readString(record, "error") === "rate_limit" &&
+                readString(record, "type") !== null;
+            if (apiError || rateLimitError) {
+                return {
+                    code: AGENT_ERROR_CODE.quota,
+                    message: "Provider reported a rate-limit error",
+                    data: { cooldownUntil: fallbackCooldownUntil },
+                };
+            }
+        }
+        return null;
+    };
+}
+export function claude(options = {}) {
+    const customizations = options.customizations ?? "inherit";
+    const definition = defineCliAgent({
+        id: CLAUDE.id,
+        command: CLAUDE.command,
+        args: {
+            [SANDBOX_MODE.full]: (_sandbox, ctx) => [
+                ...sharedArgs(ctx, customizations),
+                ...permissionModeArgs(CLAUDE_PERMISSION_MODE.bypassPermissions),
+                CLAUDE.cli.verbose,
+            ],
+            [SANDBOX_MODE.readOnly]: (sandbox, ctx) => [
+                ...sharedArgs(ctx, customizations),
+                ...permissionModeArgs(CLAUDE_PERMISSION_MODE.default),
+                ...(sandbox.grants.length === 0
+                    ? [CLAUDE.cli.tools, ""]
+                    : [
+                        CLAUDE.cli.allowedTools,
+                        sandbox.grants.map(grantToToolArg).join(","),
+                    ]),
+                CLAUDE.cli.verbose,
+            ],
+        },
+        parseLine: parseClaudeLine,
+        parseResult: parseClaudeResult,
+        classify: [structuredQuotaMatcher()],
+        // F6: Claude CLI can report a structured quota rejection on exit 0.
+        classifyOnSuccess: [structuredQuotaMatcher()],
+        availability: cliAvailability({
+            command: CLAUDE.command,
+            commandMissingRemediation: {
+                detail: "Install Claude Code and ensure `claude` is on PATH.",
+                command: null,
+            },
+            authentication: {
+                args: CLAUDE.auth.statusArgs,
+                remediation: {
+                    detail: "Sign in to Claude Code.",
+                    command: {
+                        executable: CLAUDE.command,
+                        args: CLAUDE.auth.loginArgs,
+                    },
+                },
+            },
+        }),
+        auth: claudeAuth,
+        login: claudeLogin,
+        skills: claudeSkills,
+        mcp: claudeMcp,
+    });
+    return { ...definition, session: claudeSessions({ customizations }) };
+}

package/dist/agents/{claude-session.d.ts → claude/session.d.ts}

@@ -16,22 +16,10 @@
  *   is emitted until then), `--resume <id>` continues a recorded one;
  * - the child needs `USER` in its env: without it the CLI reports "Not logged in".
  */
-import { type SessionCapability } from "../kernel/session.js";
-export declare const CLAUDE_PERMISSION_MODE: {
-    readonly default: "default";
-    readonly acceptEdits: "acceptEdits";
-    readonly auto: "auto";
-    readonly bypassPermissions: "bypassPermissions";
-    readonly dontAsk: "dontAsk";
-    readonly plan: "plan";
-};
-export type ClaudePermissionMode = (typeof CLAUDE_PERMISSION_MODE)[keyof typeof CLAUDE_PERMISSION_MODE];
-/** Spelled as the transcript's `permissionMode` records it. */
-export type ClaudeSessionPermissions = {
-    readonly mode: ClaudePermissionMode;
-};
+import { type SessionCapability } from "../../kernel/session.js";
+import { type ClaudeSessionPermissions } from "./cli.js";
 export type ClaudeSessionOptions = {
     readonly customizations: "inherit" | "disabled";
 };
 export declare function claudeSessions(options: ClaudeSessionOptions): SessionCapability<ClaudeSessionPermissions>;
-//# sourceMappingURL=claude-session.d.ts.map
+//# sourceMappingURL=session.d.ts.map

package/dist/agents/claude/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/agents/claude/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAoCH,OAAO,EAGL,KAAK,iBAAiB,EAOvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAIL,KAAK,wBAAwB,EAG9B,MAAM,UAAU,CAAC;AAqBlB,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,cAAc,EAAE,SAAS,GAAG,UAAU,CAAC;CACjD,CAAC;AAuWF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,oBAAoB,GAC5B,iBAAiB,CAAC,wBAAwB,CAAC,CAoB7C"}

package/dist/agents/claude/session.js

@@ -0,0 +1,321 @@
+/**
+ * Claude session adapter: one `claude -p --input-format stream-json
+ * --output-format stream-json` process held open across turns.
+ *
+ * Protocol facts (claude 2.1.270, T52 / T61 lab runs):
+ * - a turn is one user line `{"type":"user","message":{"role":"user","content":…}}`
+ *   and ends with the `result` line; a user line written mid-turn is absorbed
+ *   into the running turn at its next tool boundary (`steer`);
+ * - `{"type":"control_request","request_id":…,"request":{"subtype":"interrupt"}}`
+ *   is answered by a `control_response`, and the turn then ends with
+ *   `is_error: true` / `terminal_reason: "aborted_tools"`;
+ * - approval prompts reach stdout only with `--permission-prompt-tool stdio`, as
+ *   `control_request` / `can_use_tool`, and are answered with a
+ *   `control_response` whose `behavior` is `allow` (+ `updatedInput`) or `deny`;
+ * - `--session-id <uuid>` fixes the id before the first turn (no `init` line
+ *   is emitted until then), `--resume <id>` continues a recorded one;
+ * - the child needs `USER` in its env: without it the CLI reports "Not logged in".
+ */
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { AGENT_ERROR_CODE, AgentError, TIMEOUT_KIND, } from "../../core/error.js";
+import { readJsonRecord, readNumber, readRecord, readString, } from "../../core/json.js";
+import { redactSecrets } from "../../core/redact.js";
+import { AGENT_EVENT_TYPE } from "../../core/run.js";
+import { APPROVAL_DECISION, SESSION_OWNER_KIND, TURN_OUTCOME, } from "../../core/session.js";
+import { fileExists, readDirectoryNames, readJsonFile, scanJsonlFirstLast, } from "../../host/session-files.js";
+import { assertHostSessionId, SessionProcess, driveSession, sessionStateError, } from "../../kernel/session.js";
+import { CLAUDE, CLAUDE_PERMISSION_MODE, parseClaudeRecord, permissionModeArgs, } from "./cli.js";
+const CONTROL_RESPONSE_TIMEOUT_MS = 30_000;
+const DECLINED_MESSAGE = "Declined by the session owner";
+function sessionArgs(permissions, target, options) {
+    return [
+        CLAUDE.cli.prompt,
+        CLAUDE.cli.inputFormat,
+        CLAUDE.cli.streamJson,
+        CLAUDE.cli.outputFormat,
+        CLAUDE.cli.streamJson,
+        CLAUDE.cli.verbose,
+        ...permissionModeArgs(permissions.mode),
+        CLAUDE.cli.permissionPromptTool,
+        CLAUDE.cli.stdio,
+        // A session's whole point is the recorded conversation, so `disabled`
+        // drops only the customization flags, never `--no-session-persistence`.
+        ...(options.customizations === "disabled"
+            ? [CLAUDE.cli.safeMode, CLAUDE.cli.strictMcpConfig]
+            : []),
+        target.kind === "resume" ? CLAUDE.cli.resume : CLAUDE.cli.sessionId,
+        target.sessionId,
+    ];
+}
+/**
+ * The Claude side of a Session: user lines and control requests out,
+ * stream-json records in. Control responses are correlated here (they
+ * answer this protocol's own requests); everything else is decoded into
+ * the driver's sink. Claude's stream carries no turn id, so the turn id
+ * is a per-session counter.
+ */
+class ClaudeProtocol {
+    process;
+    ctx;
+    pendingControls = new Map();
+    turnCount = 0;
+    interruptRequested = false;
+    incoming;
+    constructor(process, ctx) {
+        this.process = process;
+        this.ctx = ctx;
+        this.incoming = this.records();
+    }
+    get exit() {
+        return this.process.exit;
+    }
+    get stderrTail() {
+        return this.process.stderr;
+    }
+    async startTurn(text) {
+        this.turnCount += 1;
+        this.writeUserLine(text);
+        return String(this.turnCount);
+    }
+    async steer(_turnId, text) {
+        this.writeUserLine(text);
+    }
+    async interrupt() {
+        const requestId = randomUUID();
+        this.interruptRequested = true;
+        const answered = this.awaitControlResponse(requestId);
+        this.process.writeLine(JSON.stringify({
+            type: CLAUDE.json.type.controlRequest,
+            [CLAUDE.json.field.requestId]: requestId,
+            request: { subtype: CLAUDE.json.subtype.interrupt },
+        }));
+        try {
+            await answered;
+        }
+        catch (error) {
+            // An unanswered interrupt must not color the next turn's outcome.
+            this.interruptRequested = false;
+            throw error;
+        }
+    }
+    respond(approval, decision) {
+        const response = decision === APPROVAL_DECISION.accept
+            ? {
+                behavior: CLAUDE.json.behavior.allow,
+                updatedInput: approval.input,
+            }
+            : {
+                behavior: CLAUDE.json.behavior.deny,
+                message: DECLINED_MESSAGE,
+            };
+        this.process.writeLine(JSON.stringify({
+            type: CLAUDE.json.type.controlResponse,
+            response: {
+                subtype: CLAUDE.json.subtype.success,
+                [CLAUDE.json.field.requestId]: approval.requestId,
+                response,
+            },
+        }));
+    }
+    async close() {
+        await this.process.close();
+    }
+    decode(record, sink) {
+        const type = readString(record, CLAUDE.json.field.type);
+        if (type === CLAUDE.json.type.assistant) {
+            for (const event of parseClaudeRecord(record)) {
+                if (event.type === AGENT_EVENT_TYPE.message) {
+                    sink.message(event.text);
+                }
+                else if (event.type === AGENT_EVENT_TYPE.tool) {
+                    sink.tool(event.name);
+                }
+            }
+            return;
+        }
+        if (type === CLAUDE.json.type.result) {
+            const isError = record[CLAUDE.json.field.isError] === true;
+            const outcome = this.interruptRequested
+                ? TURN_OUTCOME.interrupted
+                : isError
+                    ? TURN_OUTCOME.failed
+                    : TURN_OUTCOME.completed;
+            this.interruptRequested = false;
+            sink.endTurn(outcome, readString(record, CLAUDE.json.field.result));
+            return;
+        }
+        if (type === CLAUDE.json.type.controlRequest) {
+            this.decodeControlRequest(record, sink);
+        }
+    }
+    writeUserLine(text) {
+        this.process.writeLine(JSON.stringify({
+            type: CLAUDE.json.type.user,
+            message: { role: CLAUDE.json.type.user, content: text },
+        }));
+    }
+    awaitControlResponse(requestId) {
+        return new Promise((resolve, reject) => {
+            const cancelTimeout = this.ctx.clock.setTimeout(() => {
+                this.pendingControls.delete(requestId);
+                reject(new AgentError({
+                    code: AGENT_ERROR_CODE.timeout,
+                    classification: AgentError.agentFailure(AGENT_ERROR_CODE.timeout),
+                    message: "Claude did not answer the control request in time",
+                    data: {
+                        kind: TIMEOUT_KIND.total,
+                        limitMs: CONTROL_RESPONSE_TIMEOUT_MS,
+                    },
+                    agentId: CLAUDE.id,
+                }));
+            }, CONTROL_RESPONSE_TIMEOUT_MS);
+            this.pendingControls.set(requestId, { resolve, reject, cancelTimeout });
+        });
+    }
+    /** stdout records minus the control responses, which are answered here; settles waiters when the child is gone. */
+    async *records() {
+        try {
+            for await (const line of this.process.lines()) {
+                const record = readJsonRecord(line);
+                if (record === null) {
+                    continue;
+                }
+                if (readString(record, CLAUDE.json.field.type) ===
+                    CLAUDE.json.type.controlResponse) {
+                    this.handleControlResponse(record);
+                    continue;
+                }
+                yield record;
+            }
+        }
+        finally {
+            for (const pending of this.pendingControls.values()) {
+                pending.cancelTimeout();
+                pending.reject(sessionStateError(CLAUDE.id, "session process exited"));
+            }
+            this.pendingControls.clear();
+            this.interruptRequested = false;
+        }
+    }
+    decodeControlRequest(record, sink) {
+        const requestId = readString(record, CLAUDE.json.field.requestId);
+        const request = readRecord(record, CLAUDE.json.field.request);
+        const subtype = request === null ? null : readString(request, CLAUDE.json.field.subtype);
+        if (requestId === null || request === null) {
+            return;
+        }
+        if (subtype !== CLAUDE.json.subtype.canUseTool) {
+            this.ctx.logger.log("warn", `ignoring unsupported claude control request "${subtype ?? "?"}"`);
+            return;
+        }
+        const toolName = readString(request, CLAUDE.json.field.toolName) ?? "";
+        const description = readString(request, CLAUDE.json.field.description);
+        sink.approvalRequested(requestId, description === null ? toolName : `${toolName} ${description}`, { requestId, input: request[CLAUDE.json.field.input] });
+    }
+    handleControlResponse(record) {
+        const response = readRecord(record, CLAUDE.json.field.response);
+        const requestId = response === null
+            ? null
+            : readString(response, CLAUDE.json.field.requestId);
+        if (response === null || requestId === null) {
+            return;
+        }
+        const pending = this.pendingControls.get(requestId);
+        if (pending === undefined) {
+            return;
+        }
+        this.pendingControls.delete(requestId);
+        pending.cancelTimeout();
+        if (readString(response, CLAUDE.json.field.subtype) ===
+            CLAUDE.json.subtype.error) {
+            pending.reject(sessionStateError(CLAUDE.id, redactSecrets(readString(response, CLAUDE.json.field.error) ??
+                "control request failed")));
+            return;
+        }
+        pending.resolve();
+    }
+}
+async function openClaudeSession(target, options, ctx, sessionOptions) {
+    const process = await SessionProcess.spawn({
+        command: CLAUDE.command,
+        args: sessionArgs(options.permissions, target, sessionOptions),
+        cwd: options.workspace,
+        ctx,
+        agentId: CLAUDE.id,
+    });
+    return driveSession({
+        id: target.sessionId,
+        agentId: CLAUDE.id,
+        protocol: new ClaudeProtocol(process, ctx),
+        logger: ctx.logger,
+    });
+}
+function claudeRoot(ctx, ...segments) {
+    return path.join(ctx.location.homeDir, CLAUDE.files.root, ...segments);
+}
+/** `~/.claude/projects/<encoded cwd>/<id>.jsonl` — the project directory name is not derivable, so scan. */
+async function findClaudeTranscript(ctx, id) {
+    const root = claudeRoot(ctx, CLAUDE.files.projects);
+    for (const project of await readDirectoryNames(root)) {
+        const candidate = path.join(root, project, `${id}${CLAUDE.files.transcriptExtension}`);
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/** `~/.claude/sessions/<pid>.json` — one file per live CLI process, keyed by pid. */
+async function claudeRegistryOwner(ctx, id) {
+    const root = claudeRoot(ctx, CLAUDE.files.sessions);
+    for (const name of await readDirectoryNames(root)) {
+        if (!name.endsWith(CLAUDE.files.registryExtension)) {
+            continue;
+        }
+        const entry = await readJsonFile(path.join(root, name));
+        if (entry === null || readString(entry, CLAUDE.files.sessionId) !== id) {
+            continue;
+        }
+        return {
+            kind: SESSION_OWNER_KIND.process,
+            pid: readNumber(entry, CLAUDE.files.pid),
+            entrypoint: readString(entry, CLAUDE.files.entrypoint),
+        };
+    }
+    return { kind: SESSION_OWNER_KIND.none };
+}
+function permissionModeFrom(value) {
+    return value !== null &&
+        Object.values(CLAUDE_PERMISSION_MODE).includes(value)
+        ? value
+        : null;
+}
+async function inspectClaudeSession(id, ctx) {
+    assertHostSessionId(id, CLAUDE.id);
+    const transcript = await findClaudeTranscript(ctx, id);
+    if (transcript === null) {
+        return null;
+    }
+    const cwd = await scanJsonlFirstLast(transcript, (record) => readString(record, CLAUDE.files.cwd));
+    if (cwd.first === null) {
+        return null;
+    }
+    const modes = await scanJsonlFirstLast(transcript, (record) => readString(record, CLAUDE.files.permissionMode));
+    const mode = permissionModeFrom(modes.last);
+    return {
+        workspace: cwd.first,
+        lastPermissions: mode === null ? null : { mode },
+        owner: await claudeRegistryOwner(ctx, id),
+        archived: false,
+    };
+}
+export function claudeSessions(options) {
+    return {
+        open: (resolved, ctx) => openClaudeSession({ kind: "new", sessionId: randomUUID() }, resolved, ctx, options),
+        resume: async (id, resolved, ctx) => {
+            assertHostSessionId(id, CLAUDE.id);
+            return openClaudeSession({ kind: "resume", sessionId: id }, resolved, ctx, options);
+        },
+        inspect: inspectClaudeSession,
+    };
+}

package/dist/agents/codex/cli.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The Codex vocabulary, spelled once: the `codex exec` flags, the app-server
+ * notification and file fields the session reads, the permission words, and
+ * the host's own file names. The run adapter (`index.ts`), the session
+ * adapter (`session.ts`), and the host plane (`host.ts`) all read from here;
+ * JSON-RPC method names and sandbox words come from `codex/protocol.ts`.
+ */
+import type { CODEX_SANDBOX_MODE } from "../../codex/protocol.js";
+export declare const CODEX_HOME_ENV_VAR = "CODEX_HOME";
+export declare const CODEX_API_KEY_ENV_VAR = "OPENAI_API_KEY";
+export declare const CODEX: {
+    readonly id: "codex";
+    readonly command: "codex";
+    readonly cli: {
+        readonly exec: "exec";
+        readonly model: "--model";
+        readonly config: "-c";
+        readonly reasoningEffortConfigKey: "model_reasoning_effort";
+        readonly json: "--json";
+        readonly skipGitRepoCheck: "--skip-git-repo-check";
+        readonly sandbox: "--sandbox";
+        readonly workspace: "-C";
+    };
+    readonly auth: {
+        readonly statusArgs: readonly ["login", "status"];
+        readonly oauthLoginArgs: readonly ["login"];
+        readonly deviceLoginArgs: readonly ["login", "--device-auth"];
+    };
+    readonly json: {
+        readonly field: {
+            readonly type: "type";
+            readonly text: "text";
+            readonly item: "item";
+        };
+        readonly event: {
+            readonly turnCompleted: "turn.completed";
+            readonly agentMessage: "agent_message";
+            readonly itemCompleted: "item.completed";
+        };
+    };
+    readonly mcp: {
+        readonly add: "add";
+        readonly env: "--env";
+        readonly executableSeparator: "--";
+        readonly mcp: "mcp";
+        readonly remove: "remove";
+    };
+    readonly notification: {
+        readonly threadId: "threadId";
+        readonly turnId: "turnId";
+        readonly turn: "turn";
+        readonly item: "item";
+        readonly id: "id";
+        readonly type: "type";
+        readonly text: "text";
+        readonly status: "status";
+        readonly items: "items";
+        readonly phase: "phase";
+        readonly finalAnswer: "final_answer";
+        readonly agentMessage: "agentMessage";
+        readonly userMessage: "userMessage";
+        readonly reasoning: "reasoning";
+        readonly command: "command";
+        readonly reason: "reason";
+    };
+    readonly turnStatus: {
+        readonly completed: "completed";
+        readonly interrupted: "interrupted";
+        readonly failed: "failed";
+    };
+    readonly decision: {
+        readonly accept: "accept";
+        readonly decline: "decline";
+    };
+    readonly error: {
+        readonly archived: "is archived";
+        readonly methodNotFound: -32601;
+        readonly unsupported: "unsupported server request";
+    };
+    readonly files: {
+        readonly root: ".codex";
+        readonly sessions: "sessions";
+        readonly archivedSessions: "archived_sessions";
+        readonly writerLocks: "thread-writer-locks";
+        readonly lockExtension: ".lock";
+        readonly rolloutExtension: ".jsonl";
+        readonly type: "type";
+        readonly payload: "payload";
+        readonly sessionMeta: "session_meta";
+        readonly turnContext: "turn_context";
+        readonly cwd: "cwd";
+        readonly approvalPolicy: "approval_policy";
+        readonly approvalsReviewer: "approvals_reviewer";
+        readonly sandboxPolicy: "sandbox_policy";
+        readonly writableRoots: "writable_roots";
+        readonly networkAccess: "network_access";
+        readonly excludeTmpdirEnvVar: "exclude_tmpdir_env_var";
+        readonly excludeSlashTmp: "exclude_slash_tmp";
+    };
+};
+/** `approval_policy` words (codex 0.153.4 `AskForApproval`; the granular object form is not modeled). */
+export declare const CODEX_APPROVAL_POLICY: {
+    readonly untrusted: "untrusted";
+    readonly onRequest: "on-request";
+    readonly never: "never";
+};
+export type CodexApprovalPolicy = (typeof CODEX_APPROVAL_POLICY)[keyof typeof CODEX_APPROVAL_POLICY];
+export declare const CODEX_APPROVALS_REVIEWER: {
+    readonly user: "user";
+    readonly autoReview: "auto_review";
+    readonly guardianSubagent: "guardian_subagent";
+};
+export type CodexApprovalsReviewer = (typeof CODEX_APPROVALS_REVIEWER)[keyof typeof CODEX_APPROVALS_REVIEWER];
+/** Spelled as the rollout's `turn_context.sandbox_policy` records it. */
+export type { CodexSandboxMode } from "../../codex/protocol.js";
+export type CodexSandboxPolicy = {
+    readonly type: typeof CODEX_SANDBOX_MODE.readOnly;
+} | {
+    readonly type: typeof CODEX_SANDBOX_MODE.dangerFullAccess;
+} | {
+    readonly type: typeof CODEX_SANDBOX_MODE.workspaceWrite;
+    readonly writableRoots: readonly string[];
+    readonly networkAccess: boolean;
+    readonly excludeTmpdirEnvVar: boolean;
+    readonly excludeSlashTmp: boolean;
+};
+export type CodexSessionPermissions = {
+    readonly approvalPolicy: CodexApprovalPolicy;
+    readonly approvalsReviewer: CodexApprovalsReviewer;
+    readonly sandbox: CodexSandboxPolicy;
+};
+//# sourceMappingURL=cli.d.ts.map

package/dist/agents/codex/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../../src/agents/codex/cli.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAC/C,eAAO,MAAM,qBAAqB,mBAAmB,CAAC;AAEtD,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFR,CAAC;AAEX,yGAAyG;AACzG,eAAO,MAAM,qBAAqB;;;;CAIxB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAC7B,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC;AAErE,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,wBAAwB,CAAC,CAAC,MAAM,OAAO,wBAAwB,CAAC,CAAC;AAE3E,yEAAyE;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,QAAQ,CAAA;CAAE,GACrD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,gBAAgB,CAAA;CAAE,GAC7D;IACE,QAAQ,CAAC,IAAI,EAAE,OAAO,kBAAkB,CAAC,cAAc,CAAC;IACxD,QAAQ,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,mBAAmB,EAAE,OAAO,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC,CAAC;AAEN,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,CAAC,cAAc,EAAE,mBAAmB,CAAC;IAC7C,QAAQ,CAAC,iBAAiB,EAAE,sBAAsB,CAAC;IACnD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;CACtC,CAAC"}