super-dsh 0.1.0 → 0.1.2

package/agent-agy/dist/agy-cli-client.js

@@ -0,0 +1,301 @@
+/**
+ * agy-cli-client.ts — primary live path: the agy CLI headless stream-json
+ * session (`agy --print --input-format stream-json --output-format stream-json`).
+ *
+ * Auth: GEMINI_API_KEY env (adapter stores the key; never written to native
+ * home) + `modelProvider: "gemini"` merged into the CLI's own settings file
+ * (~/.gemini/antigravity-cli/settings.json — single-key merge, user-sanctioned
+ * 2026-09-18). Geofenced deployments pass HTTPS_PROXY via AGY_PROXY.
+ *
+ * Event mapping (superset of the SDK bridge — CLI is richer):
+ *   init            → tools list + permission mode (trace)
+ *   step_update     → system_message | agent_response (text deltas) |
+ *                     tool (ACTIVE→tool_call, DONE→tool_result w/ output)
+ *   result          → done (conversation_id for resume via --conversation)
+ *
+ * Same surface as AgyBridgeClient so AgyAgent needs no changes.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/** Merge `modelProvider: "gemini"` into the CLI's own settings (single key). */
+export function ensureCliKeyMode(nativeCliHome) {
+    const dir = join(nativeCliHome, "antigravity-cli");
+    mkdirSync(dir, { recursive: true });
+    const p = join(dir, "settings.json");
+    let settings = {};
+    if (existsSync(p)) {
+        try {
+            settings = JSON.parse(readFileSync(p, "utf8"));
+        }
+        catch {
+            settings = {};
+        }
+    }
+    if (settings.modelProvider === "gemini")
+        return;
+    settings.modelProvider = "gemini";
+    writeFileSync(p, JSON.stringify(settings, null, 2) + "\n");
+}
+export class AgyCliClient {
+    child;
+    buffer = "";
+    waiters = [];
+    pending = [];
+    opts;
+    dead = false;
+    conversationIdValue = "";
+    toolsSeen = 0;
+    onThinkingDelta;
+    onToolEvent;
+    setApprovalHandler(_handler) {
+        // CLI ask-mode approval is not wired in this iteration (approval_mode
+        // stays request-review; tools soft-deny in headless).
+    }
+    setSystemMessageHandler(handler) {
+        this.onSystemMessage = handler;
+    }
+    onSystemMessage;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get conversationId() {
+        return this.conversationIdValue;
+    }
+    get lastUsage() {
+        return this.lastUsageValue;
+    }
+    lastUsageValue;
+    nativeCliHome() {
+        return this.opts.nativeCliHome ?? join(process.env.HOME ?? "", ".gemini");
+    }
+    spawnCli() {
+        if (this.child || this.dead)
+            return;
+        ensureCliKeyMode(this.nativeCliHome());
+        const attempts = this.opts.spawnAttempts ?? 3;
+        const agyBin = this.opts.agyBin ?? "agy";
+        // Order matters: --print swallows the next token as a prompt value
+        // (flag-collision, A2A skill) — keep it LAST, after all value flags.
+        // = form everywhere: bare value flags swallow the next token (collision).
+        const args = [
+            "--input-format=stream-json", "--output-format=stream-json",
+            "--disable-slash-commands",
+        ];
+        if (this.opts.conversationId)
+            args.push(`--conversation=${this.opts.conversationId}`);
+        if (this.opts.model)
+            args.push(`--model=${this.opts.model}`);
+        if (this.opts.effort)
+            args.push(`--effort=${this.opts.effort}`);
+        if (this.opts.skipPermissions)
+            args.push("--dangerously-skip-permissions");
+        // NOTE: no --print — stream-json input mode reads prompts from stdin
+        // (verified); --print would demand a prompt argument and exit code 2.
+        let lastError;
+        for (let attempt = 1; attempt <= attempts; attempt++) {
+            try {
+                const key = typeof this.opts.apiKey === "function" ? this.opts.apiKey() : this.opts.apiKey;
+                if (!key)
+                    throw new Error("agy cli: no GEMINI_API_KEY resolved");
+                const env = { ...process.env, GEMINI_API_KEY: key, NO_PROXY: "127.0.0.1,localhost" };
+                if (this.opts.home)
+                    env.HOME = this.opts.home;
+                if (this.opts.proxy) {
+                    env.HTTPS_PROXY = this.opts.proxy;
+                    env.HTTPS_PROXY = this.opts.proxy;
+                }
+                this.child = spawn(agyBin, args, { cwd: this.opts.cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+                break;
+            }
+            catch (err) {
+                lastError = err;
+                this.opts.trace?.(`spawn attempt ${attempt} failed:`, err);
+            }
+        }
+        if (!this.child)
+            throw lastError ?? new Error("agy spawn failed");
+        const child = this.child;
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (d) => this.consume(d));
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (d) => this.opts.trace?.("[agy stderr]", d.trimEnd()));
+        child.on("exit", (code) => {
+            this.child = undefined;
+            this.dispatch({ event: "error", error: `agy exited code=${code}`, recoverable: !this.dead });
+        });
+    }
+    consume(data) {
+        this.buffer += data;
+        let idx;
+        while ((idx = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, idx).trim();
+            this.buffer = this.buffer.slice(idx + 1);
+            if (!line)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch (err) {
+                this.opts.trace?.("bad agy json:", line.slice(0, 120), err);
+                continue;
+            }
+            if (parsed.event === "init") {
+                const init = parsed.init;
+                this.toolsSeen = Array.isArray(init?.tools) ? init.tools.length : 0;
+                this.dispatch({ event: "ready", tools: this.toolsSeen, permissionMode: init?.permission_mode });
+            }
+            else if (parsed.event === "step_update") {
+                this.consumeStep(parsed.step_update);
+            }
+            else if (parsed.event === "result") {
+                const r = parsed.result;
+                if (r?.conversation_id)
+                    this.conversationIdValue = r.conversation_id;
+                if (r?.status !== "SUCCESS") {
+                    this.dispatch({ event: "error", error: r?.error ?? `agy result status=${r?.status}`, recoverable: false });
+                }
+                else {
+                    this.dispatch({ event: "done", conversation_id: this.conversationIdValue, turn_ms: 0 });
+                }
+            }
+        }
+    }
+    consumeStep(su) {
+        const st = su.step_type;
+        if (st === "system_message") {
+            this.onSystemMessage?.(su.text_delta ?? "");
+            return;
+        }
+        if (st === "agent_response") {
+            // Short turns carry their delta on the DONE frame — dispatch any delta.
+            if (su.text_delta) {
+                this.dispatch({ event: "chunk", text: su.text_delta });
+            }
+            if (su.usage) {
+                this.lastUsageValue = {
+                    input_tokens: su.usage.input_tokens ?? 0,
+                    output_tokens: su.usage.output_tokens ?? 0,
+                    thinking_tokens: su.usage.thinking_tokens ?? 0,
+                    total_tokens: su.usage.total_tokens ?? 0,
+                };
+                this.dispatch({
+                    event: "usage",
+                    input_tokens: this.lastUsageValue.input_tokens,
+                    output_tokens: this.lastUsageValue.output_tokens,
+                    thinking_tokens: this.lastUsageValue.thinking_tokens,
+                    total_tokens: this.lastUsageValue.total_tokens,
+                });
+            }
+            return;
+        }
+        if (st === "tool") {
+            const name = su.tool_name ?? su.tool_info?.name ?? "unknown";
+            const id = `${this.conversationIdValue}:${su.step_index ?? 0}`;
+            if (su.state === "ACTIVE") {
+                this.dispatch({
+                    event: "tool_call", id, name,
+                    args: JSON.stringify(su.tool_info?.parameters ?? {}),
+                });
+                this.onToolEvent?.({ event: "tool_call", id, name, args: JSON.stringify(su.tool_info?.parameters ?? {}) });
+            }
+            else if (su.state === "DONE" || su.state === "ERROR") {
+                const output = su.tool_info?.output ?? "";
+                const isError = su.state === "ERROR";
+                this.dispatch({
+                    event: "tool_result", id, name, is_error: isError,
+                    result: output || (isError ? "tool failed" : "[agy CLI reported no output summary]"),
+                });
+                this.onToolEvent?.({
+                    event: "tool_result", id, name, is_error: isError,
+                    result: output || (isError ? "tool failed" : "[agy CLI reported no output summary]"),
+                });
+            }
+        }
+    }
+    dispatch(ev) {
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter(ev);
+        else
+            this.pending.push(ev);
+    }
+    nextEvent() {
+        const pending = this.pending.shift();
+        if (pending)
+            return Promise.resolve(pending);
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    send(obj) {
+        if (!this.child)
+            throw new Error("agy not running");
+        this.child.stdin.write(JSON.stringify(obj) + "\n");
+    }
+    /** One turn. First call spawns the CLI (lazy per §14-i) and keeps it resident. */
+    async *turn(text) {
+        this.spawnCli();
+        await this.expectReady();
+        this.send({ event: "user", message: { content: text } });
+        let full = "";
+        for (;;) {
+            const ev = await this.nextEvent();
+            if (ev.event === "chunk") {
+                full += ev.text;
+                yield ev.text;
+            }
+            else if (ev.event === "system_message") {
+                this.onSystemMessage?.(ev.text);
+            }
+            else if (ev.event === "tool_call" || ev.event === "tool_result") {
+                this.onToolEvent?.(ev);
+            }
+            else if (ev.event === "usage") {
+                this.lastUsageValue = {
+                    input_tokens: ev.input_tokens, output_tokens: ev.output_tokens,
+                    thinking_tokens: ev.thinking_tokens, total_tokens: ev.total_tokens,
+                };
+            }
+            else if (ev.event === "done") {
+                return full;
+            }
+            else if (ev.event === "error") {
+                throw new Error(`agy cli: ${ev.error}`);
+            }
+        }
+    }
+    readyReceived = false;
+    async expectReady() {
+        if (this.readyReceived)
+            return;
+        for (;;) {
+            const ev = await this.nextEvent();
+            if (ev.event === "ready") {
+                this.readyReceived = true;
+                return;
+            }
+            if (ev.event === "error")
+                throw new Error(`agy cli: ${ev.error}`);
+        }
+    }
+    async ping() {
+        this.spawnCli();
+        await this.expectReady();
+    }
+    async close() {
+        if (!this.child)
+            return;
+        this.dead = true;
+        const child = this.child;
+        try {
+            child.stdin.end();
+        }
+        catch { /* already gone */ }
+        setTimeout(() => {
+            if (!child.killed)
+                child.kill("SIGKILL");
+        }, 2000).unref();
+        await new Promise((resolve) => child.on("exit", () => resolve()));
+        this.child = undefined;
+    }
+}

package/agent-agy/dist/agy-client.d.ts

@@ -0,0 +1,160 @@
+/**
+ * agy-client.ts — drives the Python SDK bridge (bridge/agy_bridge.py) over
+ * JSONL stdio.
+ *
+ * Discipline (agent-adapter-dev-rules §14-i / §16a):
+ * - LAZY: no python child until the first real prompt. `start` config is
+ *   buffered and flushed with the first `prompt` (one round trip).
+ * - Transient spawn failures retry in-place up to AGY_SPAWN_ATTEMPTS (3);
+ *   prompt-level errors are surfaced, never auto-retried.
+ * - The agy CLI is never invoked; auth is transparent (api_key param or ADC
+ *   environment picked up by the SDK itself).
+ */
+export interface AgyClientOptions {
+    /** Gemini API key; omit to let the SDK fall back to ADC. */
+    apiKey?: string;
+    model?: string;
+    /** Thinking level for the start frame (undefined = endpoint default). */
+    thinkingLevel?: string;
+    /** Tool-approval posture: "allow" (default) auto-approves; "ask" defers to
+     *  the onApprovalRequest handler (fail closed). */
+    approvalMode?: "allow" | "ask";
+    project?: string;
+    location?: string;
+    workspaces?: string[];
+    saveDir?: string;
+    /** Python interpreter (test knob; prod resolves via PATH). */
+    pythonBin?: string;
+    /** Bridge script override (tests point this at a mock). */
+    bridgePath?: string;
+    spawnAttempts?: number;
+    trace?: (...parts: unknown[]) => void;
+    /**
+     * Host-side approval handler for approval_mode "ask": resolves true=allow.
+     * NEVER consulted in "allow" mode. Fail-closed lives with the handler.
+     */
+    onApprovalRequest?: (req: {
+        id: string;
+        tool: string;
+        args: string;
+    }) => Promise<boolean>;
+}
+export interface AgyTurnUsage {
+    input_tokens: number;
+    output_tokens: number;
+    thinking_tokens: number;
+    total_tokens: number;
+}
+export type BridgeEvent = {
+    event: "pong";
+} | {
+    event: "started";
+} | {
+    event: "chunk";
+    text: string;
+} | {
+    event: "thinking";
+    text: string;
+} | {
+    event: "tool";
+    name: string;
+} | {
+    event: "tool_call";
+    id: string;
+    name: string;
+    args: string;
+} | {
+    event: "tool_result";
+    id: string;
+    name: string;
+    is_error: boolean;
+    result: string;
+} | {
+    event: "usage";
+    input_tokens: number;
+    output_tokens: number;
+    thinking_tokens: number;
+    total_tokens: number;
+} | {
+    event: "approval_request";
+    id: string;
+    tool: string;
+    args: string;
+} | {
+    event: "done";
+    conversation_id: string;
+    turn_ms: number;
+} | {
+    event: "closed";
+} | {
+    event: "error";
+    error: string;
+    recoverable: boolean;
+};
+export declare class AgyBridgeClient {
+    private child?;
+    private buffer;
+    private readonly waiters;
+    private readonly pending;
+    private readonly opts;
+    private spawnFailures;
+    /** Thinking-delta sink (agent buffers these into a reasoning block). */
+    onThinkingDelta?: (text: string) => void;
+    /** Tool lifecycle sink: tool_call / tool_result (agent writes DSH events). */
+    onToolEvent?: (ev: {
+        event: "tool_call";
+        id: string;
+        name: string;
+        args: string;
+    } | {
+        event: "tool_result";
+        id: string;
+        name: string;
+        is_error: boolean;
+        result: string;
+    }) => void;
+    /** Bridge-protocol parity for the agent test harness (fake clients). */
+    setToolEventHandler?(handler: (ev: {
+        event: "tool_call";
+        id: string;
+        name: string;
+        args: string;
+    } | {
+        event: "tool_result";
+        id: string;
+        name: string;
+        is_error: boolean;
+        result: string;
+    }) => void): void;
+    private dead;
+    private startedSent;
+    private lastUsageValue;
+    /** Per-turn token usage from the bridge (undefined when the bridge skipped it). */
+    get lastUsage(): AgyTurnUsage | undefined;
+    /** Register the ask-mode approval handler (agent wires its approval service). */
+    setApprovalHandler(handler: NonNullable<AgyClientOptions["onApprovalRequest"]>): void;
+    private conversationIdValue;
+    constructor(opts?: AgyClientOptions);
+    get conversationId(): string;
+    private resolveBridgePath;
+    /** Durable venv created by scripts/setup-venv.sh (pkg-root/.venv). */
+    private resolvePackagedVenvPython;
+    private spawnBridge;
+    private consume;
+    private dispatch;
+    private nextEvent;
+    private send;
+    /** Wait for a specific event kind, surfacing `error` events as throws. */
+    private expect;
+    /** Ping round trip (spawns the bridge if needed — use for liveness probes). */
+    ping(): Promise<void>;
+    /**
+     * Run one turn. First call materializes the bridge child and sends the
+     * buffered `start` config followed by `prompt` (lazy spawn per §14-i).
+     * Yields streamed text chunks; resolves with the full turn text.
+     */
+    turn(text: string): AsyncGenerator<string, string, void>;
+    close(): Promise<void>;
+}
+/** Convenience: read the venv python path recorded by scripts/setup-venv.sh. */
+export declare function resolveVenvPython(worldHome: string): string | undefined;