@beeos-ai/device-agent 0.4.0

package/dist/ports/agent-host.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Port — AgentHost.
+ *
+ * The host is the in-process event bus that sits between an `IAgentCore`
+ * and any number of `AgentPlugin`s (ACP, HTTP debug, agent-sync, custom).
+ *
+ * Plugins call `host.submitTask(...)` to ask the agent to do something
+ * and `host.on(...)` to subscribe to lifecycle / streaming events.
+ * The host:
+ *
+ *   - assigns a stable `taskId`
+ *   - propagates `taskId` to the logging correlation context
+ *   - translates `IAgentCore` callbacks (onText / onReasoning / onTool /
+ *     onStep) into a typed `AgentEvent` union
+ *   - tracks abort controllers for `cancel(taskId)`
+ *   - exposes `host.agent` for plugins that need to call `setModel`
+ *
+ * Plugins MUST NOT call `IAgentCore.run` directly — go through
+ * `host.submitTask` so cancellation, correlation, and event fan-out
+ * remain in one place.
+ */
+import type { AgentCoreRunResult, IAgentCore, ToolCallEvent, VlmStep } from "./agent-core.js";
+import type { DeviceManager } from "../app/device-manager.js";
+import type { IDeviceIdentity } from "./identity.js";
+/**
+ * Every AgentEvent carries:
+ *
+ *   - `taskId`    — `host.submitTask` allocated id (legacy correlation)
+ *   - `turnId`    — ACP `_turnId`. Right now we mirror `taskId` 1:1 so a
+ *                   single `session/prompt` => one logical turn; downstream
+ *                   plugins should NEVER assume `turnId === taskId` (mobile
+ *                   may want to fan one task into multiple visual turns).
+ *
+ * Events that translate into ACP `session/update` envelopes also carry
+ * `messageId` — the **per-task authoritative message id** that all of
+ * `agent_message_chunk` / `agent_thought_chunk` / `tool_call` /
+ * `tool_call_update` / `task:notice` share so chat-store's sidecar
+ * resolver can pin them to the same assistant bubble.
+ */
+export type AgentEvent = {
+    type: "task:start";
+    taskId: string;
+    turnId: string;
+    prompt: string;
+    createdAt: number;
+} | {
+    type: "task:text";
+    taskId: string;
+    turnId: string;
+    messageId: string;
+    text: string;
+} | {
+    type: "task:reasoning";
+    taskId: string;
+    turnId: string;
+    messageId: string;
+    text: string;
+} | {
+    type: "task:tool";
+    taskId: string;
+    turnId: string;
+    messageId: string;
+    tool: ToolCallEvent;
+} | {
+    type: "task:step";
+    taskId: string;
+    turnId: string;
+    messageId: string;
+    step: VlmStep & {
+        stepIndex: number;
+    };
+} | {
+    type: "task:notice";
+    taskId: string;
+    turnId: string;
+    messageId: string;
+    level: "warn" | "error";
+    text: string;
+} | {
+    type: "task:end";
+    taskId: string;
+    turnId: string;
+    result: AgentCoreRunResult;
+    error?: string;
+    completedAt: number;
+};
+export type AgentEventListener = (event: AgentEvent) => void | Promise<void>;
+export interface SubmitTaskOptions {
+    /** Free-form per-task tag forwarded to logs (e.g. ACP sessionId). */
+    correlationTag?: string;
+    /** Optional caller-supplied AbortSignal merged with the host's controller. */
+    abortSignal?: AbortSignal;
+    /** Soft cap on inner steps (forwarded to `IAgentCore.run`). */
+    maxSteps?: number;
+}
+export interface SubmittedTask {
+    taskId: string;
+    /** Resolves when the task settles (success or failure). Never rejects. */
+    done: Promise<AgentCoreRunResult>;
+    /** Cancel this specific task. Returns true if a cancel was actually issued. */
+    cancel: () => boolean;
+}
+/**
+ * AgentHost — the runtime container plugins are wired against.
+ *
+ * Implementations live in `app/agent-host.ts`. Tests construct the host
+ * with mocked `IAgentCore` / `DeviceManager` to drive plugins without
+ * spinning up a real model.
+ */
+export interface AgentHost {
+    /** The agent core (rare direct use — `setModel`, etc.). */
+    readonly agent: IAgentCore;
+    /** Device registry (plugins like HTTP debug surface device info). */
+    readonly devices: DeviceManager;
+    /** Optional Ed25519 identity (agent-sync / future signed plugins). */
+    readonly identity?: IDeviceIdentity;
+    /** Submit a task; returns the task handle synchronously. */
+    submitTask(prompt: string, opts?: SubmitTaskOptions): SubmittedTask;
+    /** Subscribe to all events. Returns an `unsubscribe` function. */
+    on(listener: AgentEventListener): () => void;
+    /** Cancel by `taskId`. Returns true if the task was running. */
+    cancel(taskId: string): boolean;
+    /** Cancel every running task (used during shutdown). */
+    cancelAll(): Promise<void>;
+}

