@alpacakit/agents 0.1.0-beta.19

package/dist/agents/codex.js

@@ -0,0 +1,355 @@
+/**
+ * Built-in codex adapter (v1 E1/E2 argv kept verbatim):
+ * `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 { 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";
+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,
+            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,
+            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,
+        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,
+            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() {
+    return 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);
+        },
+        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,
+        },
+    });
+}

package/dist/agents/openai-compatible/config.d.ts

@@ -0,0 +1,16 @@
+import { type DoctorCheck } from "../../host/capabilities.js";
+import type { OpenAiCompatibleConfig, ResolvedOpenAiCompatibleConfig } from "./types.js";
+export interface OpenAiCompatibleConfigResolver {
+    normalize<Id extends string>(config: OpenAiCompatibleConfig<Id>): OpenAiCompatibleConfig<Id>;
+    resolve(config: OpenAiCompatibleConfig, env: Readonly<Record<string, string>>): ResolvedOpenAiCompatibleConfig;
+    doctorChecks(config: OpenAiCompatibleConfig, env: Readonly<Record<string, string>>): readonly DoctorCheck[];
+}
+export declare class DefaultOpenAiCompatibleConfigResolver implements OpenAiCompatibleConfigResolver {
+    normalize<Id extends string>(config: OpenAiCompatibleConfig<Id>): OpenAiCompatibleConfig<Id>;
+    resolve(config: OpenAiCompatibleConfig, env: Readonly<Record<string, string>>): ResolvedOpenAiCompatibleConfig;
+    doctorChecks(config: OpenAiCompatibleConfig, env: Readonly<Record<string, string>>): readonly DoctorCheck[];
+    private resolveRequiredTemplate;
+    private missingEnvChecks;
+}
+export declare const defaultOpenAiCompatibleConfigResolver: DefaultOpenAiCompatibleConfigResolver;
+//# sourceMappingURL=config.d.ts.map

package/dist/agents/openai-compatible/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/agents/openai-compatible/config.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,4BAA4B,CAAC;AAMpC,OAAO,KAAK,EAEV,sBAAsB,EACtB,8BAA8B,EAC/B,MAAM,YAAY,CAAC;AAmBpB,MAAM,WAAW,8BAA8B;IAC7C,SAAS,CAAC,EAAE,SAAS,MAAM,EACzB,MAAM,EAAE,sBAAsB,CAAC,EAAE,CAAC,GACjC,sBAAsB,CAAC,EAAE,CAAC,CAAC;IAC9B,OAAO,CACL,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACpC,8BAA8B,CAAC;IAClC,YAAY,CACV,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACpC,SAAS,WAAW,EAAE,CAAC;CAC3B;AAED,qBAAa,qCACX,YAAW,8BAA8B;IAEzC,SAAS,CAAC,EAAE,SAAS,MAAM,EACzB,MAAM,EAAE,sBAAsB,CAAC,EAAE,CAAC,GACjC,sBAAsB,CAAC,EAAE,CAAC;IAW7B,OAAO,CACL,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACpC,8BAA8B;IAyCjC,YAAY,CACV,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GACpC,SAAS,WAAW,EAAE;IASzB,OAAO,CAAC,uBAAuB;IAuB/B,OAAO,CAAC,gBAAgB;CAYzB;AAED,eAAO,MAAM,qCAAqC,uCACL,CAAC"}

package/dist/agents/openai-compatible/config.js

@@ -0,0 +1,160 @@
+import { AGENT_ERROR_CODE, AgentError, NOT_AVAILABLE_CAUSE, } from "../../core/error.js";
+import { DOCTOR_CHECK_STATUS, } from "../../host/capabilities.js";
+import { referencedEnvNames as referencedTemplateEnvNames, resolveEnvTemplate, } from "../../kernel/env-template.js";
+const CONFIG_FIELD = {
+    apiKey: "apiKey",
+    baseUrl: "baseUrl",
+    headers: "headers",
+    model: "model",
+    requestParams: "requestParams",
+};
+const DOCTOR_CHECK = {
+    baseUrl: "base-url",
+    envPrefix: "env:",
+};
+const HTTP_PROTOCOL = {
+    http: "http:",
+    https: "https:",
+};
+const OBJECT_PATH_SEPARATOR = ".";
+export class DefaultOpenAiCompatibleConfigResolver {
+    normalize(config) {
+        return {
+            id: config.id,
+            baseUrl: config.baseUrl,
+            model: config.model,
+            apiKey: config.apiKey,
+            headers: { ...config.headers },
+            requestParams: structuredClone(config.requestParams),
+        };
+    }
+    resolve(config, env) {
+        const baseUrl = this.resolveRequiredTemplate(CONFIG_FIELD.baseUrl, config.baseUrl, env);
+        assertHttpBaseUrl(baseUrl);
+        return {
+            id: config.id,
+            baseUrl,
+            model: this.resolveRequiredTemplate(CONFIG_FIELD.model, config.model, env),
+            apiKey: config.apiKey === null
+                ? null
+                : this.resolveRequiredTemplate(CONFIG_FIELD.apiKey, config.apiKey, env),
+            headers: Object.fromEntries(Object.entries(config.headers).map(([key, value]) => [
+                key,
+                this.resolveRequiredTemplate(pathLabel(CONFIG_FIELD.headers, key), value, env),
+            ])),
+            requestParams: resolveJsonObjectTemplates(CONFIG_FIELD.requestParams, config.requestParams, env),
+        };
+    }
+    doctorChecks(config, env) {
+        const envChecks = this.missingEnvChecks(config, env);
+        if (envChecks.length > 0) {
+            return envChecks;
+        }
+        const baseUrlCheck = validateBaseUrlCheck(config, env);
+        return baseUrlCheck === null ? [] : [baseUrlCheck];
+    }
+    resolveRequiredTemplate(label, value, env) {
+        const resolved = resolveEnvTemplate(value, env);
+        if (!resolved.ok) {
+            throw new AgentError({
+                code: AGENT_ERROR_CODE.notAvailable,
+                message: `openaiCompatible.${label} references ${resolved.reason} environment variable: ${resolved.envName}`,
+                data: { cause: NOT_AVAILABLE_CAUSE.badConfig },
+            });
+        }
+        if (resolved.value.trim().length === 0) {
+            throw new AgentError({
+                code: AGENT_ERROR_CODE.notAvailable,
+                message: `openaiCompatible.${label} resolved to an empty value`,
+                data: { cause: NOT_AVAILABLE_CAUSE.badConfig },
+            });
+        }
+        return resolved.value;
+    }
+    missingEnvChecks(config, env) {
+        return referencedTemplateEnvNames(config)
+            .filter((name) => (env[name] ?? "").length === 0)
+            .map((name) => ({
+            id: `${DOCTOR_CHECK.envPrefix}${name}`,
+            status: DOCTOR_CHECK_STATUS.fail,
+            detail: `Missing or empty environment variable: ${name}`,
+        }));
+    }
+}
+export const defaultOpenAiCompatibleConfigResolver = new DefaultOpenAiCompatibleConfigResolver();
+function resolveJsonTemplates(label, value, env) {
+    if (typeof value === "string") {
+        const resolved = resolveEnvTemplate(value, env);
+        if (!resolved.ok) {
+            throw new AgentError({
+                code: AGENT_ERROR_CODE.notAvailable,
+                message: `openaiCompatible.${label} references ${resolved.reason} environment variable: ${resolved.envName}`,
+                data: { cause: NOT_AVAILABLE_CAUSE.badConfig },
+            });
+        }
+        return resolved.value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item, index) => resolveJsonTemplates(arrayPathLabel(label, index), item, env));
+    }
+    if (isJsonRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+            key,
+            resolveJsonTemplates(pathLabel(label, key), item, env),
+        ]));
+    }
+    return value;
+}
+function resolveJsonObjectTemplates(label, value, env) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        resolveJsonTemplates(pathLabel(label, key), item, env),
+    ]));
+}
+function isJsonRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateBaseUrlCheck(config, env) {
+    const resolved = resolveEnvTemplate(config.baseUrl, env);
+    if (!resolved.ok) {
+        return null;
+    }
+    try {
+        assertHttpBaseUrl(resolved.value);
+        return null;
+    }
+    catch (error) {
+        return {
+            id: DOCTOR_CHECK.baseUrl,
+            status: DOCTOR_CHECK_STATUS.fail,
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function assertHttpBaseUrl(baseUrl) {
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        throw new AgentError({
+            code: AGENT_ERROR_CODE.notAvailable,
+            message: `Invalid OpenAI-compatible baseUrl: ${baseUrl}`,
+            data: { cause: NOT_AVAILABLE_CAUSE.badConfig },
+        });
+    }
+    if (parsed.protocol !== HTTP_PROTOCOL.http &&
+        parsed.protocol !== HTTP_PROTOCOL.https) {
+        throw new AgentError({
+            code: AGENT_ERROR_CODE.notAvailable,
+            message: `Invalid OpenAI-compatible baseUrl protocol: ${parsed.protocol}`,
+            data: { cause: NOT_AVAILABLE_CAUSE.badConfig },
+        });
+    }
+}
+function pathLabel(parent, child) {
+    return [parent, child].join(OBJECT_PATH_SEPARATOR);
+}
+function arrayPathLabel(parent, index) {
+    return `${parent}[${index}]`;
+}

package/dist/agents/openai-compatible/engine.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The engine port: how a resolved OpenAI-compatible config is turned
+ * into an AgentRun. The engine owns its own availability — its doctor
+ * checks describe requirements of the engine itself (peer packages,
+ * node floor), never of the config (the resolver owns those). The
+ * shipped default is the dependency-free fetch chat-completions engine;
+ * an in-process pi-session engine (design E3, v1 parity) is a
+ * detail-backlog implementation of this same port.
+ */
+import type { DoctorCheck } from "../../host/capabilities.js";
+import type { AgentRun, RunContext } from "../../kernel/definition.js";
+import type { ResolvedRunOptions } from "../../kernel/options.js";
+import type { ResolvedOpenAiCompatibleConfig } from "./types.js";
+export interface OpenAiCompatibleEngine {
+    doctorChecks(): Promise<readonly DoctorCheck[]>;
+    run(config: ResolvedOpenAiCompatibleConfig, options: ResolvedRunOptions, ctx: RunContext): AgentRun;
+}
+//# sourceMappingURL=engine.d.ts.map

