super-dsh 0.1.0 → 0.1.2

package/agent-agy/dist/index.js

@@ -0,0 +1,505 @@
+/**
+ * agent-agy provider — Google Antigravity (Gemini) provider plugin for DeepSeek
+ * Harness (Agent Worlds, consumer-first line, 2026-09-18).
+ *
+ * An `AgentFactory` that drives an `AgyBridgeClient` (the Python google-
+ * antigravity SDK bridge child — localharness materializes inside it on the
+ * FIRST prompt, so create/resume spawn nothing). Auth is consumer-first:
+ * a Gemini API key persisted in the adapter's world-home state, or ADC via the
+ * environment (the SDK picks it up; we never touch the agy CLI — dev-rules §16a).
+ *
+ * Session identity ("mapping only"): the DSH session id is the authority,
+ * supplied by the harness. The SDK conversation id materializes after the
+ * first turn, so the pairing is persisted in `<worldHome>/dsh-sessions.json`
+ * (agy-sessions.ts). Resume resolves that record and fails CLOSED
+ * (CONVERSATION_NOT_FOUND) when no conversation is recorded. The DSH session
+ * log is the transcript authority, written through the upstream
+ * `sessionPersistence` service (hermes create/resume transaction shape).
+ */
+import { realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import { emitAgentEvent, installModelSelection } from "@deepseek-ai/dsh-agent";
+import { SessionLogOffset, SessionPreparation, interruptedTurnClosers, } from "@deepseek-ai/dsh-session";
+import { AgyBridgeClient } from "./agy-client.js";
+import { AgyCliClient } from "./agy-cli-client.js";
+import { SingleAgyPresetRoster } from "./agent-preset-agy.js";
+import { agyAgentPresetProjection } from "./agent-preset-projection.js";
+import { readAdapterState, writeAdapterState, readNativeDefaultModel, hasAdcEvidence, readGcloudProject } from "./agy-store.js";
+import { AgyLlmAdapter, AGY_PROVIDER_ID } from "./adapter.js";
+import { AgyAgent } from "./agent.js";
+import { sessionRecord, upsertSession } from "./agy-sessions.js";
+import { AGY_MODEL_CATALOG, CLI_DEFAULT_MODEL, parseModelId, toModelSlug } from "./models.js";
+/** Realpath of a recorded cwd, accepted only when it names an existing directory. */
+/** Extract the session-selected model id (string form) from agent options. */
+function agentOptionsModel(agentOptions) {
+    const m = agentOptions?.model;
+    return typeof m === "string" && m !== "" ? m : undefined;
+}
+function validatedCwd(cwd) {
+    if (cwd === undefined)
+        return undefined;
+    try {
+        const canonical = realpathSync(cwd);
+        return statSync(canonical).isDirectory() ? canonical : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Diagnostic trace (AGY_TRACE=1 on the dsh process enables stderr tracing). */
+const trace = (...parts) => {
+    if (process.env.AGY_TRACE === "1")
+        process.stderr.write(`[agy-provider ${Date.now() % 1_000_000}] ${parts.join(" ")}\n`);
+};
+/** Blank-session doctrine (§14 i): conversation content = turns actually ran. */
+function hasConversationContent(events) {
+    return events.some((event) => {
+        if (event.type === "turn/start" || event.type === "assistant/message")
+            return true;
+        if (event.type === "user/message") {
+            const data = event.data;
+            return data?.source?.kind === "user";
+        }
+        return false;
+    });
+}
+/** Open a read handle, pull the complete stored log, close. */
+async function readStoredEvents(persistence, id, signal) {
+    const handle = await persistence.open(id, "read", signal === undefined ? {} : { signal });
+    try {
+        return (await handle.read(0, undefined, signal === undefined ? {} : { signal })).events;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export class AgyProvider extends Service {
+    static inject = ["agents", "sessions", "llm", "agentDefaultModel", "settings"];
+    /** Plain holder — prevents Cordis re-tracing the factory's ctx through a caller shadow. */
+    runtime;
+    /** The world's DSH home — anchors adapter-owned state (session map, api-key state). */
+    home;
+    opts;
+    defaultModelKey = "";
+    constructor(ctx, opts = {}) {
+        super(ctx, "agyProvider");
+        this.runtime = { ctx };
+        this.opts = opts;
+        this.home = this.resolveHome();
+        trace(`home: worldHome=${this.home}`);
+        ctx.effect(() => ctx.agents.setFactory(this), "agyProvider.setFactory()");
+        // The roster must be visible to the API gateway's root-level remote
+        // enumeration; register it on this plugin's own (top-level) fiber.
+        new SingleAgyPresetRoster(ctx);
+        // Drive the `agentPreset` session projection ourselves.
+        ctx.inject(["sessionProjections"], (scoped) => {
+            scoped.sessionProjections.register(agyAgentPresetProjection);
+        });
+        this.registerModelCatalog();
+        this.registerDefaultModel();
+    }
+    /** The world's DSH home: boot-provided dshHomePath first, env last. */
+    resolveHome() {
+        const fromBoot = this.runtime.ctx.get("dshHomePath");
+        if (typeof fromBoot === "string" && fromBoot !== "")
+            return fromBoot;
+        if (typeof fromBoot === "function") {
+            const resolved = fromBoot();
+            if (typeof resolved === "string" && resolved !== "")
+                return resolved;
+        }
+        return process.env.DSH_HOME ?? join(process.cwd(), ".tests", "aw");
+    }
+    /** Effective Gemini API key: adapter state first, then the environment. */
+    resolveApiKey() {
+        const state = readAdapterState(this.home);
+        if (typeof state.apiKey === "string" && state.apiKey !== "")
+            return state.apiKey;
+        const env = process.env.GEMINI_API_KEY;
+        return typeof env === "string" && env !== "" ? env : undefined;
+    }
+    /**
+     * Auth evidence for the §17 onboarding gate: an API key (state or env) OR
+     * ADC evidence is enough — the SDK consumes either transparently, so a user
+     * with gcloud ADC must NOT be pushed into key onboarding.
+     */
+    hasAuthEvidence() {
+        if (this.resolveApiKey() !== undefined)
+            return true;
+        return hasAdcEvidence(process.env, process.env.HOME ?? "");
+    }
+    /** Default model id: adapter state → native TUI default (slug-normalized) → catalog head. */
+    resolveDefaultModelId() {
+        const state = readAdapterState(this.home);
+        if (typeof state.defaultModel === "string" && parseModelId(state.defaultModel) !== undefined)
+            return state.defaultModel;
+        const native = readNativeDefaultModel(this.opts.nativeHome ?? join(process.env.HOME ?? "", ".gemini"));
+        const slug = toModelSlug(native);
+        if (slug !== undefined)
+            return slug;
+        return AGY_MODEL_CATALOG[0].slug;
+    }
+    /** Legacy slug-only default (default-model push keeps slug form). */
+    resolveDefaultModel() {
+        const state = readAdapterState(this.home);
+        if (typeof state.defaultModel === "string" && state.defaultModel !== "")
+            return state.defaultModel;
+        const native = readNativeDefaultModel(this.opts.nativeHome ?? join(process.env.HOME ?? "", ".gemini"));
+        const slug = toModelSlug(native);
+        if (slug !== undefined)
+            return slug;
+        return AGY_MODEL_CATALOG[0].slug;
+    }
+    /** Static route: provider `agy` + the resolved default (or the explicit ask).
+     *  The selected model id (`slug` or `slug@level`) rides in `options.model`
+     *  so clientOptions can forward slug+thinkingLevel to the bridge start frame. */
+    sessionAgentOptions(requested) {
+        const requestedModel = typeof requested?.model === "string" ? requested.model : undefined;
+        const explicit = requestedModel !== undefined && parseModelId(requestedModel) !== undefined
+            ? requestedModel
+            : undefined;
+        const model = explicit ?? this.resolveDefaultModelId();
+        return { ...(requested ?? {}), provider: AGY_PROVIDER_ID, model };
+    }
+    requirePersistence(op) {
+        const persistence = this.runtime.ctx.get("sessionPersistence");
+        if (persistence === undefined) {
+            throw new Error(`cannot ${op} an Agy session: session persistence is not configured`);
+        }
+        return persistence;
+    }
+    agentRuntime(cwd) {
+        const provider = this;
+        return {
+            session: { cwd },
+            awaitingKey: !provider.hasAuthEvidence(),
+            onSaveApiKey: (key) => {
+                writeAdapterState(provider.home, { ...readAdapterState(provider.home), apiKey: key });
+                trace("onboarding: api key persisted to adapter state (world home)");
+            },
+            onTurnDone: undefined, // replaced per-session by followConversationId below
+        };
+    }
+    /** Persist the Dash↔conversation pairing once the first turn materializes it. */
+    followConversationId = (id, client) => {
+        const cid = client.conversationId;
+        if (cid === "")
+            return;
+        try {
+            upsertSession(this.home, String(id), { conversationId: cid });
+            trace(`conversation id recorded for ${String(id)}: ${cid}`);
+        }
+        catch (error) {
+            this.runtime.ctx.logger.warn(`agy-provider: failed to persist the conversation id for ${String(id)}: ${String(error)}`);
+        }
+    };
+    registerModelCatalog() {
+        const llm = this.runtime.ctx.get("llm");
+        if (llm === undefined)
+            return;
+        llm.registerAdapter([AGY_PROVIDER_ID], new AgyLlmAdapter());
+    }
+    /** Push the resolved default model into the world's `agentDefaultModel`. */
+    registerDefaultModel() {
+        this.runtime.ctx.inject(["agentDefaultModel", "settings"], (mCtx) => {
+            const service = mCtx.get("agentDefaultModel");
+            if (service === undefined)
+                return;
+            const target = { provider: AGY_PROVIDER_ID, model: this.resolveDefaultModel() };
+            const targetKey = `${target.provider}/${target.model}`;
+            const current = service.currentSelection?.();
+            const currentKey = current === undefined ? undefined : `${current.provider}/${current.model}`;
+            if (currentKey === targetKey || currentKey === this.defaultModelKey)
+                return;
+            trace(`default model: ${currentKey ?? "none"} → ${targetKey}`);
+            const settings = mCtx.get("settings");
+            void Promise.resolve(settings?.replace?.("agent-default-model", target))
+                .then(() => service.saveSelection?.(target))
+                .then(() => {
+                this.defaultModelKey = targetKey;
+                this.runtime.ctx.logger.info(`agy-provider: default model ← static catalog / native settings: ${targetKey}`);
+            })
+                .catch((error) => {
+                this.runtime.ctx.logger.warn(`agy-provider: default model save failed: ${String(error)}`);
+            });
+        });
+    }
+    async createAgent(ownerCtx, options) {
+        const loopCtx = this.runtime.ctx;
+        const id = options.sessionId;
+        const meta = options.meta ?? {};
+        const cwd = meta.cwd;
+        if (meta.parentSession !== undefined) {
+            throw new Error(`cannot fork session "${meta.parentSession}" onto the Agy provider: Antigravity has no native session fork`);
+        }
+        const persistence = this.requirePersistence("create");
+        const spawnCwd = validatedCwd(cwd) ?? process.cwd();
+        trace(`create id=${id} spawnCwd=${spawnCwd}`);
+        // Full-lazy (§14-i): construct the client (spawns NOTHING); the bridge
+        // child materializes on the first real prompt.
+        const client = this.createLiveClient(spawnCwd, agentOptionsModel(options.agentOptions), options.agentOptions?.reasoningEffort);
+        const preparation = SessionPreparation.create(loopCtx.sessions.prepare(id, {
+            ...(options.seed === undefined ? {} : { seed: options.seed }),
+            ...(meta === undefined ? {} : { meta }),
+            ...(options.inheritedEventCount === undefined ? {} : { inheritedEventCount: options.inheritedEventCount }),
+        }));
+        let stored;
+        let handedOff = false;
+        try {
+            stored = await this.createStoredSession(persistence, preparation.session, options.signal);
+            upsertSession(this.home, String(id), { conversationId: null, cwd: spawnCwd, createdAt: Date.now(), preset: null });
+            handedOff = true;
+            const agentOptions = await this.sessionAgentOptions(options.agentOptions);
+            return await setupAndPublish(loopCtx, ownerCtx, id, agentOptions, options.setup, preparation.session, client, options.parentAgent, "startup", { enterSession: true, preparation }, stored, this.agentRuntime(spawnCwd), () => this.followConversationId(id, client));
+        }
+        catch (error) {
+            trace(`create ${id} THREW: ${String(error)}`);
+            void client.close();
+            if (!handedOff)
+                await stored?.handle.close().catch(() => { });
+            throw error;
+        }
+        finally {
+            if (!handedOff)
+                preparation[Symbol.dispose]();
+        }
+    }
+    async resume(ownerCtx, options) {
+        const loopCtx = this.runtime.ctx;
+        const id = options.resumeSessionId;
+        // Identity ("mapping only") with BLANK-SESSION TOLERANCE (2026-09-18,
+        // dev-rules §14 i — pi doctrine mirror): the Dash host eagerly resumes on
+        // view/model-change, so a never-materialized session (no record, or a
+        // record whose native conversation never produced a turn) resumes AS
+        // FRESH — zero processes until the first prompt. A MISSING record with
+        // conversation-bearing DSH log content stays a genuine orphan → fail loud.
+        const record = sessionRecord(this.home, String(id));
+        const blank = record === undefined || record.conversationId === null || record.conversationId === "";
+        trace(`resume id=${id} record=${record === undefined ? "MISSING" : record.conversationId ?? "NO-CONVERSATION"}${blank ? " (blank-tolerant)" : ""}`);
+        const persistence = this.requirePersistence("resume");
+        let orphanCheck;
+        if (record === undefined) {
+            orphanCheck = await readStoredEvents(persistence, id, options.signal);
+            if (hasConversationContent(orphanCheck)) {
+                const error = new Error(`cannot resume session "${id}": no Antigravity conversation is recorded for this Dash session id — start a new session`);
+                error.code = "CONVERSATION_NOT_FOUND";
+                throw error;
+            }
+        }
+        const spawnCwd = blank
+            ? (record !== undefined ? validatedCwd(record.cwd) ?? process.cwd() : process.cwd())
+            : (() => {
+                const verified = validatedCwd(record.cwd);
+                if (verified === undefined) {
+                    throw new Error(`cannot resume session "${id}": its recorded working directory no longer exists`);
+                }
+                return verified;
+            })();
+        const client = this.createLiveClient(spawnCwd, agentOptionsModel(options.agentOptions), options.agentOptions?.reasoningEffort);
+        let handle;
+        let stored;
+        let preparation;
+        let handedOff = false;
+        try {
+            handle = await persistence.open(id, "write", options.signal === undefined ? {} : { signal: options.signal });
+            const cold = await handle.read(0, undefined, options.signal === undefined ? {} : { signal: options.signal });
+            const closers = interruptedTurnClosers(cold.events);
+            if (closers.length > 0)
+                await handle.append(closers);
+            preparation = SessionPreparation.create(loopCtx.sessions.prepare(id, {
+                seed: [...cold.events, ...closers],
+                meta: structuredClone(handle.header),
+                inheritedEventCount: handle.inheritedEventCount,
+                eventState: cold.eventState,
+            }));
+            stored = { handle, storedCount: cold.events.length + closers.length };
+            trace(`resume id=${id} seeded ${cold.events.length} events (+${closers.length} closers)`);
+            handle = undefined;
+            handedOff = true;
+            const agentOptions = await this.sessionAgentOptions(options.agentOptions);
+            return await setupAndPublish(loopCtx, ownerCtx, id, agentOptions, options.setup, preparation.session, client, options.parentAgent, "resume", { enterSession: true, preparation }, stored, this.agentRuntime(spawnCwd), () => this.followConversationId(id, client));
+        }
+        catch (error) {
+            trace(`resume ${id} THREW: ${String(error)}`);
+            void client.close();
+            if (!handedOff)
+                await handle?.close().catch(() => { });
+            throw error;
+        }
+        finally {
+            if (!handedOff)
+                preparation?.[Symbol.dispose]();
+        }
+    }
+    /**
+     * Live transport routing (2026-09-18 user ruling): gemini-api-key > oauth >
+     * adc. Key present → CLI stream (richest surface). ADC-only → SDK bridge.
+     * Neither → CLI as well (auth fails at first prompt; the §17 onboarding
+     * branch answers locally before any spawn).
+     */
+    createLiveClient(cwd, modelId, reasoningEffort) {
+        const apiKey = this.resolveApiKey();
+        if (apiKey === undefined && hasAdcEvidence(process.env, process.env.HOME ?? "")) {
+            return new AgyBridgeClient(this.clientOptions(cwd, modelId, reasoningEffort));
+        }
+        return new AgyCliClient(this.cliOptions(cwd, modelId, reasoningEffort));
+    }
+    /**
+     * The effective permission preset this provider was mounted with. The
+     * cordis.patch.yml default is danger-full-access; a patch-level override
+     * would surface through the permission service config, which we read
+     * best-effort (fail → the patch default).
+     */
+    currentPermissionPreset() {
+        try {
+            const permission = this.runtime.ctx.get("permission");
+            return permission?.config?.defaultPreset ?? "danger-full-access";
+        }
+        catch {
+            return "danger-full-access";
+        }
+    }
+    /** CLI transport options: key-first default is the cheapest live pair. */
+    cliOptions(cwd, modelId, reasoningEffort) {
+        const parsed = parseModelId(modelId ?? this.resolveDefaultModelId());
+        const slug = parsed?.slug ?? CLI_DEFAULT_MODEL.slug;
+        // Effort precedence: explicit session reasoningEffort (WebUI Effort
+        // selector → AgentOptions) > legacy @level id suffix > CLI cheap default.
+        const level = reasoningEffort ?? parsed?.thinkingLevel ?? CLI_DEFAULT_MODEL.thinkingLevel;
+        return {
+            apiKey: () => this.resolveApiKey(),
+            model: slug,
+            ...(level === undefined ? {} : { effort: level }),
+            cwd,
+            proxy: this.opts.proxy ?? process.env.AGY_PROXY,
+            // Preset → permission mapping (cordis.patch.yml default
+            // danger-full-access): headless has no interactive approval, so the
+            // full-access preset maps to --dangerously-skip-permissions; the
+            // tighter presets keep the CLI's request-review (soft-deny, honest).
+            skipPermissions: (this.opts.skipPermissions ?? (this.currentPermissionPreset() === "danger-full-access")),
+            agyBin: this.opts.agyBin,
+            nativeCliHome: this.opts.nativeHome,
+            home: this.opts.cliHome ?? process.env.AGY_CLI_HOME,
+            spawnAttempts: this.opts.spawnAttempts,
+        };
+    }
+    /** Bridge child options: world cwd + overrides; the api key rides the start config. */
+    clientOptions(cwd, modelId, reasoningEffort) {
+        // Auth plane (§16a): API key when present; otherwise the SDK's Vertex
+        // endpoint over ADC — which needs an explicit project, read from the
+        // gcloud CLI default. Without either, sessions gate into §17 onboarding.
+        const apiKey = this.resolveApiKey();
+        let project = this.opts.project;
+        let location = this.opts.location;
+        if (apiKey === undefined && project === undefined && hasAdcEvidence(process.env, process.env.HOME ?? "")) {
+            project = readGcloudProject(process.env.HOME ?? "");
+            location = location ?? "global";
+        }
+        // Session-selected model id wins over the provider default (previously a
+        // split-brain: the session showed one model, the bridge started another).
+        // `slug@level` decodes into model + thinking_level for the start frame.
+        const parsed = parseModelId(modelId ?? this.resolveDefaultModelId());
+        return {
+            apiKey,
+            project,
+            location,
+            model: parsed?.slug ?? this.resolveDefaultModelId(),
+            // TUI parity: the native default ships (Medium); without an explicit
+            // level the bridge sends none and thinking blocks rarely stream.
+            thinkingLevel: parsed?.thinkingLevel ?? "medium",
+            approvalMode: this.opts.approvalMode ?? "allow",
+            workspaces: [cwd],
+            bridgePath: this.opts.bridgePath,
+            pythonBin: this.opts.pythonBin,
+            spawnAttempts: this.opts.spawnAttempts,
+        };
+    }
+    async createStoredSession(persistence, session, signal) {
+        const handle = await persistence.create(session.header, {
+            inheritedEventCount: session.inheritedEventCount,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        return { handle, storedCount: 0 };
+    }
+}
+/** Durable flush of the session's pre-publication suffix. */
+async function appendUnstoredSuffix(stored, session) {
+    const suffix = session.snapshotEvents(SessionLogOffset(stored.storedCount));
+    if (suffix.length > 0)
+        await stored.handle.append(suffix);
+    stored.storedCount += suffix.length;
+}
+/** Shared create/resume transaction (module-level: Cordis tracing proxy). */
+async function setupAndPublish(loopCtx, ownerCtx, id, agentOptions, setup, session, client, parentAgent, source, opts, stored, runtimeInfo, onTurnDone) {
+    const runtime = { ...runtimeInfo, onTurnDone };
+    let detachSession;
+    let detachAgent;
+    let agent;
+    let idleExit;
+    try {
+        agent = new AgyAgent(loopCtx, id, agentOptions, session, client, () => idleExit?.(), runtime);
+        // Pin THIS session to the agy route (static resolution — synchronous).
+        try {
+            const selection = { provider: agentOptions.provider ?? "agy", model: agentOptions.model ?? "" };
+            if (selection.model !== "") {
+                let picked = selection;
+                installModelSelection(agent.ctx, {
+                    get current() { return picked; },
+                    set current(next) { picked = next; },
+                    assembled: undefined,
+                });
+                session.append("model/selection", selection);
+                trace(`session route pinned: ${selection.provider}/${selection.model}`);
+            }
+        }
+        catch (error) {
+            trace(`session route pin failed: ${String(error)}`);
+        }
+        const commit = await setup?.(agent.ctx, agent);
+        commit?.commit();
+        await appendUnstoredSuffix(stored, session);
+        if (opts.enterSession) {
+            detachSession = agent.ctx.sessions.enter(session);
+            agent.ctx.sessions.announce(session);
+        }
+        detachAgent = loopCtx.agents.enter(agent, parentAgent);
+        loopCtx.agents.announce(agent);
+        emitAgentEvent(loopCtx, agent, "agent/session-start", { source });
+        let disposed = false;
+        let unfollowOwner;
+        const dispose = async () => {
+            if (disposed)
+                return;
+            disposed = true;
+            unfollowOwner?.();
+            await agent?.dispose();
+            detachAgent?.();
+            detachSession?.();
+            await stored.handle.close();
+        };
+        idleExit = () => {
+            void dispose().catch((error) => {
+                loopCtx.logger.warn(`agy-provider: teardown of ${id} failed: ${String(error)}`);
+            });
+        };
+        unfollowOwner = ownerCtx.effect(() => () => {
+            void dispose().catch((error) => {
+                loopCtx.logger.warn(`agy-provider: owner-unload teardown of ${id} failed: ${String(error)}`);
+            });
+        }, `agyProvider.lifecycle(${id})`);
+        return { agent, dispose };
+    }
+    catch (error) {
+        trace(`setupAndPublish ${id} FAILED: ${String(error)}`);
+        detachAgent?.();
+        detachSession?.();
+        void agent?.dispose().catch(() => { });
+        void client.close();
+        throw error;
+    }
+    finally {
+        opts.preparation?.[Symbol.dispose]();
+    }
+}
+export default AgyProvider;

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

@@ -0,0 +1,41 @@
+/**
+ * Static model catalog for the Gemini consumer surface. The google-antigravity
+ * SDK has no model-list API and the CLI catalog path is auth-gated, so the
+ * catalog is static AND endpoint-verified (2026-09-18 probes on both auth
+ * planes; non-listed slugs 404 / are retired).
+ *
+ * Model ids are PLAIN slugs — thinking effort is a per-route option surfaced
+ * through the adapter's reasoning metadata (WebUI Effort selector →
+ * AgentOptions.reasoningEffort), NOT extra catalog entries (user ruling
+ * 2026-09-18).
+ */
+export interface AgyCatalogModel {
+    slug: string;
+    label: string;
+    /** Effort levels the CLI/SDK accept for this slug (absent = no effort param). */
+    efforts?: readonly string[];
+    defaultEffort?: string;
+}
+export declare const AGY_MODEL_CATALOG: readonly AgyCatalogModel[];
+/** Selectable model ids (plain slugs). */
+export declare function modelIds(): string[];
+export declare function catalogSlugs(): string[];
+/** Parse a selectable model id: plain slug, or legacy `slug@level`. */
+export declare function parseModelId(id: string | undefined): {
+    slug: string;
+    thinkingLevel?: string;
+} | undefined;
+/** Efforts for a slug (undefined = the slug takes no effort parameter). */
+export declare function effortsFor(slug: string): readonly string[] | undefined;
+export declare function defaultEffortFor(slug: string): string | undefined;
+/** Cheapest live pair on the CLI key path (probed 2026-09-18). CLI default. */
+export declare const CLI_DEFAULT_MODEL: {
+    slug: string;
+    thinkingLevel: string;
+};
+/**
+ * Normalize a model reference to an SDK-facing slug. The native TUI settings
+ * store display names ("Gemini 3.7 Flash (Medium)"); slugs pass through;
+ * unknown display names → undefined (caller uses the catalog head).
+ */
+export declare function toModelSlug(model: string | undefined): string | undefined;

package/agent-agy/dist/models.js

@@ -0,0 +1,74 @@
+/**
+ * Static model catalog for the Gemini consumer surface. The google-antigravity
+ * SDK has no model-list API and the CLI catalog path is auth-gated, so the
+ * catalog is static AND endpoint-verified (2026-09-18 probes on both auth
+ * planes; non-listed slugs 404 / are retired).
+ *
+ * Model ids are PLAIN slugs — thinking effort is a per-route option surfaced
+ * through the adapter's reasoning metadata (WebUI Effort selector →
+ * AgentOptions.reasoningEffort), NOT extra catalog entries (user ruling
+ * 2026-09-18).
+ */
+export const AGY_MODEL_CATALOG = [
+    { slug: "gemini-3.7-flash", label: "Gemini 3.7 Flash", efforts: ["low", "medium", "high"], defaultEffort: "medium" },
+    { slug: "gemini-3.6-flash", label: "Gemini 3.6 Flash", efforts: ["low", "medium", "high"], defaultEffort: "low" },
+    { slug: "gemini-3.5-flash", label: "Gemini 3.5 Flash", efforts: ["low", "medium", "high"], defaultEffort: "medium" },
+    { slug: "gemini-2.5-pro", label: "Gemini 2.5 Pro" },
+    { slug: "gemini-2.5-flash", label: "Gemini 2.5 Flash" },
+];
+/** Selectable model ids (plain slugs). */
+export function modelIds() {
+    return AGY_MODEL_CATALOG.map((m) => m.slug);
+}
+export function catalogSlugs() {
+    return modelIds();
+}
+/** Parse a selectable model id: plain slug, or legacy `slug@level`. */
+export function parseModelId(id) {
+    if (id === undefined)
+        return undefined;
+    const at = id.indexOf("@");
+    const slug = at < 0 ? id : id.slice(0, at);
+    if (!catalogSlugs().includes(slug))
+        return undefined;
+    if (at < 0)
+        return { slug };
+    const level = id.slice(at + 1);
+    const entry = AGY_MODEL_CATALOG.find((m) => m.slug === slug);
+    if (entry?.efforts && entry.efforts.includes(level))
+        return { slug, thinkingLevel: level };
+    return { slug };
+}
+/** Efforts for a slug (undefined = the slug takes no effort parameter). */
+export function effortsFor(slug) {
+    return AGY_MODEL_CATALOG.find((m) => m.slug === slug)?.efforts;
+}
+export function defaultEffortFor(slug) {
+    return AGY_MODEL_CATALOG.find((m) => m.slug === slug)?.defaultEffort;
+}
+/** Cheapest live pair on the CLI key path (probed 2026-09-18). CLI default. */
+export const CLI_DEFAULT_MODEL = {
+    slug: "gemini-3.6-flash",
+    thinkingLevel: "low",
+};
+/**
+ * Normalize a model reference to an SDK-facing slug. The native TUI settings
+ * store display names ("Gemini 3.7 Flash (Medium)"); slugs pass through;
+ * unknown display names → undefined (caller uses the catalog head).
+ */
+export function toModelSlug(model) {
+    if (!model)
+        return undefined;
+    const v = model.trim();
+    if (!v)
+        return undefined;
+    if (/^[a-z0-9.-]+$/.test(v) && !v.includes(" "))
+        return v;
+    const base = v.replace(/\s*\([^)]*\)\s*$/, "").trim().toLowerCase();
+    const slug = base.replace(/\s+/g, "-");
+    if (catalogSlugs().includes(slug))
+        return slug;
+    if (/^gemini-[0-9]/.test(slug))
+        return slug;
+    return undefined;
+}

package/agent-agy/dist/world-plugin.d.ts

@@ -0,0 +1,9 @@
+export declare const name = "aw.agent-adapter-agy";
+/** Structural slice of the ctx0 services the mount needs. */
+interface HostContext {
+    provide(name: string, value: unknown): void;
+    inject(deps: string[], callback: (ctx: unknown) => void): unknown;
+    effect?(callback: () => () => void, label?: string): unknown;
+}
+export declare function apply(ctx: HostContext): void;
+export {};