package/dist/ports/agent-host.js

@@ -0,0 +1,23 @@
+/**
+ * Port — AgentHost.
+ *
+ * The host is the in-process event bus that sits between an `IAgentCore`
+ * and any number of `AgentPlugin`s (ACP, HTTP debug, agent-sync, custom).
+ *
+ * Plugins call `host.submitTask(...)` to ask the agent to do something
+ * and `host.on(...)` to subscribe to lifecycle / streaming events.
+ * The host:
+ *
+ *   - assigns a stable `taskId`
+ *   - propagates `taskId` to the logging correlation context
+ *   - translates `IAgentCore` callbacks (onText / onReasoning / onTool /
+ *     onStep) into a typed `AgentEvent` union
+ *   - tracks abort controllers for `cancel(taskId)`
+ *   - exposes `host.agent` for plugins that need to call `setModel`
+ *
+ * Plugins MUST NOT call `IAgentCore.run` directly — go through
+ * `host.submitTask` so cancellation, correlation, and event fan-out
+ * remain in one place.
+ */
+export {};
+//# sourceMappingURL=agent-host.js.map

package/dist/ports/agent-host.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-host.js","sourceRoot":"","sources":["../../src/ports/agent-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/ports/device.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Port — abstract device adapter.
+ *
+ * Implementations:
+ *  - adapters/device-android-adb.ts (production)
+ *  - adapters/device-desktop.ts     (mock / desktop runtime)
+ *  - tests/unit/adapters/...        (in-memory test doubles)
+ *
+ * The application layer depends ONLY on this interface; concrete child_process /
+ * sharp / OS-native calls live entirely in adapters.
+ */
+import type { Action } from "../core/actions.js";
+import type { ScreenObservation, UiNode } from "../core/screen.js";
+export type DeviceType = "android" | "chromeos" | "desktop-linux" | "desktop-windows" | "desktop-macos";
+/**
+ * ACP wire v2 capability vocabulary — per-action verbs that callers can probe
+ * with `device/info` to decide whether to attempt a feature. New capabilities
+ * MUST be added to the union before adapters can advertise them.
+ */
+export type DeviceCapability = "screenshot" | "ui-tree" | "tap" | "swipe" | "type" | "press_key" | "install" | "shell";
+export interface DeviceInfo {
+    type: DeviceType;
+    name: string;
+    os: string;
+    width: number;
+    height: number;
+    capabilities: DeviceCapability[];
+    osVersion: string;
+    density: number;
+    metadata: Record<string, string>;
+}
+export interface IDevice {
+    /** Connect / warm up the underlying transport. */
+    connect(): Promise<void>;
+    /** Cleanly disconnect; safe to call multiple times. */
+    disconnect(): Promise<void>;
+    getInfo(): Promise<DeviceInfo>;
+    /**
+     * Capture screen as raw PNG bytes when *raw* is true; otherwise return a
+     * compressed JPEG suitable for VLM inputs.
+     */
+    capture(opts?: {
+        raw?: boolean;
+    }): Promise<ScreenObservation>;
+    /** Dump the accessibility / uiautomator hierarchy. */
+    getUiTree(): Promise<UiNode[]>;
+    /** Apply a typed action. */
+    apply(action: Action): Promise<void>;
+    /** Install an APK / package from a local file path. */
+    install(path: string): Promise<void>;
+    /** Run an arbitrary shell command and return stdout. */
+    shell(command: string): Promise<string>;
+}