package/dist/agents/openai-compatible/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/agents/openai-compatible/engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAEjE,MAAM,WAAW,sBAAsB;IACrC,YAAY,IAAI,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC,CAAC;IAChD,GAAG,CACD,MAAM,EAAE,8BAA8B,EACtC,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,UAAU,GACd,QAAQ,CAAC;CACb"}

package/dist/agents/openai-compatible/engine.js

@@ -0,0 +1,10 @@
+/**
+ * The engine port: how a resolved OpenAI-compatible config is turned
+ * into an AgentRun. The engine owns its own availability — its doctor
+ * checks describe requirements of the engine itself (peer packages,
+ * node floor), never of the config (the resolver owns those). The
+ * shipped default is the dependency-free fetch chat-completions engine;
+ * an in-process pi-session engine (design E3, v1 parity) is a
+ * detail-backlog implementation of this same port.
+ */
+export {};

package/dist/agents/openai-compatible/fetch-engine.d.ts

@@ -0,0 +1,38 @@
+import { AgentError } from "../../core/error.js";
+import type { DoctorCheck } from "../../host/capabilities.js";
+import type { AgentRun, RunContext } from "../../kernel/definition.js";
+import type { ResolvedRunOptions } from "../../kernel/options.js";
+import type { OpenAiCompatibleEngine } from "./engine.js";
+import { type OpenAiCompatibleResponseDecoder } from "./response.js";
+import type { ResolvedOpenAiCompatibleConfig } from "./types.js";
+export interface OpenAiCompatibleRetryPolicy {
+    readonly maxAttempts: number;
+    shouldRetry(error: AgentError, attempt: number): boolean;
+}
+export interface OpenAiCompatibleHttpFailurePolicy {
+    errorFor(response: Response, ctx: RunContext): Promise<AgentError | null>;
+}
+export type FetchOpenAiCompatibleEngineDependencies = {
+    readonly decoders?: readonly OpenAiCompatibleResponseDecoder[];
+    readonly retryPolicy?: OpenAiCompatibleRetryPolicy;
+    readonly failurePolicy?: OpenAiCompatibleHttpFailurePolicy;
+};
+export declare class FetchOpenAiCompatibleEngine implements OpenAiCompatibleEngine {
+    private readonly decoders;
+    private readonly retryPolicy;
+    private readonly failurePolicy;
+    constructor(dependencies?: FetchOpenAiCompatibleEngineDependencies);
+    doctorChecks(): Promise<readonly DoctorCheck[]>;
+    run(config: ResolvedOpenAiCompatibleConfig, options: ResolvedRunOptions, ctx: RunContext): AgentRun;
+    private decoderFor;
+}
+export declare class DefaultOpenAiCompatibleRetryPolicy implements OpenAiCompatibleRetryPolicy {
+    readonly maxAttempts = 2;
+    shouldRetry(error: AgentError, attempt: number): boolean;
+}
+export declare class DefaultOpenAiCompatibleHttpFailurePolicy implements OpenAiCompatibleHttpFailurePolicy {
+    private readonly handlers;
+    errorFor(response: Response, ctx: RunContext): Promise<AgentError | null>;
+}
+export declare const defaultOpenAiCompatibleEngine: FetchOpenAiCompatibleEngine;
+//# sourceMappingURL=fetch-engine.d.ts.map

