@agentproto/driver-agent-cli 0.1.0-alpha.0

package/dist/manifest/index.d.ts

@@ -0,0 +1,22 @@
+import { k as AgentCliFrontmatter, A as AgentCliHandle } from '../schema-CdCb4gW1.js';
+export { x as agentCliFrontmatterSchema } from '../schema-CdCb4gW1.js';
+import '@agentproto/acp';
+import 'zod';
+
+/**
+ * AIP-45 AGENT-CLI.md sidecar parser + manifest-to-handle constructor.
+ *
+ * Mirror of `@agentproto/skill/manifest` and `@agentproto/acp/manifest`:
+ * the .md provides metadata; the TS runtime supplies any spec-specific
+ * runtime bits. Both inputs end up in `defineAgentCli` so the cross-AIP
+ * invariants run uniformly.
+ */
+
+interface AgentCliManifest {
+    frontmatter: AgentCliFrontmatter;
+    body: string;
+}
+declare function parseAgentCliManifest(source: string): AgentCliManifest;
+declare function agentCliFromManifest(manifest: AgentCliManifest): AgentCliHandle;
+
+export { AgentCliFrontmatter, type AgentCliManifest, agentCliFromManifest, parseAgentCliManifest };

package/dist/manifest/index.mjs

@@ -0,0 +1,28 @@
+import { agentCliFrontmatterSchema, defineAgentCli } from '../chunk-EEIYDRIU.mjs';
+export { agentCliFrontmatterSchema } from '../chunk-EEIYDRIU.mjs';
+import matter from 'gray-matter';
+
+/**
+ * @agentproto/driver-agent-cli v0.1.0-alpha
+ * AIP-45 AGENT-CLI.md `defineAgentCli` reference implementation.
+ */
+function parseAgentCliManifest(source) {
+  const parsed = matter(source);
+  if (Object.keys(parsed.data).length === 0) {
+    throw new Error("parseAgentCliManifest: missing or empty frontmatter");
+  }
+  const result = agentCliFrontmatterSchema.safeParse(parsed.data);
+  if (!result.success) {
+    throw new Error(
+      `parseAgentCliManifest: invalid frontmatter \u2014 ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return { frontmatter: result.data, body: parsed.content };
+}
+function agentCliFromManifest(manifest) {
+  return defineAgentCli(manifest.frontmatter);
+}
+
+export { agentCliFromManifest, parseAgentCliManifest };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/manifest/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/manifest/index.ts"],"names":[],"mappings":";;;;;;;;AAwBO,SAAS,sBAAsB,MAAA,EAAkC;AACtE,EAAA,MAAM,MAAA,GAAS,OAAO,MAAM,CAAA;AAC5B,EAAA,IAAI,OAAO,IAAA,CAAK,MAAA,CAAO,IAAI,CAAA,CAAE,WAAW,CAAA,EAAG;AACzC,IAAA,MAAM,IAAI,MAAM,qDAAqD,CAAA;AAAA,EACvE;AACA,EAAA,MAAM,MAAA,GAAS,yBAAA,CAA0B,SAAA,CAAU,MAAA,CAAO,IAAI,CAAA;AAC9D,EAAA,IAAI,CAAC,OAAO,OAAA,EAAS;AACnB,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,kDAAA,EAAgD,OAAO,KAAA,CAAM,MAAA,CAC1D,IAAI,CAAC,CAAA,KAAM,GAAG,CAAA,CAAE,IAAA,CAAK,KAAK,GAAG,CAAC,KAAK,CAAA,CAAE,OAAO,EAAE,CAAA,CAC9C,IAAA,CAAK,IAAI,CAAC,CAAA;AAAA,KACf;AAAA,EACF;AACA,EAAA,OAAO,EAAE,WAAA,EAAa,MAAA,CAAO,IAAA,EAAM,IAAA,EAAM,OAAO,OAAA,EAAQ;AAC1D;AAEO,SAAS,qBACd,QAAA,EACgB;AAChB,EAAA,OAAO,cAAA,CAAe,SAAS,WAA4C,CAAA;AAC7E","file":"index.mjs","sourcesContent":["/**\n * AIP-45 AGENT-CLI.md sidecar parser + manifest-to-handle constructor.\n *\n * Mirror of `@agentproto/skill/manifest` and `@agentproto/acp/manifest`:\n * the .md provides metadata; the TS runtime supplies any spec-specific\n * runtime bits. Both inputs end up in `defineAgentCli` so the cross-AIP\n * invariants run uniformly.\n */\n\nimport matter from \"gray-matter\"\nimport {\n  agentCliFrontmatterSchema,\n  type AgentCliFrontmatter,\n} from \"../schema.js\"\nimport { defineAgentCli } from \"../define-agent-cli.js\"\nimport type { AgentCliDefinition, AgentCliHandle } from \"../types.js\"\n\nexport { agentCliFrontmatterSchema, type AgentCliFrontmatter }\n\nexport interface AgentCliManifest {\n  frontmatter: AgentCliFrontmatter\n  body: string\n}\n\nexport function parseAgentCliManifest(source: string): AgentCliManifest {\n  const parsed = matter(source)\n  if (Object.keys(parsed.data).length === 0) {\n    throw new Error(\"parseAgentCliManifest: missing or empty frontmatter\")\n  }\n  const result = agentCliFrontmatterSchema.safeParse(parsed.data)\n  if (!result.success) {\n    throw new Error(\n      `parseAgentCliManifest: invalid frontmatter — ${result.error.issues\n        .map((i) => `${i.path.join(\".\")}: ${i.message}`)\n        .join(\"; \")}`,\n    )\n  }\n  return { frontmatter: result.data, body: parsed.content }\n}\n\nexport function agentCliFromManifest(\n  manifest: AgentCliManifest,\n): AgentCliHandle {\n  return defineAgentCli(manifest.frontmatter as unknown as AgentCliDefinition)\n}\n"]}

package/dist/schema-CdCb4gW1.d.ts

@@ -0,0 +1,548 @@
+import { StreamEvent } from '@agentproto/acp';
+import { z } from 'zod';
+
+/**
+ * AIP-45 AgentCliDefinition + AgentCliHandle.
+ *
+ * Mirrors `resources/aip-45/draft/AGENT-CLI.schema.json`. Top-level
+ * fields cover the binary's install / version / auth / sandbox /
+ * protocol surface; `protocol` discriminates between ACP, MCP, and
+ * proprietary adapter arms.
+ */
+
+type AgentCliProtocol = "acp" | "mcp" | "proprietary";
+type AgentCliSessionMode = "ephemeral" | "persistent" | "resumable";
+interface AgentCliInstallMethod {
+    method: "brew" | "apt" | "dnf" | "pacman" | "choco" | "scoop" | "npm" | "pip" | "cargo" | "go" | "curl" | "download" | "vendored";
+    package?: string;
+    url?: string;
+    path?: string;
+    extract_bin?: string;
+    verify_sha256?: string;
+    global?: boolean;
+    user?: boolean;
+    experimental?: boolean;
+}
+interface AgentCliVersionCheck {
+    cmd: string;
+    parse: string;
+    range: string;
+    timeout_ms?: number;
+}
+interface AgentCliAuth {
+    ref?: string;
+    state?: {
+        paths?: string[];
+        env?: string[];
+    };
+    login?: {
+        cmd: string;
+        interactive?: boolean;
+        requires_callback_url?: boolean;
+    };
+    refresh?: {
+        cmd: string;
+        interval_s?: number;
+    };
+    expiry?: {
+        parse?: string;
+        grace_s?: number;
+    };
+}
+interface AgentCliSession {
+    mode?: AgentCliSessionMode;
+    idle_timeout_ms?: number;
+    max_turns?: number;
+    context_carryover?: boolean;
+}
+interface AgentCliModels {
+    default?: string;
+    allowed?: string[];
+    env?: Record<string, string>;
+}
+interface AgentCliCapabilities {
+    streaming?: boolean;
+    tool_calls?: boolean;
+    sub_agents?: boolean;
+    file_io?: boolean;
+    multimodal?: boolean;
+    resumable?: boolean;
+    bidirectional?: boolean;
+}
+/**
+ * AIP-45 mode declaration — a mutually-exclusive operation profile
+ * the CLI exposes. The host picks at most ONE mode per turn via
+ * `OPERATOR.runtime.config.mode`. Mode patches apply AFTER the
+ * manifest's default `bin_args` and BEFORE option patches.
+ */
+interface AgentCliMode {
+    id: string;
+    description?: string;
+    bin_args_append?: string[];
+    env?: Record<string, string>;
+}
+type AgentCliOptionType = "boolean" | "integer" | "string" | "enum";
+/**
+ * AIP-45 option declaration — an independent typed knob. Multiple
+ * options may be active per turn; each option's patch is independent
+ * and applied in declaration order, AFTER mode patches.
+ */
+interface AgentCliOption {
+    id: string;
+    type: AgentCliOptionType;
+    description?: string;
+    /** Required when type === "enum". */
+    enum?: string[];
+    default?: boolean | number | string;
+    /** Inclusive lower bound when type === "integer". */
+    min?: number;
+    /** Inclusive upper bound when type === "integer". */
+    max?: number;
+    /**
+     * Argv template appended when the option has a non-default value.
+     * The literal token `{value}` is replaced with the option's value
+     * (stringified). Use for value-bearing flags like `--model {value}`.
+     */
+    bin_args_template?: string[];
+    /**
+     * Argv appended when type === "boolean" AND value === true. Use for
+     * bare flags like `--auto`.
+     */
+    bin_args_append_when_true?: string[];
+    /**
+     * Env vars to merge when the option has a non-default value. Values
+     * may contain `{value}` for templating.
+     */
+    env?: Record<string, string>;
+}
+/**
+ * Built-in continuation strategy ids. Future custom strategies require
+ * a follow-up AIP that opens this enum. Keep this in lockstep with
+ * `continuationStrategyId` in `AGENT-CLI.schema.json`.
+ */
+type ContinuationStrategyId = "none" | "pinned-session" | "transcript" | "native-resume";
+/**
+ * AIP-45 continuation declaration — declares HOW prior turns reach the
+ * CLI on subsequent invocations. Hosts MUST refuse to dispatch with a
+ * strategy outside `supported`; the operator MAY override `default` via
+ * `OPERATOR.runtime.config.continuation` provided the chosen id is in
+ * `supported`.
+ */
+interface AgentCliContinuation {
+    default: ContinuationStrategyId;
+    supported: ContinuationStrategyId[];
+    pinned_session?: AgentCliPinnedSessionTuning;
+}
+/** Tuning for the `pinned-session` strategy. Ignored by other strategies. */
+interface AgentCliPinnedSessionTuning {
+    /** How long an idle pinned session is kept alive before the driver
+     *  closes it. Applies in addition to the CLI's own
+     *  `session.idle_timeout_ms`. Default 1_800_000 (30 min). */
+    idle_timeout_ms?: number;
+    /**
+     * Composite key that uniquely identifies a pinned session. Default
+     * `["conversation", "operator"]` — different conversations get
+     * different child processes; one operator per conversation reuses
+     * one process across turns.
+     */
+    key_scope?: ContinuationKeyScope[];
+}
+type ContinuationKeyScope = "conversation" | "operator" | "user" | "guild" | "workspace";
+interface AgentCliMcpBlock {
+    command?: string;
+    args?: string[];
+    transport: "stdio" | "http" | "sse";
+    url?: string;
+}
+interface AgentCliRequires {
+    os?: ("darwin" | "linux" | "windows")[];
+    arch?: ("x64" | "arm64" | "x86" | "arm")[];
+    min_disk_mb?: number;
+    min_memory_mb?: number;
+}
+interface AgentCliExample {
+    goal: string;
+    prompt: string;
+    note?: string;
+}
+interface AgentCliDefinition {
+    name: string;
+    id: string;
+    description: string;
+    version: string;
+    bin: string;
+    bin_args?: string[];
+    install: AgentCliInstallMethod[];
+    version_check: AgentCliVersionCheck;
+    auth?: AgentCliAuth;
+    sandbox: string | Record<string, unknown>;
+    runner?: string | Record<string, unknown>;
+    protocol: AgentCliProtocol;
+    /** REQUIRED when protocol=acp. Workspace-relative ref to AIP-44 ACP.md. */
+    acp?: string;
+    /** REQUIRED when protocol=mcp. */
+    mcp?: AgentCliMcpBlock;
+    /** REQUIRED when protocol=proprietary. NPM package implementing AgentCliClient. */
+    adapter?: string;
+    session?: AgentCliSession;
+    models?: AgentCliModels;
+    capabilities?: AgentCliCapabilities;
+    /** AIP-45 modes (mutually-exclusive operation profiles). */
+    modes?: AgentCliMode[];
+    /** AIP-45 options (independent typed knobs). */
+    options?: AgentCliOption[];
+    /** AIP-45 continuation policy (how prior turns reach the CLI). */
+    continuation?: AgentCliContinuation;
+    requires?: AgentCliRequires;
+    examples?: AgentCliExample[];
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+type AgentCliHandle = Readonly<AgentCliDefinition>;
+/**
+ * Connection options handed to a protocol arm by the runner. Sandbox
+ * resolution + secrets injection happen *before* this point — the arm
+ * receives a flat env map and a working dir.
+ */
+interface AgentCliConnectOptions {
+    cwd: string;
+    env: Record<string, string>;
+    abortSignal: AbortSignal;
+    /**
+     * When set, the protocol arm reattaches to the agent's existing
+     * session with this id (ACP `loadSession`, MCP equivalent, or argv
+     * `--resume`) instead of starting a fresh one. The agent decides
+     * the wire mechanics; the host is responsible for having stored the
+     * id from a prior `connect → newSession`.
+     *
+     * Drives the `native-resume` continuation strategy. Arms that don't
+     * support resume MAY ignore this field; the runner won't reject it
+     * because per-protocol semantics aren't visible at this layer.
+     */
+    resumeSessionId?: string;
+}
+/**
+ * Per-turn dispatch shape. Implemented by every protocol arm
+ * (ACP, MCP, proprietary). The runner is the only call site for
+ * these methods; consumers see {@link AgentCliSession} instead.
+ */
+interface AgentCliClient {
+    connect(opts: AgentCliConnectOptions): Promise<void>;
+    send(turnId: string, message: unknown): Promise<void>;
+    events(): AsyncIterable<StreamEvent>;
+    cancel(turnId: string): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * The session id the protocol arm holds. Populated after `connect()`
+     * resolves — for `newSession` calls it's whatever the agent assigned;
+     * for `loadSession` (resume) calls it's the same id the host passed
+     * in. Hosts persist this so a future cold start can resume.
+     *
+     * Empty string before connect or for protocols that don't have a
+     * session concept (proprietary one-shots).
+     */
+    readonly sessionId?: string;
+}
+/**
+ * The runtime handle returned by `defineAgentCli` — call `.start()`
+ * to spawn the binary and obtain a {@link AgentCliRuntimeSession}.
+ */
+interface AgentCliRuntime {
+    readonly definition: AgentCliHandle;
+    start(opts?: AgentCliStartOptions): Promise<AgentCliRuntimeSession>;
+}
+interface AgentCliStartOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    signal?: AbortSignal;
+    /**
+     * Per-turn runtime configuration — selects a manifest mode, sets
+     * options, and picks the continuation strategy. Validated against
+     * the manifest's declarations before spawn; unknown ids reject.
+     */
+    config?: RuntimeConfig;
+    /**
+     * Identity context the host hands to the continuation strategy.
+     * The pinned-session strategy uses this to derive its session-pin
+     * key (per `manifest.continuation.pinned_session.key_scope`); other
+     * strategies may ignore. Hosts SHOULD always pass this when in a
+     * conversation context — without it, pinning can't be keyed and
+     * the strategy falls back to per-spawn behaviour.
+     */
+    turnCtx?: TurnContext;
+    /**
+     * Reattach to an existing protocol session (ACP `loadSession`, MCP
+     * equivalent, argv `--resume`) instead of spawning fresh. The
+     * `native-resume` strategy populates this from the host's persisted
+     * (turnCtx → sessionId) lookup. Other strategies leave undefined.
+     * Forwarded verbatim to `protocolArm.connect({ resumeSessionId })`.
+     */
+    resumeSessionId?: string;
+}
+/**
+ * Operator-side runtime configuration. Mirrors the `runtime.config`
+ * block in AIP-9 OPERATOR.md. Every field is optional; omitted fields
+ * fall back to the manifest's declared defaults.
+ */
+interface RuntimeConfig {
+    /** Manifest-declared mode id. Unknown ids reject at validation time. */
+    mode?: string;
+    /** Manifest-declared option ids → values. Type / enum / bound checked. */
+    options?: Record<string, boolean | number | string>;
+    /** Continuation strategy id. Must be in `manifest.continuation.supported`. */
+    continuation?: ContinuationStrategyId;
+}
+/**
+ * Identity scope for continuation key derivation. The host populates
+ * the fields it knows; the pinned-session strategy's `key_scope` array
+ * picks which to actually combine. Missing fields the scope asked for
+ * downgrade the strategy to per-spawn behaviour with a console warning
+ * (rather than silently colliding pins across operators / conversations).
+ */
+interface TurnContext {
+    conversation?: string;
+    operator?: string;
+    user?: string;
+    guild?: string;
+    workspace?: string;
+}
+interface AgentCliRuntimeSession {
+    readonly sessionId: string;
+    send(message: unknown): AsyncIterable<StreamEvent>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+}
+
+/**
+ * AIP-45 AGENT-CLI.md frontmatter zod schema.
+ *
+ * Mirrors `resources/aip-45/draft/AGENT-CLI.schema.json`. AIP-45 is a
+ * sibling of AIP-29 (CLI.md, tool CLIs) covering interactive
+ * agent-as-process binaries. The `protocol` discriminator (acp / mcp
+ * / proprietary) selects the wire arm; cross-field rules ensure the
+ * matching arm-specific block is present.
+ *
+ * Both authoring paths (`define-agent-cli.ts` and
+ * `manifest/index.ts`) validate against this schema, so every
+ * field-level constraint runs in both paths from a single source of
+ * truth.
+ */
+
+declare const agentCliFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    bin: z.ZodString;
+    bin_args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    install: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        method: z.ZodLiteral<"brew">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"apt">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"dnf">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"pacman">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"choco">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"scoop">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"npm">;
+        package: z.ZodString;
+        global: z.ZodOptional<z.ZodBoolean>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"pip">;
+        package: z.ZodString;
+        user: z.ZodOptional<z.ZodBoolean>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"cargo">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"go">;
+        package: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"curl">;
+        url: z.ZodString;
+        verify_sha256: z.ZodOptional<z.ZodString>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"download">;
+        url: z.ZodString;
+        extract_bin: z.ZodString;
+        verify_sha256: z.ZodOptional<z.ZodString>;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        method: z.ZodLiteral<"vendored">;
+        path: z.ZodString;
+        experimental: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>], "method">>;
+    version_check: z.ZodObject<{
+        cmd: z.ZodString;
+        parse: z.ZodString;
+        range: z.ZodString;
+        timeout_ms: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    auth: z.ZodOptional<z.ZodObject<{
+        ref: z.ZodOptional<z.ZodString>;
+        state: z.ZodOptional<z.ZodObject<{
+            paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            env: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        login: z.ZodOptional<z.ZodObject<{
+            cmd: z.ZodString;
+            interactive: z.ZodOptional<z.ZodBoolean>;
+            requires_callback_url: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        refresh: z.ZodOptional<z.ZodObject<{
+            cmd: z.ZodString;
+            interval_s: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        expiry: z.ZodOptional<z.ZodObject<{
+            parse: z.ZodOptional<z.ZodString>;
+            grace_s: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    sandbox: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    runner: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>;
+    protocol: z.ZodEnum<{
+        acp: "acp";
+        mcp: "mcp";
+        proprietary: "proprietary";
+    }>;
+    acp: z.ZodOptional<z.ZodString>;
+    mcp: z.ZodOptional<z.ZodObject<{
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            http: "http";
+            sse: "sse";
+        }>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    adapter: z.ZodOptional<z.ZodString>;
+    session: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            ephemeral: "ephemeral";
+            persistent: "persistent";
+            resumable: "resumable";
+        }>>;
+        idle_timeout_ms: z.ZodDefault<z.ZodNumber>;
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        context_carryover: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    models: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodString>;
+        allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        streaming: z.ZodOptional<z.ZodBoolean>;
+        tool_calls: z.ZodOptional<z.ZodBoolean>;
+        sub_agents: z.ZodOptional<z.ZodBoolean>;
+        file_io: z.ZodOptional<z.ZodBoolean>;
+        multimodal: z.ZodOptional<z.ZodBoolean>;
+        resumable: z.ZodOptional<z.ZodBoolean>;
+        bidirectional: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    modes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        bin_args_append: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            enum: "enum";
+            integer: "integer";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        default: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>;
+        min: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodNumber>;
+        bin_args_template: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        bin_args_append_when_true: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>>>;
+    continuation: z.ZodOptional<z.ZodObject<{
+        default: z.ZodEnum<{
+            none: "none";
+            "pinned-session": "pinned-session";
+            transcript: "transcript";
+            "native-resume": "native-resume";
+        }>;
+        supported: z.ZodArray<z.ZodEnum<{
+            none: "none";
+            "pinned-session": "pinned-session";
+            transcript: "transcript";
+            "native-resume": "native-resume";
+        }>>;
+        pinned_session: z.ZodOptional<z.ZodObject<{
+            idle_timeout_ms: z.ZodDefault<z.ZodNumber>;
+            key_scope: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                conversation: "conversation";
+                operator: "operator";
+                user: "user";
+                guild: "guild";
+                workspace: "workspace";
+            }>>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    requires: z.ZodOptional<z.ZodObject<{
+        os: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            darwin: "darwin";
+            linux: "linux";
+            windows: "windows";
+        }>>>;
+        arch: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            x64: "x64";
+            arm64: "arm64";
+            x86: "x86";
+            arm: "arm";
+        }>>>;
+        min_disk_mb: z.ZodOptional<z.ZodNumber>;
+        min_memory_mb: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        goal: z.ZodString;
+        prompt: z.ZodString;
+        note: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+type AgentCliFrontmatter = z.infer<typeof agentCliFrontmatterSchema>;
+declare const runtimeConfigSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodBoolean, z.ZodNumber, z.ZodString]>>>;
+    continuation: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        "pinned-session": "pinned-session";
+        transcript: "transcript";
+        "native-resume": "native-resume";
+    }>>;
+}, z.core.$strict>;
+type RuntimeConfigInput = z.infer<typeof runtimeConfigSchema>;
+
+export { type AgentCliHandle as A, type ContinuationStrategyId as C, type RuntimeConfig as R, type TurnContext as T, type AgentCliRuntime as a, type AgentCliDefinition as b, type AgentCliClient as c, type AgentCliStartOptions as d, type AgentCliRuntimeSession as e, type ContinuationKeyScope as f, type AgentCliAuth as g, type AgentCliCapabilities as h, type AgentCliConnectOptions as i, type AgentCliContinuation as j, type AgentCliFrontmatter as k, type AgentCliInstallMethod as l, type AgentCliMcpBlock as m, type AgentCliMode as n, type AgentCliModels as o, type AgentCliOption as p, type AgentCliOptionType as q, type AgentCliPinnedSessionTuning as r, type AgentCliProtocol as s, type AgentCliSession as t, type AgentCliSessionMode as u, type AgentCliVersionCheck as v, type RuntimeConfigInput as w, agentCliFrontmatterSchema as x, runtimeConfigSchema as y };

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@agentproto/driver-agent-cli",
+  "version": "0.1.0-alpha.0",
+  "description": "@agentproto/driver-agent-cli — AIP-45 AGENT-CLI.md reference implementation. Multi-protocol runner that loads an AGENT-CLI.md manifest, spawns the binary, and dispatches turns through an ACP / MCP / proprietary arm. ACP arm delegates to @agentproto/acp; emits the canonical StreamEvent taxonomy regardless of underlying protocol.",
+  "keywords": [
+    "agentproto",
+    "aip-45",
+    "agent-cli",
+    "interactive",
+    "hermes",
+    "claude-code",
+    "opencode",
+    "goose",
+    "gemini-cli",
+    "acp",
+    "mcp"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-45",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts",
+    "directory": "packages/driver/agent-cli"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./manifest": {
+      "types": "./dist/manifest/index.d.ts",
+      "import": "./dist/manifest/index.mjs",
+      "default": "./dist/manifest/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "zod": "^4.3.6",
+    "@agentproto/acp": "0.1.0-alpha.0",
+    "@agentproto/define-doctype": "0.1.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:watch": "vitest"
+  }
+}