package/dist/ports/device.js

@@ -0,0 +1,13 @@
+/**
+ * Port — abstract device adapter.
+ *
+ * Implementations:
+ *  - adapters/device-android-adb.ts (production)
+ *  - adapters/device-desktop.ts     (mock / desktop runtime)
+ *  - tests/unit/adapters/...        (in-memory test doubles)
+ *
+ * The application layer depends ONLY on this interface; concrete child_process /
+ * sharp / OS-native calls live entirely in adapters.
+ */
+export {};
+//# sourceMappingURL=device.js.map

package/dist/ports/device.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"device.js","sourceRoot":"","sources":["../../src/ports/device.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/ports/identity.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Port — device identity (Ed25519 keypair).
+ *
+ * Production adapter `identity-file.ts` reads / writes JSON files in
+ * `~/.beeos/identity/` using the `@beeos-ai/bridge-client` keys helpers.
+ * Tests use an in-memory adapter.
+ */
+export interface KeyPair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+export interface IDeviceIdentity {
+    /**
+     * Return the existing keypair, or create one and persist it on first call.
+     * Idempotent.
+     */
+    ensure(): Promise<KeyPair>;
+    /** Base64 of the public key. */
+    publicKeyBase64(): Promise<string>;
+    /** SHA-256 hex fingerprint of the public key. */
+    fingerprint(): Promise<string>;
+}

package/dist/ports/identity.js

@@ -0,0 +1,9 @@
+/**
+ * Port — device identity (Ed25519 keypair).
+ *
+ * Production adapter `identity-file.ts` reads / writes JSON files in
+ * `~/.beeos/identity/` using the `@beeos-ai/bridge-client` keys helpers.
+ * Tests use an in-memory adapter.
+ */
+export {};
+//# sourceMappingURL=identity.js.map

package/dist/ports/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/ports/identity.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/ports/plugin.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Port — AgentPlugin.
+ *
+ * Plugins are modular extensions wired by `bootstrap()` after the
+ * `AgentHost` has been constructed. Built-in plugins:
+ *
+ *   - `plugins/acp/`         — Bridge WS + ACP JSON-RPC (default)
+ *   - `plugins/http-debug/`  — local HTTP REST API for debugging
+ *   - `plugins/agent-sync/`  — registers the agent with Agent Identity
+ *
+ * Authoring a custom plugin:
+ *
+ * ```ts
+ * import type { AgentPlugin } from "@beeos-ai/device-agent/ports/plugin.js";
+ *
+ * export const myPlugin: AgentPlugin = {
+ *   name: "my-plugin",
+ *   async init(ctx) {
+ *     ctx.host.on((ev) => {
+ *       if (ev.type === "task:end") ctx.log.info({ ev }, "task done");
+ *     });
+ *   },
+ *   async start() { ... },
+ *   async stop()  { ... },
+ * };
+ * ```
+ *
+ * Lifecycle ordering:
+ *   - bootstrap() registers plugins in declaration order
+ *   - init(ctx) runs sequentially (subscriptions / handler registration)
+ *   - start()    runs sequentially (long-lived loops, transports, listeners)
+ *   - stop()     runs in REVERSE order on shutdown
+ */
+import type { Logger } from "pino";
+import type { Config } from "../config/schema.js";
+import type { AgentHost } from "./agent-host.js";
+export interface PluginContext {
+    host: AgentHost;
+    config: Config;
+    log: Logger;
+}
+export interface AgentPlugin {
+    /** Unique, stable plugin name (used for logging / disable filters). */
+    readonly name: string;
+    /**
+     * Wire up listeners / register handlers / open file descriptors that
+     * MUST be ready before any other plugin starts. Called once,
+     * sequentially, in registration order.
+     */
+    init?(ctx: PluginContext): void | Promise<void>;
+    /**
+     * Open long-lived resources — transports, network listeners, timers.
+     * Called sequentially after every plugin's `init` has resolved.
+     */
+    start?(): void | Promise<void>;
+    /**
+     * Tear down resources. Called in REVERSE registration order during
+     * `bootstrap`'s returned `stop()` function. Implementations should be
+     * idempotent and swallow their own errors.
+     */
+    stop?(): void | Promise<void>;
+}

package/dist/ports/plugin.js

@@ -0,0 +1,35 @@
+/**
+ * Port — AgentPlugin.
+ *
+ * Plugins are modular extensions wired by `bootstrap()` after the
+ * `AgentHost` has been constructed. Built-in plugins:
+ *
+ *   - `plugins/acp/`         — Bridge WS + ACP JSON-RPC (default)
+ *   - `plugins/http-debug/`  — local HTTP REST API for debugging
+ *   - `plugins/agent-sync/`  — registers the agent with Agent Identity
+ *
+ * Authoring a custom plugin:
+ *
+ * ```ts
+ * import type { AgentPlugin } from "@beeos-ai/device-agent/ports/plugin.js";
+ *
+ * export const myPlugin: AgentPlugin = {
+ *   name: "my-plugin",
+ *   async init(ctx) {
+ *     ctx.host.on((ev) => {
+ *       if (ev.type === "task:end") ctx.log.info({ ev }, "task done");
+ *     });
+ *   },
+ *   async start() { ... },
+ *   async stop()  { ... },
+ * };
+ * ```
+ *
+ * Lifecycle ordering:
+ *   - bootstrap() registers plugins in declaration order
+ *   - init(ctx) runs sequentially (subscriptions / handler registration)
+ *   - start()    runs sequentially (long-lived loops, transports, listeners)
+ *   - stop()     runs in REVERSE order on shutdown
+ */
+export {};
+//# sourceMappingURL=plugin.js.map

package/dist/ports/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/ports/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG"}

package/dist/ports/transport.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Port — Bridge transport for ACP messages.
+ *
+ * Production adapter: `adapters/transport-bridge-ws.ts` wraps
+ * `@beeos-ai/bridge-client` (WebSocket + Ed25519 `agent_auth` handshake +
+ * automatic reconnect).
+ *
+ * Tests can plug an in-memory fake that captures sent messages and replays
+ * canned ones to drive ACP roundtrip tests.
+ */
+export type TransportEventHandler = {
+    kind: "connected";
+    handler: () => void;
+} | {
+    kind: "disconnected";
+    handler: (reason: string) => void;
+} | {
+    kind: "message";
+    handler: (data: string) => void | Promise<void>;
+} | {
+    kind: "error";
+    handler: (err: Error) => void;
+};
+export interface IBridgeTransport {
+    connect(): Promise<void>;
+    send(data: string): Promise<void>;
+    close(): Promise<void>;
+    on(event: "connected", handler: () => void): void;
+    on(event: "disconnected", handler: (reason: string) => void): void;
+    on(event: "message", handler: (data: string) => void | Promise<void>): void;
+    on(event: "error", handler: (err: Error) => void): void;
+}

package/dist/ports/transport.js

@@ -0,0 +1,12 @@
+/**
+ * Port — Bridge transport for ACP messages.
+ *
+ * Production adapter: `adapters/transport-bridge-ws.ts` wraps
+ * `@beeos-ai/bridge-client` (WebSocket + Ed25519 `agent_auth` handshake +
+ * automatic reconnect).
+ *
+ * Tests can plug an in-memory fake that captures sent messages and replays
+ * canned ones to drive ACP roundtrip tests.
+ */
+export {};
+//# sourceMappingURL=transport.js.map

package/dist/ports/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/ports/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/ports/vlm.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Port — Vision-Language Model client.
+ *
+ * The inner `Agent` (legacy `src/agent.ts`) consumes a richer `ModelClient`
+ * surface (buildMessages / request / parseResponse / updateContext). This port
+ * exposes the **outer** semantic the application layer needs: "given an
+ * instruction and a screen observation, return one parsed Action plus
+ * thinking text, or signal completion".
+ *
+ * The default adapter delegates straight to the existing `Agent` so the inner
+ * VLM loop stays untouched and battle-tested.
+ */
+import type { VlmStep as AgentCoreVlmStep } from "./agent-core.js";
+/**
+ * @deprecated since the IAgentCore introduction — re-exported from
+ * `ports/agent-core.ts` so existing imports keep compiling. New code should
+ * import `VlmStep` from `ports/agent-core.js` directly.
+ */
+export type VlmStep = AgentCoreVlmStep;
+export interface IVlm {
+    /** Identifier the agent reports back to BeeOS (e.g. `gpt-4o`). */
+    readonly modelName: string;
+    /**
+     * Provider hint last applied via `setProvider`. Empty when the implementation
+     * was constructed with provider auto-detection.
+     */
+    readonly providerName?: string;
+    /**
+     * Run a single instruction to completion using the model's own
+     * screenshot→reason→act loop. The implementation is responsible for
+     * calling `device.capture()` / `device.apply()` as needed.
+     *
+     * @param onStep Called once per step (after each VLM round-trip).
+     */
+    runTask(opts: {
+        task: string;
+        maxSteps: number;
+        /** Streaming text delta from the model (newer adapters). */
+        onText?: (text: string) => void | Promise<void>;
+        onStep?: (step: VlmStep & {
+            stepIndex: number;
+        }) => void | Promise<void>;
+        abortSignal?: AbortSignal;
+    }): Promise<{
+        finalMessage: string;
+        steps: number;
+        cancelled: boolean;
+    }>;
+    /**
+     * Hot-swap provider+model at runtime. `provider` is the human-friendly tag
+     * (e.g. "openai", "qwen", "uitars") and is used to select the correct
+     * adapter; `model` is the upstream model id passed straight through to the
+     * provider API.
+     *
+     * Implementations should be safe to call between tasks — concurrent in-flight
+     * tasks may continue with the previous client until they settle.
+     */
+    setProvider(provider: string, model: string): Promise<void>;
+}

package/dist/ports/vlm.js

@@ -0,0 +1,14 @@
+/**
+ * Port — Vision-Language Model client.
+ *
+ * The inner `Agent` (legacy `src/agent.ts`) consumes a richer `ModelClient`
+ * surface (buildMessages / request / parseResponse / updateContext). This port
+ * exposes the **outer** semantic the application layer needs: "given an
+ * instruction and a screen observation, return one parsed Action plus
+ * thinking text, or signal completion".
+ *
+ * The default adapter delegates straight to the existing `Agent` so the inner
+ * VLM loop stays untouched and battle-tested.
+ */
+export {};
+//# sourceMappingURL=vlm.js.map

package/dist/ports/vlm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vlm.js","sourceRoot":"","sources":["../../src/ports/vlm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/test-lan-autoglm.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 验证局域网 OpenAI 兼容 AutoGLM 与 device-agent-ts 内层链路（adapter=autoglm + OpenAIClient）。
+ * 需要：adb 已连机、本机可访问 GUI_AGENT_BASE_URL、.env 已配置。
+ *
+ *   npx tsx src/test-lan-autoglm.ts
+ */
+import "dotenv/config";

package/dist/test-lan-autoglm.js

@@ -0,0 +1,46 @@
+/**
+ * 验证局域网 OpenAI 兼容 AutoGLM 与 device-agent-ts 内层链路（adapter=autoglm + OpenAIClient）。
+ * 需要：adb 已连机、本机可访问 GUI_AGENT_BASE_URL、.env 已配置。
+ *
+ *   npx tsx src/test-lan-autoglm.ts
+ */
+import "dotenv/config";
+import { AndroidDevice } from "./device/android.js";
+import { OpenAIClient } from "./model/client.js";
+const TASK = process.env.LAN_VLM_SMOKE_TASK ??
+    "看当前截图，只输出一行下一步操作（不要复述用户原话里的示例代码）：用 do(action=\"Tap\", element=[x,y]) 点击你认为该点的位置，坐标 0–1000。";
+async function main() {
+    const base = process.env.GUI_AGENT_BASE_URL ?? "";
+    const model = process.env.GUI_AGENT_MODEL ?? "";
+    if (!base || !model) {
+        console.error("请设置 GUI_AGENT_BASE_URL、GUI_AGENT_MODEL（及 API_KEY）");
+        process.exit(1);
+    }
+    console.log(`[lan-autoglm] base=${base} model=${model} adapter=${process.env.GUI_AGENT_ADAPTER ?? "(auto)"} stream=${process.env.GUI_AGENT_STREAM ?? "1"}`);
+    const device = new AndroidDevice(process.env.GUI_AGENT_DEVICE_ID ?? undefined);
+    const ss = await device.takeScreenshot();
+    const currentApp = await device.getCurrentApp();
+    const client = new OpenAIClient({
+        adapter: process.env.GUI_AGENT_ADAPTER ?? "autoglm",
+    });
+    const screenInfo = {
+        screenshotB64: ss.base64Data,
+        width: ss.width,
+        height: ss.height,
+        currentApp,
+        uiXml: null,
+    };
+    const messages = client.buildMessages(TASK, screenInfo, [], true, (process.env.GUI_AGENT_LANG ?? "cn"));
+    console.log(`[lan-autoglm] requesting… (${messages.length} messages, jpeg b64 ~${Math.round(ss.base64Data.length / 1024)} KB)`);
+    const t0 = Date.now();
+    const resp = await client.request(messages, true);
+    const ms = Date.now() - t0;
+    console.log("\n--- raw (prefix) ---\n", resp.rawContent.slice(0, 1500), resp.rawContent.length > 1500 ? "\n…" : "");
+    console.log("\n--- parsed ---\n", JSON.stringify(client.parseResponse(resp.rawContent), null, 2));
+    console.log(`\n[lan-autoglm] ok in ${ms} ms`);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});
+//# sourceMappingURL=test-lan-autoglm.js.map

