@osdlc/agent-call 0.0.1-stage → 0.4.0

package/dist/registry.d.ts

@@ -0,0 +1,21 @@
+import type { AgentAdapter } from './adapters/types.js';
+import type { AgentName } from './spec.js';
+/** Instantiate a built-in adapter by name. */
+export declare function adapterFor(name: AgentName, options?: {
+    binary?: string;
+}): AgentAdapter;
+/** The names `adapterFor` accepts, in a fixed order. Frozen at run time. */
+export declare const BUILTIN_AGENTS: readonly AgentName[];
+/** Whether one agent CLI is installed, as `detectAgents` reports it. */
+export interface AgentAvailability {
+    /** The adapter's name. */
+    name: string;
+    /** `<binary> --version` ran, exited 0 and finished within 10 seconds. */
+    available: boolean;
+    /** First line of the `--version` output, when available. */
+    version?: string | undefined;
+}
+/** Probe which agent CLIs are installed (via `<binary> --version`). */
+export declare function detectAgents(adapters?: AgentAdapter[]): Promise<AgentAvailability[]>;
+/** @internal `timeoutMs` is a parameter so a test can shorten it. */
+export declare function probeVersion(binary: string, timeoutMs?: number): Promise<string | undefined>;

package/dist/registry.js

@@ -0,0 +1,41 @@
+import { claudeAdapter } from './adapters/claude.js';
+import { codexAdapter } from './adapters/codex.js';
+import { antigravityAdapter } from './adapters/antigravity.js';
+import { opencodeAdapter } from './adapters/opencode.js';
+import { spawnCollect } from './spawn.js';
+/** Instantiate a built-in adapter by name. */
+export function adapterFor(name, options = {}) {
+    switch (name) {
+        case 'claude':
+            return claudeAdapter(options);
+        case 'codex':
+            return codexAdapter(options);
+        case 'antigravity':
+            return antigravityAdapter(options);
+        case 'opencode':
+            return opencodeAdapter(options);
+    }
+}
+/** The names `adapterFor` accepts, in a fixed order. Frozen at run time. */
+export const BUILTIN_AGENTS = Object.freeze([
+    'claude',
+    'codex',
+    'antigravity',
+    'opencode',
+]);
+/** Probe which agent CLIs are installed (via `<binary> --version`). */
+export async function detectAgents(adapters = BUILTIN_AGENTS.map((name) => adapterFor(name))) {
+    return Promise.all(adapters.map(async (adapter) => {
+        const version = await probeVersion(adapter.binary);
+        return {
+            name: adapter.name,
+            available: version !== undefined,
+            version,
+        };
+    }));
+}
+/** @internal `timeoutMs` is a parameter so a test can shorten it. */
+export async function probeVersion(binary, timeoutMs = 10_000) {
+    const raw = await spawnCollect([binary, '--version'], { env: process.env, timeoutMs });
+    return raw.exitCode === 0 && !raw.timedOut ? raw.stdout.trim().split('\n')[0] : undefined;
+}

package/dist/run.d.ts

