@mlx-node/agent 0.0.8 → 0.0.10

package/dist/catalog.d.ts

@@ -23,4 +23,19 @@ export interface CatalogEntry {
 export declare const MODEL_CATALOG: readonly CatalogEntry[];
 /** Catalog entries the wizard offers (hidden entries filtered out). */
 export declare function visibleCatalog(): CatalogEntry[];
+/**
+ * Cold-tier facts, re-exported through this subpath.
+ *
+ * `@mlx-node/agent/catalog` is the agent package's one NATIVE-FREE entry point:
+ * the package root re-exports `provider/index.ts`, which value-imports
+ * `@mlx-node/core`. The dashboard is a separate viewer process that must never
+ * link the addon (docs/dashboard.md: "no Metal init, instant start"), and
+ * `mlx agent --help` must print without loading weights — so both reach the
+ * cold-tier allowlist and the cache-root canonicalizer through here.
+ *
+ * These are RE-EXPORTS. The definitions live in `./cold-tier.ts` and there is
+ * exactly one of each; `packages/agent/__test__/cold-tier-families.test.ts`
+ * guards the allowlist against the native side.
+ */
+export { COLD_TIER_RESTORE_FAMILIES, canonicalCacheRoot, coldTierRestoreFamilyList } from './cold-tier.js';
 //# sourceMappingURL=catalog.d.ts.map

package/dist/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,aAAa,EAAE,SAAS,YAAY,EA+BhD,CAAC;AAEF,uEAAuE;AACvE,wBAAgB,cAAc,IAAI,YAAY,EAAE,CAE/C"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../src/catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,eAAO,MAAM,aAAa,EAAE,SAAS,YAAY,EA+BhD,CAAC;AAEF,uEAAuE;AACvE,wBAAgB,cAAc,IAAI,YAAY,EAAE,CAE/C;AAED;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/catalog.js

@@ -42,3 +42,18 @@ export const MODEL_CATALOG = [
 export function visibleCatalog() {
     return MODEL_CATALOG.filter((entry) => !entry.hidden);
 }
+/**
+ * Cold-tier facts, re-exported through this subpath.
+ *
+ * `@mlx-node/agent/catalog` is the agent package's one NATIVE-FREE entry point:
+ * the package root re-exports `provider/index.ts`, which value-imports
+ * `@mlx-node/core`. The dashboard is a separate viewer process that must never
+ * link the addon (docs/dashboard.md: "no Metal init, instant start"), and
+ * `mlx agent --help` must print without loading weights — so both reach the
+ * cold-tier allowlist and the cache-root canonicalizer through here.
+ *
+ * These are RE-EXPORTS. The definitions live in `./cold-tier.ts` and there is
+ * exactly one of each; `packages/agent/__test__/cold-tier-families.test.ts`
+ * guards the allowlist against the native side.
+ */
+export { COLD_TIER_RESTORE_FAMILIES, canonicalCacheRoot, coldTierRestoreFamilyList } from './cold-tier.js';

package/dist/cold-tier.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Cold-tier facts shared by the agent (writer), the CLI (help text) and the
+ * dashboard (reader), kept in a NATIVE-FREE leaf module.
+ *
+ * `provider/model-host.ts` value-imports `@mlx-node/lm`, which loads the native
+ * addon; the dashboard is a separate viewer process that must never link it
+ * ("no Metal init, instant start" — docs/dashboard.md), and `mlx agent --help`
+ * must print without loading weights. This module therefore has NO runtime
+ * imports beyond `node:` builtins, and reaches those consumers through the
+ * existing native-free `@mlx-node/agent/catalog` subpath, which re-exports it.
+ * There is deliberately no `./cold-tier` entry in `package.json`: a second
+ * published subpath would be a second thing to keep native-free, and `catalog`
+ * already carries that guarantee.
+ *
+ * Everything here is a single source of truth. Do not copy the family list or
+ * re-implement the root canonicalization at a call site; import them.
+ */
+/**
+ * Model families whose paged prefix blocks can be restored from the SSD cold
+ * tier soundly. The single source of truth on the TypeScript side, mirroring
+ * `COLD_RESTORE_FAMILIES` in `crates/mlx-core/src/cold_tier.rs`; the two gate
+ * the same decision from opposite ends, and
+ * `packages/agent/__test__/cold-tier-families.test.ts` asserts they never
+ * drift.
+ *
+ * A family belongs here only when EVERY piece of per-token state its forward
+ * pass carries between turns is reconstructible from the tier — either because
+ * it all lives inside the paged pool, or because the part that does not is
+ * persisted alongside as a cold-tier sidecar and the restore reconciles down to
+ * a boundary that sidecar actually backs:
+ *
+ *  - `qwen3` (dense) sizes its pool over all layers, so the pool holds the
+ *    complete KV for the prefix and needs no sidecar.
+ *  - `gemma4` sizes its pool over the full-attention layers only, but persists
+ *    its out-of-pool sliding-window `RotatingKVCache` state as a
+ *    `ColdGroup::SlidingWindow` sidecar, and its `ColdSidecarPolicy` makes the
+ *    native restore walk refuse any boundary a validated sidecar does not back.
+ *  - `qwen3_5` (dense) sizes its pool over the full-attention layers only, but
+ *    persists its out-of-pool GDN recurrent state (conv + recurrent) as a
+ *    `ColdGroup::GdnState` sidecar, and its `ColdSidecarPolicy` reconciles the
+ *    native restore down to the deepest block-aligned boundary a validated
+ *    sidecar backs (a recurrent state is valid only at its exact prefix length).
+ *  - `qwen3_5_moe` keeps the SAME GDN recurrent state outside the pool — same
+ *    shapes, same dtype, same layer mapping — so it shares the dense family's
+ *    sidecar codec and `ColdSidecarPolicy` verbatim. Its restart-parity gate has
+ *    since been run on `Qwen3.6-35b-a3b-UD-Q2_K_XL-mlx`: the restore reconciled
+ *    onto ladder rung 304 of `[16, 64, 304, 1248]` with `hits=42` and
+ *    `corruptions=0`, and the text matched a no-persist baseline.
+ *  - `lfm2` / `lfm2_moe` keep short-conv state outside the pool with no
+ *    serialization path for it at all, AND drive the uniform native adapter
+ *    API whose restore branch is already wired to the tier — asking for
+ *    persistence on their behalf would restore an incomplete prefix silently.
+ *
+ * Widening this set is a correctness decision, never a perf one, and it is
+ * authorized by exactly one thing: the family's native restart-parity gate
+ * passing on real weights with `hits > 0` and `corruptions == 0`.
+ *
+ * `mlx agent --no-persist-cache` applies to EVERY family in this set, not to
+ * one of them: it is a SINGLE process-wide boolean handed to every load whose
+ * family is on the allowlist (`MlxModelHost.runWithResident` →
+ * `resolveModelPathFn(entry, { persistPagedCache })`). Families off the
+ * allowlist are handed no policy at all — not because the flag spares them, but
+ * because `cold_tier::resolve_persist_cold` refuses to persist them under ANY
+ * setting. The help text says so in exactly one place, built from
+ * {@link coldTierRestoreFamilyList} in `packages/cli/src/commands/agent/index.ts`
+ * and asserted by `packages/cli/__test__/agent-cmd.test.ts`.
+ */
+export declare const COLD_TIER_RESTORE_FAMILIES: ReadonlySet<string>;
+/** Allowlisted families in a stable, human-facing order (help text, API payload). */
+export declare function coldTierRestoreFamilyList(): string[];
+/**
+ * Canonical identity for a cold-cache root, used as the JOIN KEY between the
+ * agent that wrote a trace and the dashboard that reads it back.
+ *
+ * The two live in DIFFERENT PROCESSES resolving the root from their own
+ * environments: the native tier reports `manager.root().display()` (the path as
+ * constructed, never realpath'd) while the dashboard builds its own from
+ * `MLX_COLD_CACHE_DIR` or the `~/.mlx-node` default. On macOS `/tmp` is a
+ * symlink to `/private/tmp`, so two identical-looking spellings canonicalize
+ * differently — a raw string compare is a silent-zero trap, not a loud failure.
+ * Both sides MUST route through this one function.
+ *
+ * Resolution order: expand `~`, make absolute, then `realpath` the DEEPEST
+ * EXISTING ANCESTOR and re-attach every missing segment lexically. A tier that
+ * has never been opened has no root directory — that is the normal state, not
+ * an edge case — and when `MLX_COLD_CACHE_DIR` itself has never been created
+ * the parent is missing too. Stopping after one level returned a wholly
+ * UNcanonicalized path, so under a symlinked ancestor (`/tmp` → `/private/tmp`
+ * on macOS) the reader's key diverged from the writer's and rows from the SAME
+ * cache were reported as "a different cache directory". Only a path with no
+ * resolvable ancestor at all falls back to the lexical absolute form; this is
+ * an identity key, not a security boundary, so it fails OPEN to a stable string
+ * rather than to `undefined`.
+ *
+ * An empty input stays empty: the native struct reports `root: ''` while the
+ * tier is disabled, and that must never be recorded as a real cache identity.
+ */
+export declare function canonicalCacheRoot(root: string): string;
+//# sourceMappingURL=cold-tier.d.ts.map

package/dist/cold-tier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cold-tier.d.ts","sourceRoot":"","sources":["../src/cold-tier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,CAKzD,CAAC;AAEH,qFAAqF;AACrF,wBAAgB,yBAAyB,IAAI,MAAM,EAAE,CAEpD;AA2BD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAmBvD"}

package/dist/cold-tier.js

@@ -0,0 +1,155 @@
+/**
+ * Cold-tier facts shared by the agent (writer), the CLI (help text) and the
+ * dashboard (reader), kept in a NATIVE-FREE leaf module.
+ *
+ * `provider/model-host.ts` value-imports `@mlx-node/lm`, which loads the native
+ * addon; the dashboard is a separate viewer process that must never link it
+ * ("no Metal init, instant start" — docs/dashboard.md), and `mlx agent --help`
+ * must print without loading weights. This module therefore has NO runtime
+ * imports beyond `node:` builtins, and reaches those consumers through the
+ * existing native-free `@mlx-node/agent/catalog` subpath, which re-exports it.
+ * There is deliberately no `./cold-tier` entry in `package.json`: a second
+ * published subpath would be a second thing to keep native-free, and `catalog`
+ * already carries that guarantee.
+ *
+ * Everything here is a single source of truth. Do not copy the family list or
+ * re-implement the root canonicalization at a call site; import them.
+ */
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+/**
+ * Model families whose paged prefix blocks can be restored from the SSD cold
+ * tier soundly. The single source of truth on the TypeScript side, mirroring
+ * `COLD_RESTORE_FAMILIES` in `crates/mlx-core/src/cold_tier.rs`; the two gate
+ * the same decision from opposite ends, and
+ * `packages/agent/__test__/cold-tier-families.test.ts` asserts they never
+ * drift.
+ *
+ * A family belongs here only when EVERY piece of per-token state its forward
+ * pass carries between turns is reconstructible from the tier — either because
+ * it all lives inside the paged pool, or because the part that does not is
+ * persisted alongside as a cold-tier sidecar and the restore reconciles down to
+ * a boundary that sidecar actually backs:
+ *
+ *  - `qwen3` (dense) sizes its pool over all layers, so the pool holds the
+ *    complete KV for the prefix and needs no sidecar.
+ *  - `gemma4` sizes its pool over the full-attention layers only, but persists
+ *    its out-of-pool sliding-window `RotatingKVCache` state as a
+ *    `ColdGroup::SlidingWindow` sidecar, and its `ColdSidecarPolicy` makes the
+ *    native restore walk refuse any boundary a validated sidecar does not back.
+ *  - `qwen3_5` (dense) sizes its pool over the full-attention layers only, but
+ *    persists its out-of-pool GDN recurrent state (conv + recurrent) as a
+ *    `ColdGroup::GdnState` sidecar, and its `ColdSidecarPolicy` reconciles the
+ *    native restore down to the deepest block-aligned boundary a validated
+ *    sidecar backs (a recurrent state is valid only at its exact prefix length).
+ *  - `qwen3_5_moe` keeps the SAME GDN recurrent state outside the pool — same
+ *    shapes, same dtype, same layer mapping — so it shares the dense family's
+ *    sidecar codec and `ColdSidecarPolicy` verbatim. Its restart-parity gate has
+ *    since been run on `Qwen3.6-35b-a3b-UD-Q2_K_XL-mlx`: the restore reconciled
+ *    onto ladder rung 304 of `[16, 64, 304, 1248]` with `hits=42` and
+ *    `corruptions=0`, and the text matched a no-persist baseline.
+ *  - `lfm2` / `lfm2_moe` keep short-conv state outside the pool with no
+ *    serialization path for it at all, AND drive the uniform native adapter
+ *    API whose restore branch is already wired to the tier — asking for
+ *    persistence on their behalf would restore an incomplete prefix silently.
+ *
+ * Widening this set is a correctness decision, never a perf one, and it is
+ * authorized by exactly one thing: the family's native restart-parity gate
+ * passing on real weights with `hits > 0` and `corruptions == 0`.
+ *
+ * `mlx agent --no-persist-cache` applies to EVERY family in this set, not to
+ * one of them: it is a SINGLE process-wide boolean handed to every load whose
+ * family is on the allowlist (`MlxModelHost.runWithResident` →
+ * `resolveModelPathFn(entry, { persistPagedCache })`). Families off the
+ * allowlist are handed no policy at all — not because the flag spares them, but
+ * because `cold_tier::resolve_persist_cold` refuses to persist them under ANY
+ * setting. The help text says so in exactly one place, built from
+ * {@link coldTierRestoreFamilyList} in `packages/cli/src/commands/agent/index.ts`
+ * and asserted by `packages/cli/__test__/agent-cmd.test.ts`.
+ */
+export const COLD_TIER_RESTORE_FAMILIES = new Set([
+    'gemma4',
+    'qwen3',
+    'qwen3_5',
+    'qwen3_5_moe',
+]);
+/** Allowlisted families in a stable, human-facing order (help text, API payload). */
+export function coldTierRestoreFamilyList() {
+    return [...COLD_TIER_RESTORE_FAMILIES].sort();
+}
+/**
+ * Expand a leading `~` / `~/…` against the current home directory. A bare `~`
+ * prefix that is part of a longer name (`~cache`) is left alone — only the
+ * shell's own two spellings are expanded.
+ */
+/**
+ * `realpath(3)` rather than Node's JS walk.
+ *
+ * On a case-insensitive volume — APFS's default, i.e. essentially every Mac —
+ * `MLX_COLD_CACHE_DIR=~/CacheDir` and `~/cachedir` name the SAME directory, but
+ * `fs.realpathSync` hands back whichever spelling the caller typed. Two join
+ * keys for one cache is the F1 symptom inverted: a populated disk scan sitting
+ * beside a flat 0/0 trend. `realpathSync.native` folds each existing component
+ * to its on-disk spelling, so both env spellings produce one key.
+ */
+function realpathNative(path) {
+    return realpathSync.native(path);
+}
+function expandTilde(path) {
+    if (path === '~')
+        return homedir();
+    if (path.startsWith('~/'))
+        return join(homedir(), path.slice(2));
+    return path;
+}
+/**
+ * Canonical identity for a cold-cache root, used as the JOIN KEY between the
+ * agent that wrote a trace and the dashboard that reads it back.
+ *
+ * The two live in DIFFERENT PROCESSES resolving the root from their own
+ * environments: the native tier reports `manager.root().display()` (the path as
+ * constructed, never realpath'd) while the dashboard builds its own from
+ * `MLX_COLD_CACHE_DIR` or the `~/.mlx-node` default. On macOS `/tmp` is a
+ * symlink to `/private/tmp`, so two identical-looking spellings canonicalize
+ * differently — a raw string compare is a silent-zero trap, not a loud failure.
+ * Both sides MUST route through this one function.
+ *
+ * Resolution order: expand `~`, make absolute, then `realpath` the DEEPEST
+ * EXISTING ANCESTOR and re-attach every missing segment lexically. A tier that
+ * has never been opened has no root directory — that is the normal state, not
+ * an edge case — and when `MLX_COLD_CACHE_DIR` itself has never been created
+ * the parent is missing too. Stopping after one level returned a wholly
+ * UNcanonicalized path, so under a symlinked ancestor (`/tmp` → `/private/tmp`
+ * on macOS) the reader's key diverged from the writer's and rows from the SAME
+ * cache were reported as "a different cache directory". Only a path with no
+ * resolvable ancestor at all falls back to the lexical absolute form; this is
+ * an identity key, not a security boundary, so it fails OPEN to a stable string
+ * rather than to `undefined`.
+ *
+ * An empty input stays empty: the native struct reports `root: ''` while the
+ * tier is disabled, and that must never be recorded as a real cache identity.
+ */
+export function canonicalCacheRoot(root) {
+    const expanded = expandTilde(root.trim());
+    if (expanded.length === 0)
+        return '';
+    const absolute = resolve(expanded);
+    const missing = [];
+    let cursor = absolute;
+    for (;;) {
+        try {
+            const resolved = realpathNative(cursor);
+            return missing.length === 0 ? resolved : join(resolved, ...missing);
+        }
+        catch {
+            const parent = dirname(cursor);
+            // `dirname` is a fixpoint at the filesystem root, which is the loop's
+            // termination condition: nothing above it is left to canonicalize.
+            if (parent === cursor)
+                return absolute;
+            missing.unshift(basename(cursor));
+            cursor = parent;
+        }
+    }
+}

package/dist/extensions/local-image-input.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Attach the local image path inserted by Pi's interactive clipboard handler.
+ *
+ * Pi 0.81.1 writes a pasted clipboard image to a temporary file and inserts
+ * only that absolute path into the editor. AgentSession's `input` event is the
+ * last seam where the path can be upgraded to `ImageContent` before the user
+ * message is committed. Keep this deliberately narrow:
+ *
+ * - TUI + interactive input only;
+ * - the entire input must be one absolute image path;
+ * - only `\ ` shell escapes (the macOS drag/paste shape) are decoded;
+ * - extension and magic bytes must both identify a supported image.
+ *
+ * Every failed check returns `continue`, preserving the original text exactly.
+ * Capability is intentionally not checked here: discovery advertises every
+ * local model as text-only until its first resident load. The stream adapter's
+ * authoritative `session.supportsImages()` decides whether native bytes or the
+ * existing text-model placeholder reaches inference.
+ */
+import type { ExtensionContext, InlineExtension, InputEvent, InputEventResult } from '@earendil-works/pi-coding-agent';
+/** @internal Exported for focused tests of Pi's input-transform contract. */
+export declare function attachStandaloneLocalImage(event: InputEvent, ctx: ExtensionContext): Promise<InputEventResult>;
+export declare function createLocalImageInputExtension(): InlineExtension;
+//# sourceMappingURL=local-image-input.d.ts.map

package/dist/extensions/local-image-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-image-input.d.ts","sourceRoot":"","sources":["../../src/extensions/local-image-input.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,OAAO,KAAK,EAEV,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,gBAAgB,EACjB,MAAM,iCAAiC,CAAC;AA0CzC,6EAA6E;AAC7E,wBAAsB,0BAA0B,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAkDpH;AAED,wBAAgB,8BAA8B,IAAI,eAAe,CAOhE"}

package/dist/extensions/local-image-input.js

@@ -0,0 +1,114 @@
+/**
+ * Attach the local image path inserted by Pi's interactive clipboard handler.
+ *
+ * Pi 0.81.1 writes a pasted clipboard image to a temporary file and inserts
+ * only that absolute path into the editor. AgentSession's `input` event is the
+ * last seam where the path can be upgraded to `ImageContent` before the user
+ * message is committed. Keep this deliberately narrow:
+ *
+ * - TUI + interactive input only;
+ * - the entire input must be one absolute image path;
+ * - only `\ ` shell escapes (the macOS drag/paste shape) are decoded;
+ * - extension and magic bytes must both identify a supported image.
+ *
+ * Every failed check returns `continue`, preserving the original text exactly.
+ * Capability is intentionally not checked here: discovery advertises every
+ * local model as text-only until its first resident load. The stream adapter's
+ * authoritative `session.supportsImages()` decides whether native bytes or the
+ * existing text-model placeholder reaches inference.
+ */
+import { open } from 'node:fs/promises';
+import { extname, isAbsolute } from 'node:path';
+const MAX_LOCAL_IMAGE_BYTES = 20 * 1024 * 1024;
+const IMAGE_EXTENSIONS = new Set(['.gif', '.jpeg', '.jpg', '.png', '.webp']);
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+function startsWith(bytes, signature, offset = 0) {
+    return (bytes.byteLength >= offset + signature.length && signature.every((byte, index) => bytes[offset + index] === byte));
+}
+function startsWithAscii(bytes, text, offset = 0) {
+    return startsWith(bytes, Array.from(text, (character) => character.charCodeAt(0)), offset);
+}
+function detectImageMimeType(bytes) {
+    if (startsWith(bytes, [0xff, 0xd8, 0xff]) && bytes[3] !== 0xf7)
+        return 'image/jpeg';
+    if (startsWith(bytes, PNG_SIGNATURE) && startsWithAscii(bytes, 'IHDR', 12))
+        return 'image/png';
+    if (startsWithAscii(bytes, 'GIF87a') || startsWithAscii(bytes, 'GIF89a'))
+        return 'image/gif';
+    if (startsWithAscii(bytes, 'RIFF') && startsWithAscii(bytes, 'WEBP', 8))
+        return 'image/webp';
+    return undefined;
+}
+/**
+ * Resolve only the standalone path shape produced by Pi/macOS paste and drag.
+ * This is not a shell parser: no quoting, expansion, commands, or general
+ * backslash processing is performed.
+ */
+function standaloneImagePath(text) {
+    const trimmed = text.trim();
+    if (trimmed.length === 0 || trimmed.includes('\n') || trimmed.includes('\r'))
+        return undefined;
+    const path = trimmed.replaceAll('\\ ', ' ');
+    if (!isAbsolute(path) || !IMAGE_EXTENSIONS.has(extname(path).toLowerCase()))
+        return undefined;
+    return path;
+}
+/** @internal Exported for focused tests of Pi's input-transform contract. */
+export async function attachStandaloneLocalImage(event, ctx) {
+    if (ctx.mode !== 'tui' || event.source !== 'interactive' || event.images?.length) {
+        return { action: 'continue' };
+    }
+    const path = standaloneImagePath(event.text);
+    if (path === undefined)
+        return { action: 'continue' };
+    try {
+        // Open once so validation and reading stay bound to the same inode if
+        // the pathname is replaced. FileHandle.readFile() is intentionally not
+        // used: it may allocate from a file that grew after stat(). The exact,
+        // positional loop below caps allocation at the validated size.
+        const file = await open(path, 'r');
+        try {
+            const metadata = await file.stat();
+            if (!metadata.isFile() || metadata.size === 0 || metadata.size > MAX_LOCAL_IMAGE_BYTES) {
+                return { action: 'continue' };
+            }
+            const bytes = Buffer.allocUnsafe(metadata.size);
+            let offset = 0;
+            while (offset < bytes.byteLength) {
+                const { bytesRead } = await file.read(bytes, offset, bytes.byteLength - offset, offset);
+                if (bytesRead === 0)
+                    return { action: 'continue' };
+                offset += bytesRead;
+            }
+            // Reject same-inode growth after fstat without ever allocating or
+            // reading more than one byte beyond the validated size.
+            const overflowProbe = Buffer.allocUnsafe(1);
+            if ((await file.read(overflowProbe, 0, 1, metadata.size)).bytesRead !== 0) {
+                return { action: 'continue' };
+            }
+            const mimeType = detectImageMimeType(bytes);
+            if (mimeType === undefined)
+                return { action: 'continue' };
+            return {
+                action: 'transform',
+                text: event.text,
+                images: [{ type: 'image', mimeType, data: bytes.toString('base64') }],
+            };
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch {
+        // Missing, unreadable, or racing files remain ordinary user text.
+        return { action: 'continue' };
+    }
+}
+export function createLocalImageInputExtension() {
+    return {
+        name: 'mlx-local-image-input',
+        factory: (pi) => {
+            pi.on('input', attachStandaloneLocalImage);
+        },
+    };
+}

package/dist/extensions/subagent.d.ts

@@ -15,6 +15,16 @@
  * examples/extensions/subagent (MIT).
  */
 import type { ExtensionContext, InlineExtension } from '@earendil-works/pi-coding-agent';
+/**
+ * Tool loops can overlap; the shared `MlxModelHost` serializes model calls.
+ *
+ * Exported because it is one half of a cross-language invariant. Every live
+ * loop is a distinct native GDN cache owner, so this fleet demands
+ * `MAX_CONCURRENCY + 1` checkpoint slots (root session plus one per loop), and
+ * the native store supplies `gdnPrefixCheckpointLimit()` of them.
+ * `__test__/gdn-checkpoint-capacity.test.ts` holds the two together.
+ */
+export declare const MAX_CONCURRENCY = 4;
 type AgentScope = 'user' | 'project' | 'both';
 type AgentSource = 'builtin' | 'user' | 'project' | 'unknown';
 export type SubagentMode = 'single' | 'parallel' | 'chain';
@@ -36,7 +46,15 @@ export interface InProcessSubagentSession {
 export interface SubagentSessionCreateOptions {
     cwd: string;
     model: NonNullable<ExtensionContext['model']>;
-    modelRegistry: ExtensionContext['modelRegistry'];
+    /**
+     * Parent's registered in-process mlx provider config. Registering it on the
+     * subagent's fresh runtime reuses the parent's `streamSimple` closure, which
+     * is bound to the single shared `MlxModelHost` — so subagent inference stays
+     * serialized on the one GPU-resident model. `ProviderConfigInput` is not
+     * exported at the package root, so type it structurally from the facade
+     * method's return type (survives a future pi rename of the type).
+     */
+    mlxProviderConfig: NonNullable<ReturnType<ExtensionContext['modelRegistry']['getRegisteredProviderConfig']>>;
     tools?: string[];
     systemPrompt: string;
 }
@@ -77,6 +95,7 @@ export declare function normalizeSubagentMode(input: SubagentRequestShape): {
     mode: SubagentMode;
     modeCount: number;
 };
+export declare function createProductionSession(options: SubagentSessionCreateOptions): Promise<InProcessSubagentSession>;
 export declare function createSubagentExtension(options?: SubagentExtensionOptions): InlineExtension;
 export {};
 //# sourceMappingURL=subagent.d.ts.map

package/dist/extensions/subagent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagent.d.ts","sourceRoot":"","sources":["../../src/extensions/subagent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,OAAO,KAAK,EAAgB,gBAAgB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAUvG,KAAK,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAC9C,KAAK,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAiCD,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC1D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,4BAA4B;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,WAAW,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9C,aAAa,EAAE,gBAAgB,CAAC,eAAe,CAAC,CAAC;IACjD,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,mEAAmE;IACnE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAC9F;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAMD;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,0BAA0B,GAClC,0BAA0B,CAoB5B;AA6GD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,UAAU,GAChB;IACD,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CASA;AAqCD,UAAU,oBAAoB;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,GAAG;IAClE,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAQA;AAwND,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B,GAAG,eAAe,CAsJ/F"}
+{"version":3,"file":"subagent.d.ts","sourceRoot":"","sources":["../../src/extensions/subagent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH,OAAO,KAAK,EAAgB,gBAAgB,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAMvG;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AAGjC,KAAK,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAC9C,KAAK,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAC;AAE3D,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAiCD,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAC1D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,4BAA4B;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,WAAW,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9C;;;;;;;OAOG;IACH,iBAAiB,EAAE,WAAW,CAAC,UAAU,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,6BAA6B,CAAC,CAAC,CAAC,CAAC;IAC7G,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,mEAAmE;IACnE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;CAC9F;AAED,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAMD;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,0BAA0B,GAClC,0BAA0B,CAoB5B;AA6GD,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,UAAU,GAChB;IACD,MAAM,EAAE,cAAc,EAAE,CAAC;IACzB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC,CASA;AAqCD,UAAU,oBAAoB;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,oBAAoB,GAAG;IAClE,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAQA;AAeD,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,4BAA4B,GACpC,OAAO,CAAC,wBAAwB,CAAC,CAkDnC;AA0LD,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,wBAA6B,GAAG,eAAe,CAsJ/F"}

package/dist/extensions/subagent.js

@@ -21,8 +21,16 @@ import { StringEnum } from '@earendil-works/pi-ai';
 import { Type } from 'typebox';
 import { sanitizeApprovalDetail } from './approval-detail.js';
 const MAX_PARALLEL_TASKS = 8;
-/** Tool loops can overlap; the shared `MlxModelHost` serializes model calls. */
-const MAX_CONCURRENCY = 4;
+/**
+ * Tool loops can overlap; the shared `MlxModelHost` serializes model calls.
+ *
+ * Exported because it is one half of a cross-language invariant. Every live
+ * loop is a distinct native GDN cache owner, so this fleet demands
+ * `MAX_CONCURRENCY + 1` checkpoint slots (root session plus one per loop), and
+ * the native store supplies `gdnPrefixCheckpointLimit()` of them.
+ * `__test__/gdn-checkpoint-capacity.test.ts` holds the two together.
+ */
+export const MAX_CONCURRENCY = 4;
 const PER_TASK_OUTPUT_CAP = 50 * 1024;
 const COMPACTION_RESERVE_WINDOW_FRACTION = 0.25;
 const COMPACTION_KEEP_RECENT_WINDOW_FRACTION = 0.5;
@@ -238,10 +246,10 @@ async function mapWithConcurrencyLimit(items, fn) {
     await Promise.all(workers);
     return results;
 }
-async function createProductionSession(options) {
+export async function createProductionSession(options) {
     // `runAgent()` seeds pi's config environment before the extension can execute,
     // so defer the runtime import until now instead of importing pi at module load.
-    const { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, SettingsManager } = await import('@earendil-works/pi-coding-agent');
+    const { createAgentSession, DefaultResourceLoader, getAgentDir, ModelRuntime, SessionManager, SettingsManager } = await import('@earendil-works/pi-coding-agent');
     const agentDir = getAgentDir();
     const settingsManager = SettingsManager.create(options.cwd, agentDir);
     settingsManager.applyOverrides({
@@ -259,11 +267,26 @@ async function createProductionSession(options) {
         appendSystemPromptOverride: (base) => (options.systemPrompt.trim() ? [...base, options.systemPrompt] : base),
     });
     await resourceLoader.reload();
+    // 0.81.1: `createAgentSession` takes a `ModelRuntime`, not a `ModelRegistry`.
+    // Build a fresh runtime that carries the parent's in-process mlx provider. The
+    // config's `streamSimple` closure is bound to the single shared `MlxModelHost`,
+    // so all subagent inference stays serialized on the one GPU-resident model.
+    // `create` does no network (`allowModelNetwork:false`, also the default — set
+    // explicitly to keep the offline invariant local to this call, independent of
+    // the process-wide PI_OFFLINE seed in `runAgent`), and reuses the parent's
+    // `authPath`/`modelsPath`; `registerProvider` marks mlx configured (apiKey
+    // present) so streaming works immediately, dispatched by provider id.
+    const modelRuntime = await ModelRuntime.create({
+        authPath: path.join(agentDir, 'auth.json'),
+        modelsPath: path.join(agentDir, 'models.json'),
+        allowModelNetwork: false,
+    });
+    modelRuntime.registerProvider('mlx', options.mlxProviderConfig);
     const { session } = await createAgentSession({
         cwd: options.cwd,
         agentDir,
         model: options.model,
-        modelRegistry: options.modelRegistry,
+        modelRuntime,
         tools: options.tools,
         resourceLoader,
         sessionManager: SessionManager.inMemory(options.cwd),
@@ -312,6 +335,23 @@ async function runSingleAgent(options, defaultCwd, agents, agentName, task, cwd,
             step,
         };
     }
+    // The subagent runs on a fresh runtime (no mlx provider extension), so it must
+    // inherit the parent's exact registered mlx config to reuse the shared host.
+    // Fail closed if the parent has no 'mlx' provider — never fall back to an
+    // unconfigured/cloud provider.
+    const mlxProviderConfig = context.modelRegistry.getRegisteredProviderConfig('mlx');
+    if (!mlxProviderConfig) {
+        return {
+            agent: agent.name,
+            agentSource: agent.source,
+            task,
+            exitCode: 1,
+            messages: [],
+            stderr: `Agent ${agent.name} could not inherit the parent mlx provider (no 'mlx' provider registered).`,
+            usage: emptyUsage(),
+            step,
+        };
+    }
     const result = {
         agent: agent.name,
         agentSource: agent.source,
@@ -342,7 +382,7 @@ async function runSingleAgent(options, defaultCwd, agents, agentName, task, cwd,
         session = await (options.createSession ?? createProductionSession)({
             cwd: cwd ?? defaultCwd,
             model,
-            modelRegistry: context.modelRegistry,
+            mlxProviderConfig,
             tools: agent.tools,
             systemPrompt: agent.systemPrompt,
         });

package/dist/paths.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `$HOME/.mlx-node` layout helpers owned by the agent.
+ *
+ * The agent must not import `@mlx-node/cli` (wrong dependency direction), so
+ * the small home-directory layout it needs lives here. Mirrors
+ * `resolveMlxNodeHome()` in `@mlx-node/server/host/paths`
+ * (`packages/server/src/host/paths.ts`).
+ */
+/** Absolute path to `$HOME/.mlx-node`. */
+export declare function mlxNodeHome(): string;
+/** Directory holding per-process `MetricsTrace` JSONL files. */
+export declare function metricsTraceDir(): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,0CAA0C;AAC1C,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED,gEAAgE;AAChE,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/paths.js

@@ -0,0 +1,18 @@
+/**
+ * `$HOME/.mlx-node` layout helpers owned by the agent.
+ *
+ * The agent must not import `@mlx-node/cli` (wrong dependency direction), so
+ * the small home-directory layout it needs lives here. Mirrors
+ * `resolveMlxNodeHome()` in `@mlx-node/server/host/paths`
+ * (`packages/server/src/host/paths.ts`).
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Absolute path to `$HOME/.mlx-node`. */
+export function mlxNodeHome() {
+    return join(homedir(), '.mlx-node');
+}
+/** Directory holding per-process `MetricsTrace` JSONL files. */
+export function metricsTraceDir() {
+    return join(mlxNodeHome(), 'metrics', 'traces');
+}

package/dist/provider/chat-config.d.ts

@@ -30,5 +30,5 @@ export interface ResolvedReasoningMode {
  * option was present.
  */
 export declare function resolveReasoningMode(reasoning: ThinkingLevel | undefined): ResolvedReasoningMode;
-export declare function buildChatConfig(modelType: ModelType, options: SimpleStreamOptions | undefined, tools: ToolDefinition[] | undefined, rootCacheOwnerId?: string, resolvedReasoning?: ResolvedReasoningMode): ChatConfig;
+export declare function buildChatConfig(modelType: ModelType, options: SimpleStreamOptions | undefined, tools: ToolDefinition[] | undefined, rootCacheOwnerId?: string, resolvedReasoning?: ResolvedReasoningMode, modelMaxTokens?: unknown): ChatConfig;
 //# sourceMappingURL=chat-config.d.ts.map

package/dist/provider/chat-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat-config.d.ts","sourceRoot":"","sources":["../../src/provider/chat-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0BrE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,YAAY,GAAG,SAAS,CAE9E;AAgBD,MAAM,WAAW,qBAAqB;IACpC,eAAe,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpD,8EAA8E;IAC9E,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,aAAa,GAAG,SAAS,GAAG,qBAAqB,CAMhG;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAS,EACnC,gBAAgB,CAAC,EAAE,MAAM,EACzB,iBAAiB,wBAA2C,GAC3D,UAAU,CA6BZ"}
+{"version":3,"file":"chat-config.d.ts","sourceRoot":"","sources":["../../src/provider/chat-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0BrE;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,SAAS,GAAG,YAAY,GAAG,SAAS,CAE9E;AAgBD,MAAM,WAAW,qBAAqB;IACpC,eAAe,EAAE,MAAM,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACpD,8EAA8E;IAC9E,eAAe,EAAE,OAAO,CAAC;CAC1B;AAMD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,aAAa,GAAG,SAAS,GAAG,qBAAqB,CAMhG;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAS,EACnC,gBAAgB,CAAC,EAAE,MAAM,EACzB,iBAAiB,wBAA2C,EAC5D,cAAc,CAAC,EAAE,OAAO,GACvB,UAAU,CAsCZ"}