@yitom/agy-acp-map 0.1.3 → 0.1.6

package/dist/lib/agy-args.d.ts

@@ -60,7 +60,19 @@ export declare function normalizeJsonSchema(v: unknown): string | undefined;
  */
 export declare function normalizeSandbox(v: unknown): boolean | undefined;
 /** Canonical safety tier values (also listed on BRIDGE_CAPABILITIES.safetyTiers). */
-export declare const SAFETY_TIERS: readonly ["safe", "autonomous", "autonomous-unsandboxed"];
+export declare const SAFETY_TIERS: readonly ['safe', 'autonomous', 'autonomous-unsandboxed'];
+/** Legacy denominator kept only for unknown models (see modelContextWindow). */
+export declare const DEFAULT_CONTEXT_SIZE = 200000;
+/**
+ * Real input context window per model family, used as usage_update.size.
+ *
+ * Verified 2026-09: gemini-3.x flash = 1,048,576 input tokens;
+ * claude sonnet-4-6 / opus-4-6 = 1,000,000; gpt-oss-120b = 131,072.
+ * Unknown models fall back to DEFAULT_CONTEXT_SIZE (explicitly pessimistic).
+ *
+ * Override for any model via AGY_ACP_CONTEXT_SIZE (plain number, e.g. "1000000").
+ */
+export declare function modelContextWindow(model: unknown, env?: NodeJS.ProcessEnv): number;
 /**
  * Normalize safety mode.
  * Accepts: safe | autonomous | auto | autonomous-unsandboxed | autonomous_unsandboxed | unsandboxed
@@ -94,14 +106,20 @@ export type SafetyResolveInput = {
 /**
  * Central three-tier safety resolution.
  *
+ * Note on `--sandbox`: agy documents it only as "terminal restrictions enabled".
+ * It is NOT verified to mean offline. Assumed split:
+ * - model API + built-in cloud search tools: unaffected;
+ * - terminal network (`curl`, `Invoke-WebRequest`, `git clone`, `npm install`): may be blocked.
+ * Use two probes to confirm: built-in search vs `run_command` network.
+ *
  * Tiers:
- *   safe (default)              — no skip-permissions; sandbox only if explicitly true
- *   autonomous                  — skip-permissions; default --sandbox unless sandbox:false
+ *   safe                        — no skip-permissions; sandbox only if explicitly true
+ *   autonomous (default)        — skip-permissions; default --sandbox unless sandbox:false
  *   autonomous-unsandboxed      — skip-permissions; NEVER --sandbox
  *
  * Inputs:
  *   session.safety / AGY_ACP_SAFETY
- *   AGY_ACP_SKIP_PERMISSIONS=1 ≈ autonomous if safety unset; =0 ≈ safe
+ *   AGY_ACP_SKIP_PERMISSIONS=0 ≈ safe if safety unset; otherwise autonomous
  *   explicit session.skipPermissions overrides the skip flag only
  *   explicit session.sandbox / AGY_ACP_SANDBOX override sandbox except unsandboxed tier
  */
