@alpacakit/agents 0.1.0-beta.19

package/dist/kernel/classify.js

@@ -0,0 +1,136 @@
+/**
+ * Failure classification (design "Errors"): the matcher contract, the
+ * combinators custom agents build on, cooldown-hint parsing, and the
+ * generic quota / auth free-text matchers shared by every agent
+ * (v1 F3/F5 signals, kept verbatim). Provider-specific matchers live on
+ * their adapter modules and enter via the blueprints' `classify` arrays.
+ */
+import { AGENT_ERROR_CODE, AUTH_FAILURE_REASON } from "../core/error.js";
+function combinedText(evidence) {
+    return `${evidence.stderr}\n${evidence.stdout}`;
+}
+const ISO_TIMESTAMP = /\b(20\d{2}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)\b/;
+const EPOCH_AFTER_RESET = /\b(?:reset|retry[- ]after)\b[^0-9]*(\d{10,13})\b/i;
+const RETRY_AFTER_SECONDS = /retry[- ]after[: ]+(\d+)(?:\s*(?:seconds?|secs?|s))?/i;
+const RELATIVE_IN_UNITS = /(?:try again|retry|reset)[^\n]*?\bin\s+(\d+)\s*(seconds?|secs?|minutes?|mins?|hours?|hrs?)/i;
+function unitMultiplierMs(unit) {
+    if (unit.startsWith("hour") || unit.startsWith("hr")) {
+        return 3_600_000;
+    }
+    if (unit.startsWith("min")) {
+        return 60_000;
+    }
+    return 1_000;
+}
+export function parseEpochTimestamp(value) {
+    const ms = value >= 1e12 ? value : value * 1000;
+    return new Date(ms).toISOString();
+}
+/**
+ * Cooldown-time parsing (F3): ISO timestamps, epoch digits after
+ * reset/retry-after, "retry after N s", and relative "in N minutes".
+ */
+export function parseCooldownHint(text, now) {
+    const iso = text.match(ISO_TIMESTAMP);
+    if (iso?.[1] !== undefined) {
+        return iso[1];
+    }
+    const epoch = text.match(EPOCH_AFTER_RESET);
+    if (epoch?.[1] !== undefined) {
+        return parseEpochTimestamp(Number(epoch[1]));
+    }
+    const seconds = text.match(RETRY_AFTER_SECONDS);
+    if (seconds?.[1] !== undefined) {
+        return new Date(now + Number(seconds[1]) * 1000).toISOString();
+    }
+    const relative = text.match(RELATIVE_IN_UNITS);
+    if (relative?.[1] !== undefined && relative[2] !== undefined) {
+        return new Date(now + Number(relative[1]) * unitMultiplierMs(relative[2])).toISOString();
+    }
+    return null;
+}
+/** Matcher combinator: classify as quota when the pattern matches. */
+export function quotaIf(pattern) {
+    return (evidence) => {
+        const text = combinedText(evidence);
+        if (!pattern.test(text)) {
+            return null;
+        }
+        return {
+            code: AGENT_ERROR_CODE.quota,
+            message: "Provider quota or rate limit reached",
+            data: { cooldownUntil: parseCooldownHint(text, evidence.now) },
+        };
+    };
+}
+/** Matcher combinator: classify as capacity when the pattern matches. */
+export function capacityIf(pattern) {
+    return (evidence) => {
+        const text = combinedText(evidence);
+        if (!pattern.test(text)) {
+            return null;
+        }
+        return {
+            code: AGENT_ERROR_CODE.capacity,
+            message: "Provider is at capacity",
+            data: { cooldownUntil: parseCooldownHint(text, evidence.now) },
+        };
+    };
+}
+const AUTH_REASON_MARKERS = [
+    [/\brefresh_token_reused\b/i, AUTH_FAILURE_REASON.refreshTokenReused],
+    [/\btoken_invalidated\b/i, AUTH_FAILURE_REASON.tokenInvalidated],
+    [/\binvalid api key\b/i, AUTH_FAILURE_REASON.invalidApiKey],
+    [/\binvalid token\b/i, AUTH_FAILURE_REASON.invalidToken],
+    [
+        /\bauth(?:entication)? invalid\b/i,
+        AUTH_FAILURE_REASON.authenticationFailed,
+    ],
+    [/\bauthentication failed\b/i, AUTH_FAILURE_REASON.authenticationFailed],
+    [/not logged in|please log ?in/i, AUTH_FAILURE_REASON.notLoggedIn],
+    [/\bunauthorized\b/i, AUTH_FAILURE_REASON.unauthorized],
+    [/\bforbidden\b/i, AUTH_FAILURE_REASON.forbidden],
+];
+export function detectAuthReason(text) {
+    for (const [pattern, reason] of AUTH_REASON_MARKERS) {
+        if (pattern.test(text)) {
+            return reason;
+        }
+    }
+    return AUTH_FAILURE_REASON.unknown;
+}
+/** Matcher combinator: classify as auth when the pattern matches. */
+export function authIf(pattern) {
+    return (evidence) => {
+        const text = combinedText(evidence);
+        const match = text.match(pattern);
+        if (match === null) {
+            return null;
+        }
+        return {
+            code: AGENT_ERROR_CODE.auth,
+            message: "Agent credentials are missing or invalid",
+            data: { reason: detectAuthReason(text), detail: match[0] },
+        };
+    };
+}
+/** v1 free-text signal lists, kept verbatim (lowercased substrings). */
+const QUOTA_TEXT = /quota exhausted|quota is exhausted|rate limit|retry-after|retry after|try again in|too many requests|insufficient balance|usage limit/i;
+const AUTH_TEXT = /authentication failed|auth invalid|invalid api key|invalid token|not logged in|please login|please log in|unauthorized|forbidden|refresh_token_reused|token_invalidated/i;
+/**
+ * Shared matchers, consulted after agent-specific ones. Provider-specific
+ * structured quota and capacity text matchers live on built-in blueprints.
+ */
+export const sharedFailureMatchers = [
+    quotaIf(QUOTA_TEXT),
+    authIf(AUTH_TEXT),
+];
+export function classifyFailure(matchers, evidence) {
+    for (const matcher of matchers) {
+        const classified = matcher(evidence);
+        if (classified !== null) {
+            return classified;
+        }
+    }
+    return null;
+}

