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

package/dist/agents/codex.js

@@ -1,379 +0,0 @@
-/**
- * Built-in codex CLI contract:
- * `codex exec [--model m] [-c model_reasoning_effort="e"] --json
- *  --skip-git-repo-check --sandbox <mode> -C <workspace>`, prompt on
- * stdin. Codex sandboxing is filesystem-level, so read-only grants have
- * no argv mapping and are ignored here.
- */
-import { LOGIN_METHOD } from "../auth/login.js";
-import { cliLoginProbe } from "../auth/login-probe.js";
-import { AUTH_MATERIAL_KIND, envVarAuthMaterial } from "../auth/material.js";
-import { requireSecret } from "../auth/secrets.js";
-import { listAllCodexMcpServerStatuses, withCodexAppServer, } from "../codex/app-server.js";
-import { CODEX_APP_SERVER_METHOD } from "../codex/protocol.js";
-import { AGENT_ERROR_CODE, AgentError, AUTH_FAILURE_REASON, } from "../core/error.js";
-import { readJsonRecord, readRecord, readString } from "../core/json.js";
-import { AGENT_EVENT_TYPE } from "../core/run.js";
-import { cliAvailability } from "../host/availability.js";
-import { INSTALL_STATUS, MCP_SCOPE, MCP_TRANSPORT, SKILL_SOURCE_KIND, } from "../host/capabilities.js";
-import { runHostCommand } from "../host/run-command.js";
-import { parseCooldownHint } from "../kernel/classify.js";
-import { defineCliAgent } from "../kernel/cli-agent.js";
-import { cliLoginCommand } from "../kernel/cli-login.js";
-import { SANDBOX_MODE } from "../kernel/options.js";
-import { codexSessions, } from "./codex-session.js";
-export const CODEX_HOME_ENV_VAR = "CODEX_HOME";
-export const CODEX_API_KEY_ENV_VAR = "OPENAI_API_KEY";
-const CODEX = {
-    id: "codex",
-    command: "codex",
-    cli: {
-        exec: "exec",
-        model: "--model",
-        config: "-c",
-        reasoningEffortConfigKey: "model_reasoning_effort",
-        json: "--json",
-        skipGitRepoCheck: "--skip-git-repo-check",
-        sandbox: "--sandbox",
-        workspace: "-C",
-    },
-    sandbox: {
-        full: "danger-full-access",
-        readOnly: "read-only",
-    },
-    auth: {
-        // Exit-code-only login probe (E12): `codex login status` exits 0 when a
-        // credential is present, nonzero otherwise. The output format is not
-        // parsed — only the exit code decides valid/invalid, like claude's.
-        statusArgs: ["login", "status"],
-        oauthLoginArgs: ["login"],
-        deviceLoginArgs: ["login", "--device-auth"],
-    },
-    json: {
-        field: {
-            type: "type",
-            text: "text",
-            item: "item",
-        },
-        event: {
-            turnCompleted: "turn.completed",
-            agentMessage: "agent_message",
-            itemCompleted: "item.completed",
-        },
-    },
-    mcp: {
-        add: "add",
-        env: "--env",
-        executableSeparator: "--",
-        mcp: "mcp",
-        remove: "remove",
-    },
-};
-const COMPETING_API_KEY_VARS = ["OPENAI_API_KEY", "CODEX_API_KEY"];
-const COMPETING_HOME_VARS = ["CODEX_HOME", "CODEX_API_KEY"];
-const UNSUPPORTED_CWD_REASON = "unsupported codex stdio mcp cwd";
-const UNSUPPORTED_SCOPE_REASON_PREFIX = "unsupported codex mcp scope";
-const UNSUPPORTED_PLUGIN_OVERWRITE_REASON = "plugin install does not support overwrite";
-const CODEX_PLUGIN_AUTH_REQUIRED_MESSAGE = "Codex plugin installation requires app authorization";
-const CODEX_ALREADY_INSTALLED_STATUS = /already/i;
-const CODEX_MCP_UNUSABLE_STATUS = /failed|error|invalid|missing|required/i;
-/** Codex capacity phrasing (v1 F5 signals, kept verbatim). */
-const CAPACITY_TEXT = /selected model is at capacity|model is at capacity/i;
-const CAPACITY_COMBINED = /at capacity/i;
-const CAPACITY_MODEL = /model/i;
-function sharedArgs(ctx, sandboxValue) {
-    return [
-        CODEX.cli.exec,
-        ...(ctx.model === null ? [] : [CODEX.cli.model, ctx.model]),
-        ...(ctx.effort === null
-            ? []
-            : [
-                CODEX.cli.config,
-                `${CODEX.cli.reasoningEffortConfigKey}="${ctx.effort}"`,
-            ]),
-        CODEX.cli.json,
-        CODEX.cli.skipGitRepoCheck,
-        CODEX.cli.sandbox,
-        sandboxValue,
-        CODEX.cli.workspace,
-        ctx.workspace,
-    ];
-}
-function parseCodexLine(line) {
-    const record = readJsonRecord(line);
-    if (record === null) {
-        return [];
-    }
-    const type = readString(record, CODEX.json.field.type);
-    if (type === CODEX.json.event.turnCompleted) {
-        return [{ type: AGENT_EVENT_TYPE.turn }];
-    }
-    if (type === CODEX.json.event.agentMessage) {
-        const text = readString(record, CODEX.json.field.text);
-        return text === null ? [] : [{ type: AGENT_EVENT_TYPE.message, text }];
-    }
-    if (type === CODEX.json.event.itemCompleted) {
-        const item = readRecord(record, CODEX.json.field.item);
-        if (item !== null &&
-            readString(item, CODEX.json.field.type) === CODEX.json.event.agentMessage) {
-            const text = readString(item, CODEX.json.field.text);
-            return text === null ? [] : [{ type: AGENT_EVENT_TYPE.message, text }];
-        }
-    }
-    return [];
-}
-/**
- * Codex "selected model is at capacity" phrasing, plus the looser
- * "model ... at capacity" combination. Exported for custom agents that
- * surface the same provider text.
- */
-export function capacityTextMatcher() {
-    return (evidence) => {
-        const text = `${evidence.stderr}\n${evidence.stdout}`;
-        const matches = CAPACITY_TEXT.test(text) ||
-            (CAPACITY_COMBINED.test(text) && CAPACITY_MODEL.test(text));
-        if (!matches) {
-            return null;
-        }
-        return {
-            code: AGENT_ERROR_CODE.capacity,
-            message: "Provider is at capacity",
-            data: { cooldownUntil: parseCooldownHint(text, evidence.now) },
-        };
-    };
-}
-function codexAppServerCwd(ctx) {
-    return ctx.location.projectDir ?? ctx.location.homeDir;
-}
-function codexAppServerCwds(ctx) {
-    return [codexAppServerCwd(ctx)];
-}
-async function listCodexSkills(ctx) {
-    return withCodexAppServer(codexAppServerOptions(ctx), async (client) => {
-        const result = await client.request(CODEX_APP_SERVER_METHOD.skillsList, {
-            cwds: codexAppServerCwds(ctx),
-            forceReload: true,
-        });
-        return skillsFromCodexResult(result);
-    });
-}
-async function installCodexPlugin(ctx, source, options) {
-    if (options.overwrite === true) {
-        // `plugin/install` has no overwrite semantics; refusing is honest,
-        // silently ignoring the request is not (same contract as claude).
-        throw new AgentError({
-            code: AGENT_ERROR_CODE.invalidInput,
-            classification: AgentError.agentFailure(AGENT_ERROR_CODE.invalidInput),
-            message: "Codex plugin installation cannot overwrite an installed plugin",
-            data: { reason: UNSUPPORTED_PLUGIN_OVERWRITE_REASON },
-        });
-    }
-    return withCodexAppServer(codexAppServerOptions(ctx), async (client) => {
-        const result = await client.request(CODEX_APP_SERVER_METHOD.pluginInstall, {
-            pluginName: source.name,
-            marketplacePath: null,
-            remoteMarketplaceName: null,
-        });
-        return installOutcomeFromCodexPlugin(source.name, result);
-    });
-}
-async function listCodexMcp(ctx) {
-    return withCodexAppServer(codexAppServerOptions(ctx), async (client) => (await listAllCodexMcpServerStatuses(client)).map(codexMcpState));
-}
-async function addCodexStdioMcp(ctx, name, spec, options) {
-    assertCodexStdioMcpSupported(spec, options);
-    await runHostCommand(ctx, {
-        command: CODEX.command,
-        args: [
-            CODEX.mcp.mcp,
-            CODEX.mcp.add,
-            name,
-            ...Object.entries(spec.env).flatMap(([key, value]) => [
-                CODEX.mcp.env,
-                `${key}=${value}`,
-            ]),
-            CODEX.mcp.executableSeparator,
-            spec.command,
-            ...spec.args,
-        ],
-    });
-    return {
-        status: INSTALL_STATUS.installed,
-        location: `codex:${options.scope}:${name}`,
-    };
-}
-async function removeCodexMcp(ctx, name, options) {
-    assertCodexMcpScopeSupported(options.scope);
-    await runHostCommand(ctx, {
-        command: CODEX.command,
-        args: [CODEX.mcp.mcp, CODEX.mcp.remove, name],
-    });
-}
-function assertCodexStdioMcpSupported(spec, options) {
-    assertCodexMcpScopeSupported(options.scope);
-    if (spec.cwd !== null) {
-        throw new AgentError({
-            code: AGENT_ERROR_CODE.invalidInput,
-            classification: AgentError.agentFailure(AGENT_ERROR_CODE.invalidInput),
-            message: "Codex stdio MCP registration does not support server cwd",
-            data: { reason: UNSUPPORTED_CWD_REASON },
-        });
-    }
-}
-function assertCodexMcpScopeSupported(scope) {
-    if (scope === MCP_SCOPE.user) {
-        return;
-    }
-    const reason = [UNSUPPORTED_SCOPE_REASON_PREFIX, scope].join(": ");
-    throw new AgentError({
-        code: AGENT_ERROR_CODE.invalidInput,
-        classification: AgentError.agentFailure(AGENT_ERROR_CODE.invalidInput),
-        message: `Codex MCP registration does not support scope "${scope}"`,
-        data: { reason },
-    });
-}
-function codexAppServerOptions(ctx) {
-    return {
-        exec: ctx.exec,
-        clock: ctx.clock,
-        env: ctx.env,
-        cwd: codexAppServerCwd(ctx),
-        command: CODEX.command,
-    };
-}
-function skillsFromCodexResult(result) {
-    return result.data.flatMap((entry) => entry.skills.map((skill) => ({
-        id: skill.name,
-        name: skill.name,
-        description: skill.description,
-        location: skill.path,
-        source: `codex:${skill.scope}`,
-    })));
-}
-function installOutcomeFromCodexPlugin(name, result) {
-    if (result.appsNeedingAuth.length > 0) {
-        throw new AgentError({
-            code: AGENT_ERROR_CODE.auth,
-            classification: AgentError.agentFailure(AGENT_ERROR_CODE.auth),
-            message: CODEX_PLUGIN_AUTH_REQUIRED_MESSAGE,
-            data: {
-                reason: AUTH_FAILURE_REASON.notLoggedIn,
-                detail: result.authPolicy,
-            },
-        });
-    }
-    const location = result.location ?? `codex:plugin:${name}`;
-    const alreadyInstalled = result.alreadyInstalled === true ||
-        (result.status !== null &&
-            CODEX_ALREADY_INSTALLED_STATUS.test(result.status));
-    return {
-        status: alreadyInstalled
-            ? INSTALL_STATUS.alreadyInstalled
-            : INSTALL_STATUS.installed,
-        location,
-    };
-}
-function codexMcpState(status) {
-    // tools === null = the app-server did not enumerate tools; McpServerState
-    // keeps that distinct from an enumerated-but-empty tool list.
-    const tools = status.tools === null
-        ? null
-        : Object.entries(status.tools).map(([key, tool]) => tool.name ?? key);
-    return {
-        name: status.name,
-        transport: MCP_TRANSPORT.stdio,
-        usable: !CODEX_MCP_UNUSABLE_STATUS.test(status.authStatus),
-        tools,
-    };
-}
-function codexLogin(args) {
-    return (request, ctx) => cliLoginCommand({
-        command: CODEX.command,
-        args,
-        envPatch: {
-            set: { [CODEX_HOME_ENV_VAR]: request.homeDir },
-            unset: COMPETING_API_KEY_VARS,
-        },
-        request,
-        ctx,
-    });
-}
-export function codex() {
-    const definition = defineCliAgent({
-        id: CODEX.id,
-        command: CODEX.command,
-        args: {
-            [SANDBOX_MODE.full]: (_sandbox, ctx) => sharedArgs(ctx, CODEX.sandbox.full),
-            [SANDBOX_MODE.readOnly]: (_sandbox, ctx) => sharedArgs(ctx, CODEX.sandbox.readOnly),
-        },
-        parseLine: parseCodexLine,
-        classify: [capacityTextMatcher()],
-        detectCompletion: (line, state) => {
-            if (state.messages.length === 0) {
-                return false;
-            }
-            const record = readJsonRecord(line);
-            return (record !== null &&
-                readString(record, CODEX.json.field.type) ===
-                    CODEX.json.event.turnCompleted);
-        },
-        availability: cliAvailability({
-            command: CODEX.command,
-            commandMissingRemediation: {
-                detail: "Install Codex and ensure `codex` is on PATH.",
-                command: null,
-            },
-            authentication: {
-                args: CODEX.auth.statusArgs,
-                remediation: {
-                    detail: "Sign in to Codex.",
-                    command: {
-                        executable: CODEX.command,
-                        args: CODEX.auth.oauthLoginArgs,
-                    },
-                },
-            },
-        }),
-        auth: {
-            [AUTH_MATERIAL_KIND.homeDir]: envVarAuthMaterial({
-                set: (material) => ({ [CODEX_HOME_ENV_VAR]: material.path }),
-                unset: COMPETING_API_KEY_VARS,
-                check: (material, ctx) => cliLoginProbe({
-                    command: CODEX.command,
-                    args: CODEX.auth.statusArgs,
-                    envPatch: {
-                        set: { [CODEX_HOME_ENV_VAR]: material.path },
-                        unset: COMPETING_API_KEY_VARS,
-                    },
-                    ctx,
-                }),
-            }),
-            [AUTH_MATERIAL_KIND.apiKey]: envVarAuthMaterial({
-                set: async (material, secrets) => ({
-                    [CODEX_API_KEY_ENV_VAR]: await requireSecret(secrets, material.secret),
-                }),
-                unset: COMPETING_HOME_VARS,
-            }),
-        },
-        login: {
-            methods: {
-                [LOGIN_METHOD.oauth]: codexLogin(CODEX.auth.oauthLoginArgs),
-                [LOGIN_METHOD.device]: codexLogin(CODEX.auth.deviceLoginArgs),
-            },
-        },
-        skills: {
-            list: listCodexSkills,
-            install: {
-                [SKILL_SOURCE_KIND.plugin]: installCodexPlugin,
-            },
-        },
-        mcp: {
-            list: listCodexMcp,
-            add: {
-                [MCP_TRANSPORT.stdio]: addCodexStdioMcp,
-            },
-            remove: removeCodexMcp,
-        },
-    });
-    return { ...definition, session: codexSessions() };
-}