package/dist/agents/openai-compatible/fetch-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-engine.d.ts","sourceRoot":"","sources":["../../../src/agents/openai-compatible/fetch-engine.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EAIX,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAa,8BAA8B,EAAE,MAAM,YAAY,CAAC;AA+C5E,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1D;AAED,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;CAC3E;AAED,MAAM,MAAM,uCAAuC,GAAG;IACpD,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,+BAA+B,EAAE,CAAC;IAC/D,QAAQ,CAAC,WAAW,CAAC,EAAE,2BAA2B,CAAC;IACnD,QAAQ,CAAC,aAAa,CAAC,EAAE,iCAAiC,CAAC;CAC5D,CAAC;AAEF,qBAAa,2BAA4B,YAAW,sBAAsB;IACxE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6C;IACtE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAC1D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAoC;gBAEtD,YAAY,GAAE,uCAA4C;IAUhE,YAAY,IAAI,OAAO,CAAC,SAAS,WAAW,EAAE,CAAC;IAI9C,GAAG,CACR,MAAM,EAAE,8BAA8B,EACtC,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,UAAU,GACd,QAAQ;IA+CX,OAAO,CAAC,UAAU;CAanB;AAED,qBAAa,kCACX,YAAW,2BAA2B;IAEtC,QAAQ,CAAC,WAAW,KAAwB;IAE5C,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO;CAGzD;AAED,qBAAa,wCACX,YAAW,iCAAiC;IAE5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAIvB;IAEI,QAAQ,CACZ,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,UAAU,GACd,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;CAM9B;AAyID,eAAO,MAAM,6BAA6B,6BAAoC,CAAC"}