package/dist/kernel/cli-agent.d.ts

@@ -0,0 +1,62 @@
+/**
+ * CLI agent blueprint (design "Kernel"): the shared machinery for agents
+ * that are CLI subprocesses — command resolution, stdin prompt delivery,
+ * NDJSON line parsing, abort handling with SIGTERM→SIGKILL escalation,
+ * early-completion detection, and failure classification. `claude` and
+ * `codex` are built with this factory; a third-party adapter is the same
+ * ~20-line exercise.
+ */
+import type { LoginCapability } from "../auth/login.js";
+import type { MaterialHandlers } from "../auth/material.js";
+import type { AgentEvent, RunUsage } from "../core/run.js";
+import type { DoctorCapability, McpCapability, SkillsCapability } from "../host/capabilities.js";
+import { type FailureMatcher } from "./classify.js";
+import type { AgentDefinition } from "./definition.js";
+import type { ResolvedSandbox, SandboxMode } from "./options.js";
+export type ArgContext = {
+    readonly model: string | null;
+    readonly effort: string | null;
+    readonly workspace: string;
+};
+export type OutputState = {
+    readonly stdout: string;
+    readonly stderr: string;
+    messages: readonly string[];
+};
+export type CliResultCapture = {
+    readonly text: string | null;
+    readonly usage: RunUsage | null;
+};
+/** Keyed handler record (principle 7): key presence = mode supported. */
+export type SandboxArgBuilders = {
+    readonly [M in SandboxMode]?: (sandbox: Readonly<Extract<ResolvedSandbox, {
+        mode: M;
+    }>>, ctx: ArgContext) => readonly string[];
+};
+export type CliAgentBlueprint<Id extends string = string> = {
+    readonly id: Id;
+    readonly command: string;
+    readonly args: SandboxArgBuilders;
+    /** Parse one NDJSON stdout line into events; [] when none (rule 3). */
+    readonly parseLine?: (line: string) => readonly AgentEvent[];
+    /** Capture the final normalized text / usage from a result line. */
+    readonly parseResult?: (line: string) => CliResultCapture | null;
+    /** Early completion (E9): arm the grace timer when this returns true. */
+    readonly detectCompletion?: (line: string, state: OutputState) => boolean;
+    readonly completionGraceMs?: number;
+    /** Agent-specific matchers, consulted before the shared chain. */
+    readonly classify?: readonly FailureMatcher[];
+    /**
+     * Matchers scanned over exit-0 output (F6). Only unambiguous,
+     * structured signals belong here — free-text matchers on successful
+     * output would misclassify runs that merely talk about limits.
+     */
+    readonly classifyOnSuccess?: readonly FailureMatcher[];
+    readonly auth?: MaterialHandlers;
+    readonly login?: LoginCapability;
+    readonly doctor?: DoctorCapability;
+    readonly skills?: SkillsCapability;
+    readonly mcp?: McpCapability;
+};
+export declare function defineCliAgent<const Id extends string>(blueprint: CliAgentBlueprint<Id>): AgentDefinition<Id>;
+//# sourceMappingURL=cli-agent.d.ts.map