package/dist/agents/openai-compatible/pi/session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/agents/openai-compatible/pi/session.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,aAAa,CAAC;AA8E5D,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,8BAA8B,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;CAC1B,CAAC;AAWF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,QAAQ,CAE/D"}

package/dist/core/process-close.d.ts

@@ -1,11 +0,0 @@
-/**
- * The one way a held child is ended: stdin EOF first (both hosts exit on
- * it — and only that exit removes Codex's thread writer lock), SIGTERM
- * after a grace for a child that is not reading stdin, SIGKILL after
- * another for one that ignores both. Shared by the session child and the
- * codex app-server client so the escalation exists once.
- */
-import type { Clock, ExecExit, InteractiveExecProcess } from "./ports.js";
-export declare const CLOSE_GRACE_MS = 5000;
-export declare function endProcessGracefully(process: InteractiveExecProcess, clock: Clock): Promise<ExecExit>;
-//# sourceMappingURL=process-close.d.ts.map

package/dist/core/process-close.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"process-close.d.ts","sourceRoot":"","sources":["../../src/core/process-close.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAG1E,eAAO,MAAM,cAAc,OAAQ,CAAC;AAEpC,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,sBAAsB,EAC/B,KAAK,EAAE,KAAK,GACX,OAAO,CAAC,QAAQ,CAAC,CAoBnB"}

package/dist/core/process-close.js

@@ -1,27 +0,0 @@
-/**
- * The one way a held child is ended: stdin EOF first (both hosts exit on
- * it — and only that exit removes Codex's thread writer lock), SIGTERM
- * after a grace for a child that is not reading stdin, SIGKILL after
- * another for one that ignores both. Shared by the session child and the
- * codex app-server client so the escalation exists once.
- */
-import { PROCESS_SIGNAL } from "./values.js";
-export const CLOSE_GRACE_MS = 5_000;
-export async function endProcessGracefully(process, clock) {
-    process.endStdin();
-    const cancels = [];
-    cancels.push(clock.setTimeout(() => {
-        process.kill(PROCESS_SIGNAL.sigterm);
-        cancels.push(clock.setTimeout(() => {
-            process.kill(PROCESS_SIGNAL.sigkill);
-        }, CLOSE_GRACE_MS));
-    }, CLOSE_GRACE_MS));
-    try {
-        return await process.exit;
-    }
-    finally {
-        for (const cancel of cancels.splice(0)) {
-            cancel();
-        }
-    }
-}