@@ -144,7 +162,7 @@ export declare function applyConfigOption(session: SessionLaunchFields, configId
  * they are used as-is. Otherwise resolveSafety(session) fills them from safety tier.
  *
  * Defaults:
- *   - safety: safe → skipPermissions false, sandbox false
+ *   - safety: autonomous → skipPermissions true, sandbox true
  *   - disableSlashCommands: true
  *   - printTimeout: "0"
  */

package/dist/lib/agy-discovery.d.ts

@@ -15,10 +15,16 @@ export declare function parseAgyModelsStdout(stdout: string): string[];
  * Accepts "id\\tname", "id name", or plain id-per-line.
  */
 export declare function parseAgyAgentsStdout(stdout: string): string[];
+/**
+ * Official supported Antigravity models (verified 14 models).
+ */
+export declare const DEFAULT_AGY_MODELS: string[];
+export declare const FALLBACK_MODELS: string[];
 export declare function discoverAgyCatalog(opts?: {
     bin?: string;
     timeoutMs?: number;
     force?: boolean;
+    dynamic?: boolean;
 }): Promise<DiscoveryResult>;
 /** Test helper: clear process-lifetime cache. */
 export declare function clearDiscoveryCache(): void;

package/dist/lib/agy-process.d.ts

@@ -22,6 +22,30 @@ export interface SpawnAgyOptions extends AgyProcessCallbacks {
     /** Optional override; manager increments its own generation when omitted. */
     generation?: number;
 }
+export interface AgyLaunchTarget {
+    bin: string;
+    args: string[];
+    /** True when a native Windows CREATE_NO_WINDOW shim is being used. */
+    headless: boolean;
+}
+/**
+ * Resolve the actual process target used for the Google CLI.
+ *
+ * Bun's Node-compatible spawn(..., {windowsHide: true}) is not sufficient for
+ * this CUI executable on every Windows runtime: the OS can still allocate a
+ * conhost.exe for agy.exe. The native shim creates agy with CREATE_NO_WINDOW
+ * and forwards all three standard streams unchanged.
+ */
+export declare function resolveAgyLaunchTarget(bin: string, args: string[]): AgyLaunchTarget;
+/**
+ * Generic variant: route ANY Windows console binary through the native
+ * headless launcher (CREATE_NO_WINDOW + stdio passthrough). Used for
+ * short-lived helpers (discovery, taskkill) that otherwise bypass the
+ * agy-specific resolver above. Returns the input unchanged off-Windows,
+ * when disabled, when the launcher is missing, or when the target already
+ * IS the launcher (recursion guard).
+ */
+export declare function resolveHeadlessTarget(bin: string, args: string[]): AgyLaunchTarget;
 /**
  * Per-session process supervisor. Tracks generation so late lines from a killed
  * child are ignored after a respawn.
@@ -30,10 +54,15 @@ export declare class AgyProcessManager {
     private child;
     private generation;
     private killInFlight;
+    private callbacks;
     get currentChild(): ChildProcess | null;
     get currentGeneration(): number;
     isAlive(): boolean;
     isWritable(): boolean;
+    /**
+     * Dynamically update callbacks for ongoing process (e.g. multi-turn sessions).
+     */
+    setCallbacks(callbacks: AgyProcessCallbacks): void;
     /**
      * Kill any existing child (await exit), then spawn a new one with a fresh generation.
      */

package/dist/lib/debug-log.d.ts

@@ -0,0 +1,2 @@
+export declare function debugLog(msg: string): void;
+export declare function installFileLogging(): string | null;

package/dist/lib/map-agy-to-acp.d.ts

@@ -10,6 +10,10 @@ export interface MapperState {
     agentMessageIds: Map<number, string>;
     thoughtMessageIds?: Map<number, string>;
     toolSeen: Set<number>;
+    /** Stable per-turn toolCallIds: stepIndex -> id (prevents cross-turn merge in Zed). */
+    toolIds: Map<number, string>;
+    /** Monotonic turn counter; part of toolCallId so step_index reuse never collides. */
+    turnSeq: number;
     lastStopReason?: string;
     turnDone?: boolean;
     emittedImageUris: Set<string>;
@@ -26,15 +30,19 @@ export interface AcpNotification {
     params: Record<string, unknown>;
 }
 export declare function createMapperState(richRoots?: FileToAcpImageOpts): MapperState;
-/** Reset per-turn tracking (keep conversationId / tools / richRoots). */
+/** Reset per-turn tracking (keep conversationId / tools / richRoots / turnSeq+1). */
 export declare function resetTurnState(state: MapperState): MapperState;
 export declare function guessToolKind(name: unknown): string;
-/** Format or downgrade updates according to client ACP protocol version (v1 vs v2). */
-export declare function formatUpdateForProtocol(update: Record<string, unknown>, protocolVersion: number): Record<string, unknown>;
+/** Format or adapt updates according to client ACP protocol version (v1 vs v2). */
+export declare function formatUpdateForProtocol(update: Record<string, unknown>, protocolVersion: number): Record<string, unknown> | null;
+export interface MapAgyEventOpts {
+    /** Session model id; selects the real context window for usage_update.size. */
+    model?: string;
+}
 /**
  * Map one agy NDJSON event object into zero or more ACP session/update notifications.
  */
-export declare function mapAgyEvent(sessionId: string, event: unknown, state: MapperState): {
+export declare function mapAgyEvent(sessionId: string, event: unknown, state: MapperState, opts?: MapAgyEventOpts): {
     notifications: AcpNotification[];
     state: MapperState;
 };

package/dist/lib/prompt-normalize.d.ts

@@ -1,5 +1,6 @@
 export interface NormalizeOpts {
     cwd: string;
+    sessionId?: string;
     stagingDir?: string;
     /** Max decoded bytes for a single blob (default 8MB). */
     maxBlobBytes?: number;
@@ -39,13 +40,27 @@ export declare function cleanupStaging(filesOrDir: string[] | string, opts?: {
     skipped: boolean;
 };
 /**
- * Clean `<cwd>/.agy-acp-staging` for a session (all files in that dir).
+ * Clean `<cwd>/.agy-acp-staging` for a session.
+ * When `sessionId` is provided, cleans exclusively `<cwd>/.agy-acp-staging/<sessionId>`
+ * without removing staging files belonging to other sessions under the same cwd.
  */
 export declare function cleanupSessionStaging(cwd: string, opts?: {
     keep?: boolean;
     stagingDir?: string;
+    sessionId?: string;
+    files?: string[];
 }): {
     removed: string[];
     skipped: boolean;
 };
+export interface PromptValidationResult {
+    ok: boolean;
+    reason?: string;
+}
+/**
+ * Synchronous pre-validation for ACP Prompt ContentBlocks.
+ * Ensures the prompt is a non-empty array and contains at least one
+ * content block with valid, non-empty data (text, resource, resource_link, image, audio).
+ */
+export declare function validatePromptBlocks(blocks: unknown): PromptValidationResult;
 export { STAGING_DIRNAME, };

package/dist/lib/session-history.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Small, display-oriented history journal.
+ *
+ * This is intentionally not a copy of agy's internal conversation database. It
+ * only stores the text that an ACP client can display: user prompts and final
+ * assistant text. Tool calls, tool output, thoughts, and internal events are
+ * deliberately excluded.
+ */
+export type SessionHistoryRole = 'user' | 'assistant';
+export type SessionHistoryRecord = {
+    version: 1;
+    sessionId: string;
+    messageId: string;
+    role: SessionHistoryRole;
+    text: string;
+    createdAt: string;
+};
+export declare function resolveHistoryDir(sessionStorePath?: string, env?: NodeJS.ProcessEnv, homedir?: () => string): string;
+export declare class SessionHistoryStore {
+    readonly directory: string;
+    constructor(directory?: string);
+    filePath(sessionId: string): string;
+    /**
+     * Append one completed turn as two JSONL records.
+     *
+     * The assistant record is omitted when the turn produced no visible final
+     * text. This keeps cancelled/error-only turns from becoming fake answers.
+     */
+    appendTurn(sessionId: string, userText: string, assistantText?: string): void;
+    /** Read valid records and ignore incomplete/corrupt trailing lines. */
+    read(sessionId: string): SessionHistoryRecord[];
+    delete(sessionId: string): void;
+}

package/dist/lib/session-store.d.ts

@@ -14,6 +14,7 @@ export type SessionRecord = {
     jsonSchema?: string;
     printTimeout?: string;
     disableSlashCommands?: boolean;
+    protocolVersion?: 1 | 2;
     createdAt: string;
     updatedAt: string;
 };
@@ -42,6 +43,7 @@ export declare function sessionToRecord(session: {
     jsonSchema?: string;
     printTimeout?: string;
     disableSlashCommands?: boolean;
+    protocolVersion?: 1 | 2;
 }): SessionRecord;
 /**
  * Fields needed to rehydrate an in-memory Session (no child process yet).
@@ -64,13 +66,19 @@ export declare function recordLaunchFields(record: SessionRecord): {
     jsonSchema?: string;
     printTimeout?: string;
     disableSlashCommands?: boolean;
+    protocolVersion?: 1 | 2;
 };
 export declare class SessionStore {
     readonly filePath: string;
     constructor(filePath?: string);
-    /** Read all records; missing/corrupt file → []. */
+    /** Read all records; missing/corrupt file → []; retries on transient locks. */
     load(): SessionRecord[];
-    /** Atomic write: temp file in same dir + rename. */
+    /**
+     * Acquire a cross-process file lock during read-modify-write operations
+     * to avoid lost updates between concurrent ACP services or test workers.
+     */
+    withLock<T>(fn: () => T): T;
+    /** Atomic write: temp file in same dir + rename with Windows retry backoff. */
     save(records: SessionRecord[]): void;
     upsert(record: SessionRecord): void;
     get(sessionId: string): SessionRecord | undefined;

package/dist/lib/soft-deny.d.ts

@@ -8,6 +8,13 @@
  * Also accepts explicit key=value fragments: tool=, allow-rule=, path=
  * And stream-json: tool ERROR with permission/denied wording + result.denied_actions
  *
+ * Sandbox note: `agy --help` documents `--sandbox` only as "terminal restrictions
+ * enabled". It does NOT state offline. Convention used here:
+ * - model API + built-in search tools: assumed unaffected;
+ * - terminal network (`curl`, `Invoke-WebRequest`, ...) may be blocked and is
+ *   surfaced separately with `source: *-sandbox` so callers can suggest
+ *   `safety: autonomous-unsandboxed` / `sandbox: false` retry.
+ *
  * v0.1.3: do NOT treat generic tool ERROR as soft-deny (tighten parseSoftDenyFromEvent).
  */
 export interface SoftDenyInfo {
@@ -32,5 +39,9 @@ export declare function parseSoftDenyFromEvent(event: unknown): SoftDenyInfo[];
 export declare function mergeSoftDenies(...lists: (SoftDenyInfo[] | undefined)[]): SoftDenyInfo[];
 /**
  * Format soft-denies into a short agent-facing note.
+ * Sandbox sources get a separate hint: built-in search is expected to keep
+ * working, terminal network (`curl`, `Invoke-WebRequest`, ...) may be blocked —
+ * retry the same prompt with `safety: autonomous-unsandboxed` / `sandbox: false`
+ * to distinguish the two paths.
  */
 export declare function formatSoftDenyMessage(denies: SoftDenyInfo[]): string;

package/dist/lib/win32-console.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Windows Console Window Self-Hiding Utility.
+ *
+ * When ACP stdio servers are launched on Windows by a GUI host (Zed, Electron, etc.),
+ * Windows kernel automatically allocates a visible conhost console window because
+ * Node/Bun are console subsystem binaries.
+ *
+ * Calling `hideConsoleWindow()` as early as possible in the server entry point
+ * immediately hides and detaches the console window via Win32 API, while keeping
+ * stdio pipes (pipe handles) 100% intact and functional.
+ */
+export declare function hideConsoleWindow(): void;

package/dist/router.d.ts

@@ -0,0 +1,7 @@
+import * as v2 from '@agentclientprotocol/sdk/experimental/v2';
+/**
+ * Dual router supporting both ACP v1 and v2 clients automatically.
+ * Shares the underlying AgySessionCore so sessions created in v1
+ * or v2 share the same runtime store and process supervisors.
+ */
+export declare function createDualAcpApp(sharedServiceOrCore?: any): v2.AgentProtocolRouter;

package/dist/v1/adapter.d.ts

@@ -0,0 +1,17 @@
+import { AgySessionCore } from '../core/session-core.ts';
+export declare class AgyAcpV1Service {
+    readonly core: AgySessionCore;
+    constructor(core?: AgySessionCore);
+    initialize(): Promise<any>;
+    newSession(params: any): Promise<any>;
+    resumeSession(params: any): Promise<any>;
+    loadSession(params: any, notifyClient: (update: any) => Promise<void> | void): Promise<any>;
+    setConfigOption(params: any): Promise<any>;
+    listSessions(params?: any): Promise<any>;
+    closeSession(params: any): Promise<any>;
+    deleteSession(params: any): Promise<any>;
+    cancelSession(params: any): void;
+    promptSession(params: any, notifyClient: (update: any) => Promise<void> | void): Promise<{
+        stopReason: string;
+    }>;
+}

package/dist/v1/app.d.ts

@@ -0,0 +1,6 @@
+import * as v1 from '@agentclientprotocol/sdk';
+import { AgyAcpV1Service } from './adapter.ts';
+/**
+ * Creates an ACP v1 agent app wrapped with official @agentclientprotocol/sdk.
+ */
+export declare function createAcpV1App(service?: AgyAcpV1Service | any): v1.AgentApp;

package/dist/v1/config.d.ts

@@ -0,0 +1,8 @@
+import type * as v1 from '@agentclientprotocol/sdk';
+import type { DiscoveryResult } from '../lib/agy-discovery.ts';
+import { type SdkSession } from '../core/types.ts';
+/**
+ * Builds standard ACP v1 session configuration options.
+ * In ACP v1, the selector ID field is named `id`.
+ */
+export declare function buildV1ConfigOptions(discovery: DiscoveryResult, session?: Pick<SdkSession, 'model' | 'agent'>): v1.SessionConfigOption[];

package/dist/v1/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.ts';
+export * from './config.ts';
+export * from './adapter.ts';
+export * from './app.ts';

package/dist/v1/types.d.ts

@@ -0,0 +1,10 @@
+export declare const V1_AGENT_CAPABILITIES: {
+    loadSession: boolean;
+    sessionCapabilities: {
+        list: {};
+        resume: {};
+        close: {};
+        delete: {};
+        additionalDirectories: {};
+    };
+};

package/dist/v2/adapter.d.ts

@@ -0,0 +1,18 @@
+import { AgySessionCore } from '../core/session-core.ts';
+export declare class AgyAcpV2Service {
+    readonly core: AgySessionCore;
+    constructor(core?: AgySessionCore);
+    initialize(): Promise<any>;
+    newSession(params: any): Promise<any>;
+    resumeSession(params: any, notifyClient?: (update: any) => Promise<void> | void): Promise<any>;
+    setConfigOption(params: any): Promise<any>;
+    listSessions(params?: any): Promise<any>;
+    closeSession(params: any): Promise<any>;
+    deleteSession(params: any): Promise<any>;
+    cancelSession(params: any): void;
+    promptSession(params: any, notifyClient: (update: any) => Promise<void> | void, opts?: {
+        isPreLocked?: boolean;
+    }): Promise<{
+        stopReason: string;
+    }>;
+}

package/dist/v2/app.d.ts

@@ -0,0 +1,6 @@
+import * as v2 from '@agentclientprotocol/sdk/experimental/v2';
+import { AgyAcpV2Service } from './adapter.ts';
+/**
+ * Creates an ACP v2 agent app wrapped with official @agentclientprotocol/sdk.
+ */
+export declare function createAcpV2App(service?: AgyAcpV2Service | any): v2.AgentApp;

package/dist/v2/config.d.ts

@@ -0,0 +1,8 @@
+import type * as v2 from '@agentclientprotocol/sdk/experimental/v2';
+import type { DiscoveryResult } from '../lib/agy-discovery.ts';
+import { type SdkSession } from '../core/types.ts';
+/**
+ * Builds experimental ACP v2 session configuration options.
+ * In ACP v2, the selector ID field is named `configId`.
+ */
+export declare function buildV2ConfigOptions(discovery: DiscoveryResult, session?: Pick<SdkSession, 'model' | 'agent'>): v2.SessionConfigOption[];

package/dist/v2/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.ts';
+export * from './config.ts';
+export * from './adapter.ts';
+export * from './app.ts';

package/dist/v2/types.d.ts

@@ -0,0 +1,6 @@
+export declare const V2_AGENT_CAPABILITIES: {
+    session: {
+        additionalDirectories: {};
+        delete: {};
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yitom/agy-acp-map",
-  "version": "0.1.3",
+  "version": "0.1.6",
   "publishConfig": {
     "access": "public"
   },
@@ -25,17 +25,25 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "bun run build:js && bun run build:types",
+    "build": "bun run build:js && bun run build:types && bun run build:headless",
+    "build:headless": "bun scripts/build-headless.ts",
     "build:js": "bun build src/sdk-server.ts --target node --outfile dist/bin.js && bun build src/index.ts --target node --outfile dist/index.js",
+    "build:exe": "bun build src/sdk-server.ts --compile --target=bun-windows-x64 --outfile dist/agy-acp-win-x64.exe",
     "build:types": "bunx tsc -p tsconfig.build.json",
-    "prepublishOnly": "bun run build && bun test src/lib",
+    "release:patch": "bun scripts/release.ts",
+    "release:publish": "bun scripts/release.ts --publish",
+    "prepublishOnly": "bun run build && bun test --timeout 30000",
     "start": "bun src/sdk-server.ts",
     "start:dist": "node dist/bin.js",
     "start:legacy": "bun archive/legacy-server.ts",
     "map": "bun src/map.ts",
-    "test": "bun test src/lib",
+    "test": "bun test --timeout 30000",
+    "test:unit": "bun test src/lib",
+    "test:integration": "bun test tests/protocol-integration.test.ts",
+    "test:wire": "bun test tests/protocol-wire-stdio.test.ts",
     "test:args": "bun tests/test-agy-args.ts",
     "smoke": "bun tests/smoke/smoke-basic.ts",
+    "smoke:v2": "bun tests/smoke/smoke-v2-draft.ts",
     "smoke:flags": "bun tests/smoke/smoke-flags.ts",
     "smoke:permissions": "bun tests/smoke/smoke-permissions.ts",
     "smoke:image-in": "bun tests/smoke/smoke-image-in.ts",