@@ -0,0 +1,75 @@
+import type { AgentAdapter, ParsedOutput, RawProcessOutput } from './adapters/types.js';
+import type { Conversation } from './conversation.js';
+import { type PlannedCall } from './plan.js';
+import type { AgentCallSpec } from './spec.js';
+/**
+ * Why a run failed, on `AgentResult.error`. `callAgent` returns it instead of
+ * throwing.
+ *
+ * `reason` is open: a later minor release may add reasons. Handle the ones you
+ * know and keep a default branch for the rest.
+ */
+export interface CallError {
+    /**
+     * - `spawn-failed` — the process never started (binary missing, empty argv).
+     * - `timeout` — `timeoutMs` elapsed or the caller aborted.
+     * - `nonzero-exit` — the process exited with a nonzero code, or ended on a
+     *   signal the runner did not send (such as an out-of-memory kill); `detail`
+     *   names the signal.
+     * - `agent-error` — the process exited 0 but the agent reported failure, or
+     *   the adapter's parser threw on the output.
+     */
+    reason: 'spawn-failed' | 'timeout' | 'nonzero-exit' | 'agent-error';
+    /** A human-readable explanation, taken from the agent's output where there is one. */
+    detail: string;
+}
+/** Everything a run produced: normalized fields plus the untouched raw output. */
+export interface AgentResult extends ParsedOutput {
+    ok: boolean;
+    exitCode: number | null;
+    durationMs: number;
+    error?: CallError | undefined;
+    /** The exact invocation that ran — argv, env additions, notes, spec. */
+    planned: PlannedCall;
+    /** Raw process output, always preserved. */
+    raw: RawProcessOutput;
+    /** Normalized transcript, when `captureConversation` was requested. */
+    conversation?: Conversation | undefined;
+}
+/** Per-run options for `callAgent`, separate from the spec. */
+export interface CallOptions {
+    /** Also lift the transcript into the normalized conversation model. */
+    captureConversation?: boolean | undefined;
+    /** Abort the run early: kills the child, or skips the spawn if already aborted. */
+    signal?: AbortSignal | undefined;
+}
+/**
+ * Plan a call without running it: the exact argv, stdin, env, temp files,
+ * and capability notes the adapter would use. Pure and side-effect free.
+ *
+ * @throws Whatever the adapter's `plan` throws: see `templateAdapter`'s
+ * `@throws`; and `customAdapter` lets its `args` function throw.
+ */
+export declare function planCall(adapter: AgentAdapter, spec: AgentCallSpec): PlannedCall;
+/**
+ * Translate the spec through the adapter, run the CLI, normalize the result.
+ * Never throws on agent failure: a failed run returns `ok: false` with an
+ * `error`.
+ *
+ * Runs the child in its own process group and kills the group on timeout or
+ * abort, so it needs POSIX process groups (Linux, macOS). The child inherits
+ * the parent's environment plus `spec.env`.
+ *
+ * Because the agent has its own process group, a terminal Ctrl+C or a kill of
+ * the host does not reach it, and it keeps running. A host that can be
+ * interrupted must pass a `signal` and abort it from its own SIGINT/SIGTERM
+ * handler. The runner installs no exit handlers.
+ *
+ * @throws The returned promise rejects, rather than resolving `ok: false`,
+ * when planning throws (see {@link planCall}), when a `TempFile.name` is not a
+ * plain file name (empty, or holding `/`, `\` or `..`), or when the per-call
+ * temp directory cannot be created or written. A directory that was made is
+ * removed. A parser that throws on the output does not reject: the result is
+ * `ok: false` with reason `agent-error`.
+ */
+export declare function callAgent(adapter: AgentAdapter, spec: AgentCallSpec, options?: CallOptions): Promise<AgentResult>;

package/dist/run.js