package/dist/test-lan-autoglm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-lan-autoglm.js","sourceRoot":"","sources":["../src/test-lan-autoglm.ts"],"names":[],"mappings":"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"}

package/dist/test-mem-breakdown.d.ts

@@ -0,0 +1 @@
+import "dotenv/config";

package/dist/test-mem-breakdown.js

@@ -0,0 +1,103 @@
+import "dotenv/config";
+// Memory diagnostic: peel back each layer to see where the 200MB goes.
+// Run with:  npx tsx --expose-gc src/test-mem-breakdown.ts
+function mb(n) { return (n / 1024 / 1024).toFixed(1); }
+function rss() { return process.memoryUsage().rss; }
+function heap() { return process.memoryUsage().heapUsed; }
+function ext() { return process.memoryUsage().external; }
+function snap(label, baseline) {
+    const m = process.memoryUsage();
+    const delta = baseline !== undefined ? ` (Δrss=${mb(m.rss - baseline)}MB)` : "";
+    console.log(`[${label.padEnd(28)}] rss=${mb(m.rss)}MB heap=${mb(m.heapUsed)}MB ext=${mb(m.external)}MB${delta}`);
+    return m.rss;
+}
+async function waitGc() {
+    if (global.gc) {
+        global.gc();
+        global.gc();
+    }
+    await new Promise(r => setTimeout(r, 50));
+}
+console.log("=".repeat(78));
+console.log("Memory Breakdown Diagnostic");
+console.log("=".repeat(78));
+// ── Layer 0: bare node ──────────────────────────────────────────────────────
+const bare = snap("0. bare node (tsx loader)");
+// ── Layer 1: dotenv + types (already loaded at top, but measure current) ────
+const l1 = snap("1. + dotenv", bare);
+// ── Layer 2: load openai SDK ────────────────────────────────────────────────
+await import("openai");
+const l2 = snap("2. + openai sdk", l1);
+// ── Layer 3: load sharp (triggers libvips mmap) ─────────────────────────────
+const sharpMod = await import("sharp");
+const l3 = snap("3. + sharp (libvips mmap)", l2);
+// ── Layer 4: load our Device layer ──────────────────────────────────────────
+const { AndroidDevice } = await import("./device/android.js");
+const l4 = snap("4. + device/android", l3);
+// ── Layer 5: instantiate device + check adb exists ──────────────────────────
+const dev = new AndroidDevice(process.env.GUI_AGENT_DEVICE_ID);
+const l5 = snap("5. + new AndroidDevice()", l4);
+// ── Layer 6: load agent + model adapters ────────────────────────────────────
+const { Agent } = await import("./agent.js");
+const { OpenAIClient } = await import("./model/client.js");
+await import("./model/adapters/index.js");
+const l6 = snap("6. + agent + all adapters", l5);
+// ── Layer 7: instantiate model client (openai client w/ keep-alive) ─────────
+const client = new OpenAIClient({ adapter: process.env.GUI_AGENT_ADAPTER });
+const l7 = snap("7. + new OpenAIClient()", l6);
+// ── Layer 8: take one screenshot (triggers sharp pipeline + buffer) ─────────
+await dev.takeScreenshot();
+await waitGc();
+const l8 = snap("8. + 1 screenshot (post-gc)", l7);
+// ── Layer 9: take 5 screenshots back-to-back ────────────────────────────────
+let peak9 = l8;
+for (let i = 0; i < 5; i++) {
+    await dev.takeScreenshot();
+    peak9 = Math.max(peak9, rss());
+}
+await waitGc();
+const l9 = snap("9. + 5 screenshots (post-gc)", l8);
+console.log(`   └─ intra-loop peak rss=${mb(peak9)}MB`);
+// ── Layer 10: instantiate agent ─────────────────────────────────────────────
+const agent = new Agent(client, dev, { maxSteps: 3, verbose: false });
+const l10 = snap("10. + new Agent()", l9);
+// ── Layer 11: run 1 full agent step (includes API call if connected) ────────
+let peak11 = l10;
+const before = rss();
+try {
+    await agent.run("打开系统设置");
+    peak11 = Math.max(peak11, rss());
+}
+catch (e) {
+    // ignore — we just want memory delta
+}
+await waitGc();
+const l11 = snap("11. + agent.run() (post-gc)", l10);
+console.log(`   └─ intra-run peak rss=${mb(peak11)}MB (Δ from pre-run=${mb(peak11 - before)}MB)`);
+// ── Summary ─────────────────────────────────────────────────────────────────
+console.log("=".repeat(78));
+console.log("Component Breakdown (incremental RSS additions, MB)");
+console.log("=".repeat(78));
+const rows = [
+    ["Node.js + tsx loader baseline", bare],
+    ["+ dotenv", l1 - bare],
+    ["+ openai SDK", l2 - l1],
+    ["+ sharp (libvips native mmap)", l3 - l2],
+    ["+ device layer (adb client)", l4 - l3],
+    ["+ AndroidDevice instance", l5 - l4],
+    ["+ agent + all model adapters", l6 - l5],
+    ["+ OpenAI client (keep-alive pool)", l7 - l6],
+    ["+ first screenshot (warm cache)", l8 - l7],
+    ["+ 4 more screenshots", l9 - l8],
+    ["+ Agent instance", l10 - l9],
+    ["+ agent.run() full cycle", l11 - l10],
+];
+for (const [label, delta] of rows) {
+    console.log(`  ${label.padEnd(42)} ${(delta / 1024 / 1024).toFixed(1).padStart(6)} MB`);
+}
+console.log("-".repeat(78));
+console.log(`  TOTAL steady-state RSS:                   ${mb(l11).padStart(6)} MB`);
+console.log(`  Peak RSS during run:                      ${mb(peak11).padStart(6)} MB  (transient request buffer)`);
+console.log("=".repeat(78));
+process.exit(0);
+//# sourceMappingURL=test-mem-breakdown.js.map