package/dist/kernel/cli-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-agent.d.ts","sourceRoot":"","sources":["../../src/kernel/cli-agent.ts"],"names":[],"mappings":"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"}

package/dist/kernel/cli-agent.js

@@ -0,0 +1,281 @@
+/**
+ * CLI agent blueprint (design "Kernel"): the shared machinery for agents
+ * that are CLI subprocesses — command resolution, stdin prompt delivery,
+ * NDJSON line parsing, abort handling with SIGTERM→SIGKILL escalation,
+ * early-completion detection, and failure classification. `claude` and
+ * `codex` are built with this factory; a third-party adapter is the same
+ * ~20-line exercise.
+ */
+import { AGENT_ERROR_CODE, AgentError, NOT_AVAILABLE_CAUSE, } from "../core/error.js";
+import { redactSecrets } from "../core/redact.js";
+import { AGENT_EVENT_TYPE, RUN_COMPLETION_KIND } from "../core/run.js";
+import { OUTPUT_CHANNEL, PROCESS_SIGNAL, } from "../core/values.js";
+import { DOCTOR_CHECK_STATUS } from "../host/capabilities.js";
+import { classifyFailure, sharedFailureMatchers, } from "./classify.js";
+import { requireKeyedHandler } from "./keyed.js";
+const SIGKILL_ESCALATION_MS = 5_000;
+const DEFAULT_COMPLETION_GRACE_MS = 1_000;
+const RAW_OUTPUT_CAP_BYTES = 10 * 1024 * 1024;
+const OUTPUT_TAIL_CHARS = 2_000;
+const CLASSIFIED_EVIDENCE_TAIL_CHARS = 2_000;
+function appendCapped(current, text) {
+    const combined = current + text;
+    return combined.length > RAW_OUTPUT_CAP_BYTES
+        ? combined.slice(combined.length - RAW_OUTPUT_CAP_BYTES)
+        : combined;
+}
+class CliOutput {
+    hooks;
+    stdout = "";
+    stderr = "";
+    resultText = null;
+    usage = null;
+    completionDetected = false;
+    messages = [];
+    pendingLine = "";
+    constructor(hooks) {
+        this.hooks = hooks;
+    }
+    append(channel, text) {
+        const events = [
+            { type: AGENT_EVENT_TYPE.output, channel, chunk: text },
+        ];
+        if (channel === OUTPUT_CHANNEL.stderr) {
+            this.stderr = appendCapped(this.stderr, text);
+            return events;
+        }
+        this.stdout = appendCapped(this.stdout, text);
+        this.pendingLine += text;
+        const lines = this.pendingLine.split(/\r?\n/);
+        this.pendingLine = lines.pop() ?? "";
+        for (const line of lines) {
+            events.push(...this.handleLine(line));
+        }
+        return events;
+    }
+    flush() {
+        const line = this.pendingLine;
+        this.pendingLine = "";
+        return this.handleLine(line);
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (trimmed === "") {
+            return [];
+        }
+        const events = this.hooks.parseLine(trimmed);
+        for (const event of events) {
+            if (event.type === AGENT_EVENT_TYPE.message) {
+                this.messages.push(event.text);
+            }
+        }
+        const capture = this.hooks.parseResult(trimmed);
+        if (capture !== null) {
+            this.resultText = capture.text ?? this.resultText;
+            this.usage = capture.usage ?? this.usage;
+        }
+        if (!this.completionDetected) {
+            this.completionDetected = this.hooks.detectCompletion(trimmed, {
+                stdout: this.stdout,
+                stderr: this.stderr,
+                messages: this.messages,
+            });
+        }
+        return events;
+    }
+}
+/**
+ * The one seam where a classification becomes observable: yield the
+ * `failure_classified` evidence event onto the run stream, then throw
+ * the matching typed error. Event and error cannot drift apart because
+ * they are born here together.
+ */
+function* raiseClassifiedFailure(classified, agentId, evidence) {
+    const stdoutTail = redactSecrets(evidence.stdout.slice(-CLASSIFIED_EVIDENCE_TAIL_CHARS));
+    const stderrTail = redactSecrets(evidence.stderr.slice(-CLASSIFIED_EVIDENCE_TAIL_CHARS));
+    yield {
+        type: AGENT_EVENT_TYPE.failureClassified,
+        code: classified.code,
+        evidence: {
+            stdoutTail: stdoutTail === "" ? null : stdoutTail,
+            stderrTail: stderrTail === "" ? null : stderrTail,
+            exitCode: evidence.exitCode,
+            signal: evidence.signal,
+        },
+    };
+    throw new AgentError({
+        ...classified,
+        message: redactSecrets(classified.message),
+        agentId,
+        started: true,
+    });
+}
+function* finishCliRun(input) {
+    const { agentId, matchers, successMatchers, output, exit, completion, ctx } = input;
+    const completedByGrace = completion.kind === RUN_COMPLETION_KIND.earlyGrace;
+    if (ctx.signal.aborted) {
+        throw new AgentError({
+            code: AGENT_ERROR_CODE.cancelled,
+            message: "Run aborted",
+            data: { reason: null },
+            agentId,
+            started: true,
+        });
+    }
+    const evidence = {
+        stdout: output.stdout,
+        stderr: output.stderr,
+        exitCode: exit.code,
+        signal: exit.signal,
+        now: ctx.clock.now(),
+    };
+    if (completedByGrace || exit.code === 0) {
+        if (!completedByGrace) {
+            // F6: exit-0 output is still scanned with the blueprint's
+            // success-path matchers.
+            const classified = classifyFailure(successMatchers, evidence);
+            if (classified !== null) {
+                yield* raiseClassifiedFailure(classified, agentId, evidence);
+            }
+        }
+        return {
+            text: output.resultText ?? output.messages.join("\n"),
+            model: null,
+            exit: { code: exit.code, signal: exit.signal, completion },
+            raw: { stdout: output.stdout, stderr: output.stderr },
+            usage: output.usage,
+        };
+    }
+    const classified = classifyFailure(matchers, evidence);
+    if (classified !== null) {
+        yield* raiseClassifiedFailure(classified, agentId, evidence);
+    }
+    const stdoutTail = redactSecrets(output.stdout.slice(-OUTPUT_TAIL_CHARS));
+    const stderrTail = redactSecrets(output.stderr.slice(-OUTPUT_TAIL_CHARS));
+    throw new AgentError({
+        code: AGENT_ERROR_CODE.failed,
+        message: redactSecrets(`Agent "${agentId}" exited with code ${exit.code ?? "null"}${exit.signal === null ? "" : ` (signal ${exit.signal})`}`),
+        data: {
+            exitCode: exit.code,
+            stdoutTail: stdoutTail === "" ? null : stdoutTail,
+            stderrTail: stderrTail === "" ? null : stderrTail,
+        },
+        agentId,
+        started: true,
+    });
+}
+function buildRun(blueprint, hooks, matchers, successMatchers) {
+    const graceMs = blueprint.completionGraceMs ?? DEFAULT_COMPLETION_GRACE_MS;
+    return async function* run(options, ctx) {
+        const argBuilder = requireKeyedHandler(blueprint.args, options.sandbox.mode, blueprint.id, `sandbox mode "${options.sandbox.mode}"`);
+        const command = await ctx.exec.which(blueprint.command, ctx.env);
+        if (command === null) {
+            throw new AgentError({
+                code: AGENT_ERROR_CODE.notAvailable,
+                message: `Command "${blueprint.command}" was not found on PATH`,
+                data: { cause: NOT_AVAILABLE_CAUSE.notInstalled },
+                agentId: blueprint.id,
+            });
+        }
+        const argv = argBuilder(options.sandbox, {
+            model: options.model,
+            effort: options.effort,
+            workspace: options.workspace,
+        });
+        const child = ctx.exec.spawn({
+            command,
+            args: [...argv],
+            cwd: options.workspace,
+            env: ctx.env,
+            stdin: options.prompt,
+        });
+        const output = new CliOutput(hooks);
+        const cancels = [];
+        let completion = { kind: RUN_COMPLETION_KIND.natural };
+        const completionTimer = { graceArmed: false };
+        const onAbort = () => {
+            child.kill(PROCESS_SIGNAL.sigterm);
+            cancels.push(ctx.clock.setTimeout(() => child.kill(PROCESS_SIGNAL.sigkill), SIGKILL_ESCALATION_MS));
+        };
+        if (ctx.signal.aborted) {
+            onAbort();
+        }
+        else {
+            ctx.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        try {
+            for await (const chunk of child.chunks) {
+                yield* output.append(chunk.channel, chunk.text);
+                if (output.completionDetected && !completionTimer.graceArmed) {
+                    completionTimer.graceArmed = true;
+                    cancels.push(ctx.clock.setTimeout(() => {
+                        completion = { kind: RUN_COMPLETION_KIND.earlyGrace };
+                        child.kill(PROCESS_SIGNAL.sigterm);
+                    }, graceMs));
+                }
+            }
+            yield* output.flush();
+            const exit = await child.exit;
+            return yield* finishCliRun({
+                agentId: blueprint.id,
+                matchers,
+                successMatchers,
+                output,
+                exit,
+                completion,
+                ctx,
+            });
+        }
+        finally {
+            ctx.signal.removeEventListener("abort", onAbort);
+            for (const cancel of cancels.splice(0)) {
+                cancel();
+            }
+        }
+    };
+}
+export function defineCliAgent(blueprint) {
+    const hooks = {
+        parseLine: blueprint.parseLine?.bind(blueprint) ?? (() => []),
+        parseResult: blueprint.parseResult?.bind(blueprint) ?? (() => null),
+        detectCompletion: blueprint.detectCompletion?.bind(blueprint) ?? (() => false),
+    };
+    const matchers = [...(blueprint.classify ?? []), ...sharedFailureMatchers];
+    const successMatchers = blueprint.classifyOnSuccess ?? [];
+    const doctor = blueprint.doctor ??
+        {
+            probe: async (ctx) => {
+                const command = await ctx.exec.which(blueprint.command, ctx.env);
+                return {
+                    available: command !== null,
+                    checks: [
+                        {
+                            id: "command-on-path",
+                            status: command === null
+                                ? DOCTOR_CHECK_STATUS.fail
+                                : DOCTOR_CHECK_STATUS.pass,
+                            detail: command,
+                        },
+                    ],
+                };
+            },
+        };
+    const definition = {
+        id: blueprint.id,
+        run: buildRun(blueprint, hooks, matchers, successMatchers),
+        doctor,
+    };
+    if (blueprint.auth !== undefined) {
+        definition.auth = { materials: blueprint.auth };
+    }
+    if (blueprint.login !== undefined) {
+        definition.login = blueprint.login;
+    }
+    if (blueprint.skills !== undefined) {
+        definition.skills = blueprint.skills;
+    }
+    if (blueprint.mcp !== undefined) {
+        definition.mcp = blueprint.mcp;
+    }
+    return definition;
+}

package/dist/kernel/cli-login.d.ts

@@ -0,0 +1,13 @@
+import { type LoginContext, type LoginRequest, type LoginRun } from "../auth/login.js";
+import { type EnvPatch } from "../core/env.js";
+type CliLoginCommandOptions = {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly envPatch: EnvPatch;
+    readonly request: Omit<LoginRequest, "signal">;
+    readonly ctx: LoginContext;
+    readonly timeoutMs?: number;
+};
+export declare function cliLoginCommand(options: CliLoginCommandOptions): LoginRun;
+export {};
+//# sourceMappingURL=cli-login.d.ts.map

package/dist/kernel/cli-login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-login.d.ts","sourceRoot":"","sources":["../../src/kernel/cli-login.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EAIjB,KAAK,YAAY,EACjB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAC;AAM1B,OAAO,EAAiB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AA8B9D,KAAK,sBAAsB,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;IAC/C,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AA+FF,wBAAuB,eAAe,CACpC,OAAO,EAAE,sBAAsB,GAC9B,QAAQ,CA+GV"}