@@ -0,0 +1,172 @@
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { TMP_TOKEN } from './plan.js';
+import { spawnCollect } from './spawn.js';
+/**
+ * Plan a call without running it: the exact argv, stdin, env, temp files,
+ * and capability notes the adapter would use. Pure and side-effect free.
+ *
+ * @throws Whatever the adapter's `plan` throws: see `templateAdapter`'s
+ * `@throws`; and `customAdapter` lets its `args` function throw.
+ */
+export function planCall(adapter, spec) {
+    return adapter.plan(spec);
+}
+/**
+ * Translate the spec through the adapter, run the CLI, normalize the result.
+ * Never throws on agent failure: a failed run returns `ok: false` with an
+ * `error`.
+ *
+ * Runs the child in its own process group and kills the group on timeout or
+ * abort, so it needs POSIX process groups (Linux, macOS). The child inherits
+ * the parent's environment plus `spec.env`.
+ *
+ * Because the agent has its own process group, a terminal Ctrl+C or a kill of
+ * the host does not reach it, and it keeps running. A host that can be
+ * interrupted must pass a `signal` and abort it from its own SIGINT/SIGTERM
+ * handler. The runner installs no exit handlers.
+ *
+ * @throws The returned promise rejects, rather than resolving `ok: false`,
+ * when planning throws (see {@link planCall}), when a `TempFile.name` is not a
+ * plain file name (empty, or holding `/`, `\` or `..`), or when the per-call
+ * temp directory cannot be created or written. A directory that was made is
+ * removed. A parser that throws on the output does not reject: the result is
+ * `ok: false` with reason `agent-error`.
+ */
+export async function callAgent(adapter, spec, options = {}) {
+    const planned = adapter.plan(spec);
+    const raw = await execute(planned, spec, options.signal);
+    let error;
+    if (raw.exitCode === null && !raw.timedOut) {
+        error =
+            raw.signal === undefined
+                ? { reason: 'spawn-failed', detail: raw.stderr.trim() }
+                : {
+                    reason: 'nonzero-exit',
+                    detail: `${planned.argv[0]} was killed by signal ${raw.signal}: ${raw.stderr.trim().slice(0, 500)}`,
+                };
+    }
+    else if (raw.timedOut) {
+        error = {
+            reason: 'timeout',
+            detail: raw.cutShortBy === 'abort'
+                ? 'aborted by the caller'
+                : `killed after ${spec.timeoutMs ?? 0}ms`,
+        };
+    }
+    let parsed = { text: raw.stdout.trim() };
+    if (error === undefined) {
+        try {
+            parsed = adapter.parseResult(planned, raw);
+        }
+        catch (err) {
+            error = {
+                reason: 'agent-error',
+                detail: `the adapter's parser threw: ${errorMessage(err)}`,
+            };
+        }
+    }
+    if (error === undefined && raw.exitCode !== 0) {
+        const stderrTail = raw.stderr.trim().slice(0, 500);
+        error = {
+            reason: 'nonzero-exit',
+            detail: [
+                parsed.errorDetail,
+                stderrTail === ''
+                    ? `${planned.argv[0]} exited ${raw.exitCode}`
+                    : `${planned.argv[0]} exited ${raw.exitCode}: ${stderrTail}`,
+            ]
+                .filter((part) => part !== undefined && part !== '')
+                .join('; '),
+        };
+    }
+    else if (error === undefined && parsed.isError === true) {
+        error = {
+            reason: 'agent-error',
+            detail: parsed.errorDetail ?? 'the agent reported an error',
+        };
+    }
+    const result = {
+        ...parsed,
+        ok: error === undefined,
+        exitCode: raw.exitCode,
+        durationMs: raw.durationMs,
+        error,
+        planned,
+        raw,
+    };
+    if (options.captureConversation === true && adapter.toConversation) {
+        try {
+            result.conversation = adapter.toConversation(planned, raw);
+        }
+        catch (err) {
+            result.ok = false;
+            result.error ??= {
+                reason: 'agent-error',
+                detail: `the adapter's parser threw: ${errorMessage(err)}`,
+            };
+        }
+    }
+    return result;
+}
+function isPlainFileName(name) {
+    return name !== '' && !name.includes('/') && !name.includes('\\') && !name.includes('..');
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function execute(planned, spec, signal) {
+    for (const file of planned.tempFiles) {
+        if (!isPlainFileName(file.name)) {
+            throw new Error(`temp file name ${JSON.stringify(file.name)} is not a plain file name`);
+        }
+    }
+    let tempDir;
+    if (planned.tempFiles.length > 0) {
+        tempDir = await mkdtemp(join(tmpdir(), 'agent-call-'));
+    }
+    try {
+        if (tempDir !== undefined) {
+            for (const file of planned.tempFiles) {
+                await writeFile(join(tempDir, file.name), file.content, 'utf8');
+            }
+        }
+        const resolveTmp = (value) => tempDir === undefined ? value : value.replaceAll(TMP_TOKEN, tempDir);
+        const argv = planned.argv.map(resolveTmp);
+        const env = { ...process.env };
+        for (const [key, value] of Object.entries(planned.env)) {
+            env[key] = resolveTmp(value);
+        }
+        const startedAt = Date.now();
+        const raw = await spawnCollect(argv, {
+            stdin: planned.stdin,
+            cwd: planned.cwd,
+            env,
+            timeoutMs: spec.timeoutMs,
+            signal,
+        });
+        raw.durationMs = Date.now() - startedAt;
+        if (tempDir !== undefined) {
+            const files = {};
+            for (const file of planned.tempFiles) {
+                if (file.readBack !== true)
+                    continue;
+                try {
+                    files[file.name] = await readFile(join(tempDir, file.name), 'utf8');
+                }
+                catch {
+                    // The CLI may not have written it (e.g. errored before finishing).
+                }
+            }
+            if (Object.keys(files).length > 0)
+                raw.files = files;
+        }
+        return raw;
+    }
+    finally {
+        if (tempDir !== undefined) {
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    }
+}

package/dist/spawn.d.ts

@@ -0,0 +1,10 @@
+import type { RawProcessOutput } from './adapters/types.js';
+export interface SpawnOptions {
+    stdin?: string | undefined;
+    cwd?: string | undefined;
+    env: NodeJS.ProcessEnv;
+    timeoutMs?: number | undefined;
+    signal?: AbortSignal | undefined;
+}
+/** Spawn, collect output, honor timeout and abort. @internal */
+export declare function spawnCollect(argv: string[], options: SpawnOptions): Promise<RawProcessOutput>;

package/dist/spawn.js

@@ -0,0 +1,143 @@
+import { spawn } from 'node:child_process';
+/** Grace period between SIGTERM and SIGKILL on timeout/abort. */
+const KILL_GRACE_MS = 5_000;
+/** Spawn, collect output, honor timeout and abort. @internal */
+export function spawnCollect(argv, options) {
+    return new Promise((resolve) => {
+        const [binary, ...args] = argv;
+        if (binary === undefined) {
+            resolve({
+                stdout: '',
+                stderr: 'empty argv',
+                exitCode: null,
+                durationMs: 0,
+                timedOut: false,
+            });
+            return;
+        }
+        // An already-aborted signal never fires `abort` again, so it has to be
+        // honored before spawn — otherwise the agent runs the full turn. The
+        // result mirrors a mid-run abort: cut short, with no exit code.
+        if (options.signal?.aborted === true) {
+            resolve({
+                stdout: '',
+                stderr: '',
+                exitCode: null,
+                durationMs: 0,
+                timedOut: true,
+                cutShortBy: 'abort',
+            });
+            return;
+        }
+        // Raw `node:child_process`, not the command seam: the package stays
+        // dependency-free and this manages a long-lived process group (D-07).
+        const child = spawn(binary, args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            // Own process group, so a timeout/abort can kill the whole tree. Without
+            // it, a shell child (e.g. `sh -c "sleep 30"`) leaves its grandchild
+            // orphaned holding the stdio pipe open, and `close` never fires — the
+            // call hangs until the real command ends instead of honoring timeoutMs.
+            detached: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let cutShortBy;
+        let stdinError;
+        let settled = false;
+        let killTimer;
+        let graceTimer;
+        const killTree = (signal) => {
+            const pid = child.pid;
+            try {
+                // Negative pid targets the whole process group (child is a group
+                // leader via `detached`), so grandchildren die too and release the
+                // stdio pipe. Fall back to a direct kill if the group is already gone
+                // or the platform lacks process groups.
+                if (pid !== undefined)
+                    process.kill(-pid, signal);
+                else
+                    child.kill(signal);
+            }
+            catch {
+                try {
+                    child.kill(signal);
+                }
+                catch {
+                    /* already exited */
+                }
+            }
+        };
+        const terminate = () => {
+            if (graceTimer !== undefined)
+                return;
+            killTree('SIGTERM');
+            graceTimer = setTimeout(() => killTree('SIGKILL'), KILL_GRACE_MS);
+        };
+        if (options.timeoutMs !== undefined && options.timeoutMs > 0) {
+            killTimer = setTimeout(() => {
+                timedOut = true;
+                cutShortBy ??= 'timeout';
+                terminate();
+            }, options.timeoutMs);
+        }
+        const onAbort = () => {
+            timedOut = true;
+            cutShortBy ??= 'abort';
+            terminate();
+        };
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        const settle = (exitCode, spawnError, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            if (killTimer !== undefined)
+                clearTimeout(killTimer);
+            if (graceTimer !== undefined)
+                clearTimeout(graceTimer);
+            options.signal?.removeEventListener('abort', onAbort);
+            if (spawnError !== undefined && stderr === '') {
+                stderr = spawnError.message;
+            }
+            resolve({
+                stdout,
+                stderr,
+                exitCode,
+                durationMs: 0,
+                timedOut,
+                cutShortBy,
+                stdinError,
+                signal: signal ?? undefined,
+            });
+        };
+        // Decode through the stream, not per chunk: a UTF-8 sequence straddling
+        // two reads must be held over the boundary instead of becoming two U+FFFD.
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', (err) => settle(null, err));
+        child.on('close', (code, signal) => settle(code, undefined, signal));
+        // The child may exit before draining stdin (bad flag, auth failure, or a
+        // kill from the timeout/abort path), which fails the write with EPIPE.
+        // Without a listener that stream error is an uncaught exception that takes
+        // the host process down. It is recorded rather than dropped: the failure
+        // means the agent saw a truncated prompt, and nothing else reveals that
+        // when the child still exits 0. Recorded at `settle` so the diagnostic
+        // rides on the resolved value; node closes stdin before emitting `close`,
+        // so the error always lands first.
+        child.stdin.on('error', (err) => {
+            stdinError ??= err.message;
+        });
+        if (options.stdin !== undefined) {
+            child.stdin.write(options.stdin);
+        }
+        child.stdin.end();
+    });
+}

package/dist/spec.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The canonical, agent-agnostic description of one headless agent call.
+ *
+ * A spec says WHAT you want — prompt, permission posture, context, output
+ * shape, session behavior — never HOW a particular CLI expresses it. Each
+ * built-in adapter translates the spec into a concrete invocation on a
+ * best-effort basis and records every approximation as a `CapabilityNote` (see
+ * plan.ts). Custom and template adapters note the fields they fold into the prompt and
+ * `permissions.mode`; any other field the `args` builder leaves out is not noted.
+ */
+import type { EffortLevel } from './models.js';
+/** Adapters shipped with this package. Custom adapters may use any name. */
+export type AgentName = 'claude' | 'codex' | 'antigravity' | 'opencode';
+/**
+ * Canonical permission posture, ordered from most to least restricted.
+ *
+ * - `read-only`  — the agent may inspect but not mutate anything.
+ * - `default`    — whatever the agent's own default posture is.
+ * - `edits`      — file edits are pre-approved; shell/network still gated
+ *                  (gated means denied under headless runs — nothing prompts).
+ * - `full-auto`  — edits and workspace-scoped commands pre-approved, inside
+ *                  whatever sandbox the agent offers.
+ * - `bypass`     — skip all approvals and sandboxing. Dangerous; intended for
+ *                  externally sandboxed environments only.
+ */
+export type PermissionMode = 'read-only' | 'default' | 'edits' | 'full-auto' | 'bypass';
+/** Permission posture for a call: a canonical mode, plus per-tool rules where the CLI has them. */
+export interface PermissionSpec {
+    mode?: PermissionMode | undefined;
+    /**
+     * Tool patterns to pre-approve. Passed through verbatim where the agent
+     * supports tool rules (claude's `--allowedTools "Bash(git *) Edit"`);
+     * recorded as dropped by the other built-in adapters.
+     */
+    allowTools?: string[] | undefined;
+    /** Tool patterns to deny. Same passthrough semantics as `allowTools`. */
+    denyTools?: string[] | undefined;
+}
+/** What the agent should know about beyond the prompt: files, directories, free text. */
+export interface ContextSpec {
+    /**
+     * Files the agent should consider. Attached natively where the CLI supports
+     * it (opencode `-f`), otherwise emulated with a prompt preamble that lists
+     * the paths (and `@path` references for agents with @-inclusion syntax).
+     */
+    files?: string[] | undefined;
+    /** Extra directories the agent may access (`--add-dir` and friends). */
+    dirs?: string[] | undefined;
+    /** Freeform context prepended to the prompt on every agent. */
+    text?: string | undefined;
+}
+/** The shape of the CLI's output; see {@link OutputSpec.format}. */
+export type OutputFormat = 'text' | 'json' | 'stream-json';
+/** The output shape a call asks for: a format, and optionally a JSON Schema for the answer. */
+export interface OutputSpec {
+    /**
+     * - `text`        — final answer as plain text.
+     * - `json`        — one machine-readable envelope with metadata.
+     * - `stream-json` — line-delimited JSON events as the run progresses.
+     *
+     * When omitted, adapters default to their richest aggregate format so
+     * usage/cost/session metadata can be captured; `AgentResult.text` always
+     * carries the final answer regardless.
+     */
+    format?: OutputFormat | undefined;
+    /**
+     * JSON Schema the final answer must satisfy. Native where supported
+     * (claude `--json-schema`, codex `--output-schema`), otherwise emulated by
+     * appending a strict respond-only-with-JSON instruction to the prompt.
+     * The parsed value lands in `AgentResult.structured`.
+     */
+    schema?: Record<string, unknown> | undefined;
+}
+/** Session behaviour: pin an id, resume, continue the last session, or keep the run off disk. */
+export interface SessionSpec {
+    /** Pin the new session's id (claude only). */
+    id?: string | undefined;
+    /** Resume an existing session/thread by id. */
+    resume?: string | undefined;
+    /** Resume the most recent session instead of naming one. */
+    continueLast?: boolean | undefined;
+    /** Set false to keep the run off disk where supported (default: agent's own). */
+    persist?: boolean | undefined;
+}
+/** MCP servers to expose to the agent for this call. */
+export interface McpSpec {
+    /**
+     * MCP servers to expose to the agent, in the common `mcpServers` config
+     * shape: name → `{command, args?, env?}` or `{url}`. Native on claude
+     * (`--mcp-config`), rendered to `-c mcp_servers.*` overrides on codex,
+     * config-file-only (dropped, with a note) on antigravity/opencode.
+     */
+    servers?: Record<string, Record<string, unknown>> | undefined;
+    /** Use ONLY these servers, ignoring user/project config (claude only). */
+    strict?: boolean | undefined;
+}
+/**
+ * Plugins for this session only (claude only). `dirs` load with
+ * `--plugin-dir`; `disable` lists installed plugin ids (`name@marketplace`)
+ * turned off through `--settings`.
+ */
+export interface PluginSpec {
+    dirs: string[];
+    disable: string[];
+}
+/** The canonical call. Only `prompt` is required. */
+export interface AgentCallSpec {
+    prompt: string;
+    /** Concrete model id or alias for the target agent, passed through as given. */
+    model?: string | undefined;
+    effort?: EffortLevel | undefined;
+    mcp?: McpSpec | undefined;
+    plugins?: PluginSpec | undefined;
+    /** Replace the agent's system prompt (native on claude; else emulated). */
+    systemPrompt?: string | undefined;
+    /** Append to the agent's system prompt (native on claude; else emulated). */
+    appendSystemPrompt?: string | undefined;
+    permissions?: PermissionSpec | undefined;
+    context?: ContextSpec | undefined;
+    output?: OutputSpec | undefined;
+    session?: SessionSpec | undefined;
+    /** Hard dollar cap where supported (claude `--max-budget-usd`). */
+    budgetUsd?: number | undefined;
+    /** Working directory for the agent process. */
+    cwd?: string | undefined;
+    /** Extra environment variables for the agent process. */
+    env?: Record<string, string> | undefined;
+    /** Kill the process after this long (SIGTERM, then SIGKILL after 5s). */
+    timeoutMs?: number | undefined;
+    /** Escape hatch: appended verbatim to the built argv, after everything. */
+    extraArgs?: string[] | undefined;
+}

package/dist/spec.js

@@ -0,0 +1,11 @@
+/**
+ * The canonical, agent-agnostic description of one headless agent call.
+ *
+ * A spec says WHAT you want — prompt, permission posture, context, output
+ * shape, session behavior — never HOW a particular CLI expresses it. Each
+ * built-in adapter translates the spec into a concrete invocation on a
+ * best-effort basis and records every approximation as a `CapabilityNote` (see
+ * plan.ts). Custom and template adapters note the fields they fold into the prompt and
+ * `permissions.mode`; any other field the `args` builder leaves out is not noted.
+ */
+export {};