super-dsh 0.1.0 → 0.1.2

package/agent-pi/dist/models.js

@@ -0,0 +1,200 @@
+/**
+ * models — the shared pi ModelRuntime seam and the memoized model catalog.
+ *
+ * ONE ModelRuntime per process (the SDK's app-level model/auth service: it
+ * reads the native `~/.pi/agent` tree — auth.json, models-store.json,
+ * models.json — so user-configured providers work identically; the
+ * 2026-09-17 native-home ruling means we do NOT redirect any of it). The
+ * runtime is injectable (`setPiModelRuntimeFactory`) so tests never load the
+ * real SDK.
+ *
+ * The catalog memo fills on `warmPiCatalog()` (provider boot calls it once,
+ * fire-and-forget); `readPiModelCatalog()` is a synchronous memo read for
+ * the call sites codex served from a sync disk read (route pinning, default
+ * model push). Cold → empty models + `defaultSelection: undefined`, with
+ * codex's placeholder-omit semantics at the call sites (nothing is invented
+ * and no placeholder value ever leaves this module).
+ *
+ * Model identity (omp parity, 2026-09-17 parity fixes): every entry carries
+ * its REAL pi provider slug (`deepseek`, `zai`, …) plus the BARE model id,
+ * and the picker groups by the distinct slug routes this adapter registers
+ * after the warm (`piProviderIds` → registration `handle.replace`). Model
+ * ids therefore never collide across providers and no umbrella re-branding
+ * collapses them into one "Pi" group. `PI_PROVIDER_ID` survives only as the
+ * boot placeholder route (`registerAdapter` must not be empty) and in the
+ * legacy split path: selections stored before the split arrive as
+ * `<provider>/<modelId>` composites under the umbrella route, which
+ * `splitCatalogId` (FIRST slash) still resolves.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * The BOOT placeholder route: `registerAdapter` must not be empty, so the
+ * provider registers this single route at boot and atomically swaps it for
+ * the real per-provider slugs once the catalog is warm. No selection can be
+ * made under it (the cold catalog lists nothing).
+ */
+export const PI_PROVIDER_ID = "pi";
+/** Default factory: the real SDK's ModelRuntime (dynamic import, cached). */
+let runtimeFactory = async () => {
+    const sdk = (await import("@earendil-works/pi-coding-agent"));
+    return sdk.ModelRuntime.create();
+};
+/** Replace the runtime factory (tests inject a fake). */
+export function setPiModelRuntimeFactory(factory) {
+    runtimeFactory = factory;
+    runtimePromise = undefined;
+}
+let runtimePromise;
+/** The shared ModelRuntime (memoized; one per process). */
+export function getPiModelRuntime() {
+    runtimePromise ??= runtimeFactory();
+    return runtimePromise;
+}
+let memo;
+let warmPromise;
+/** Split a composite `<provider>/<modelId>` on the FIRST slash; `undefined` when there is none.
+ *
+ * Legacy path only: pre-split stored selections arrive as composites under
+ * the umbrella `pi` route. Real-slug selections pass the bare id (which may
+ * itself contain slashes) and must NOT be split here. */
+export function splitCatalogId(composite) {
+    const slash = composite.indexOf("/");
+    if (slash <= 0 || slash === composite.length - 1)
+        return undefined;
+    return { provider: composite.slice(0, slash), modelId: composite.slice(slash + 1) };
+}
+/** One warm pass: `getAvailable()` into the memo. Idempotent in-flight. */
+export function warmPiCatalog() {
+    warmPromise ??= (async () => {
+        const runtime = await getPiModelRuntime();
+        const available = (await runtime.getAvailable());
+        const models = [];
+        for (const raw of available) {
+            const provider = typeof raw["provider"] === "string" ? raw["provider"] : "";
+            const id = typeof raw["id"] === "string" ? raw["id"] : "";
+            if (provider === "" || id === "")
+                continue;
+            models.push({
+                id,
+                label: typeof raw["name"] === "string" && raw["name"] !== "" ? raw["name"] : id,
+                provider,
+                ...(typeof raw["contextWindow"] === "number" && raw["contextWindow"] > 0
+                    ? { contextWindow: raw["contextWindow"] }
+                    : {}),
+            });
+        }
+        memo = models;
+    })();
+    return warmPromise;
+}
+/**
+ * The pi CLI's default-model facts: `settings.json` in the agent dir
+ * (`defaultProvider` + `defaultModel`). The agent dir resolution mirrors the
+ * SDK (`PI_CODING_AGENT_DIR` → `~/.pi/agent`) without importing the SDK on
+ * this synchronous path. Fail-soft: unreadable settings contribute nothing.
+ */
+function settingsDefault() {
+    const env = process.env.PI_CODING_AGENT_DIR;
+    const agentDir = env !== undefined && env.trim() !== "" ? env : join(homedir(), ".pi", "agent");
+    const path = join(agentDir, "settings.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        const provider = typeof parsed["defaultProvider"] === "string" ? parsed["defaultProvider"] : "";
+        const modelId = typeof parsed["defaultModel"] === "string" ? parsed["defaultModel"] : "";
+        if (provider === "" || modelId === "")
+            return undefined;
+        return { provider, modelId };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Synchronous catalog read. `defaultSelection` is the settings default only
+ * when it is actually served by the warmed catalog; otherwise `undefined`
+ * (call sites OMIT the model so pi's own default applies).
+ */
+export function readPiModelCatalog() {
+    const models = memo ?? [];
+    const wanted = settingsDefault();
+    const served = wanted !== undefined && models.some((model) => model.provider === wanted.provider && model.id === wanted.modelId);
+    return {
+        provider: PI_PROVIDER_ID,
+        providerName: "Pi",
+        models,
+        defaultSelection: served && wanted !== undefined ? { provider: wanted.provider, model: wanted.modelId } : undefined,
+    };
+}
+/**
+ * The distinct provider slugs across the catalog — the picker routes this
+ * adapter registers. omp's ordering pattern: the operator-wired provider
+ * leads (for pi that is settings.json `defaultProvider`, the pi CLI's own
+ * default-model role), everything else follows alphabetically.
+ */
+export function piProviderIds(models = readPiModelCatalog().models) {
+    const seen = new Set();
+    for (const model of models)
+        seen.add(model.provider);
+    const ordered = [];
+    const preferred = settingsDefault()?.provider ?? "";
+    if (preferred !== "" && seen.has(preferred))
+        ordered.push(preferred);
+    for (const provider of [...seen].sort((a, b) => a.localeCompare(b))) {
+        if (!ordered.includes(provider))
+            ordered.push(provider);
+    }
+    return ordered;
+}
+/** Human-readable provider name for `LlmProviderInfo.name` (omp pattern). */
+const PROVIDER_TITLES = {
+    zai: "Z.AI",
+    xai: "xAI",
+    openrouter: "OpenRouter",
+    deepseek: "DeepSeek",
+    anthropic: "Anthropic",
+    openai: "OpenAI",
+    google: "Google",
+    moonshot: "Moonshot AI",
+};
+export function providerDisplayName(provider) {
+    return PROVIDER_TITLES[provider] ?? (provider.charAt(0).toUpperCase() + provider.slice(1));
+}
+/**
+ * Resolve a stored/observed model selection into the real route pair.
+ * Handles both shapes: a real-slug pair (`provider` = a catalog slug,
+ * `model` = the bare id, which may itself contain slashes) passes through
+ * untouched; a LEGACY composite rides the umbrella `pi` route with
+ * `<provider>/<modelId>` as the model and is split once. A warm catalog is
+ * the truth source: an unserved pair degrades to `undefined` so call sites
+ * omit the model (pi's own default applies) instead of forwarding a value
+ * the runtime would silently refuse.
+ */
+export function resolvePiSelection(provider, model) {
+    if (typeof model !== "string" || model === "")
+        return undefined;
+    let resolved;
+    if (provider === undefined || provider === "" || provider === PI_PROVIDER_ID) {
+        const split = splitCatalogId(model);
+        resolved = split !== undefined ? { provider: split.provider, model: split.modelId } : { provider: provider ?? "", model };
+    }
+    else {
+        resolved = { provider, model };
+    }
+    if (resolved.provider === "" || resolved.model === "")
+        return undefined;
+    const memoed = memo;
+    if (memoed !== undefined && memoed.length > 0 && !memoed.some((m) => m.provider === resolved.provider && m.id === resolved.model)) {
+        return undefined;
+    }
+    return resolved;
+}
+/** Test hygiene: drop the memo and the runtime singleton. */
+export function clearPiCatalogForTests() {
+    memo = undefined;
+    warmPromise = undefined;
+    runtimePromise = undefined;
+}

package/agent-pi/dist/permission.js

@@ -0,0 +1,66 @@
+/** The Dash preset table (mirrors the base bundle's permission plugin config). */
+const PRESETS = {
+    "danger-full-access": { sandbox: "danger-full-access", approval: "never", toolset: undefined },
+    "workspace-write": { sandbox: "workspace-write", approval: "ask", toolset: undefined },
+    "read-only": { sandbox: "read-only", approval: "ask", toolset: ["read", "grep", "find", "ls"] },
+};
+/** Narrow an untrusted value to a known preset name. */
+export function isPresetName(raw) {
+    return typeof raw === "string" && Object.hasOwn(PRESETS, raw);
+}
+/**
+ * `PI_APPROVAL_MODE` when it names a preset this adapter implements, else
+ * undefined. An invalid value is IGNORED (the preset mapping applies).
+ */
+export function envApprovalMode() {
+    const raw = process.env.PI_APPROVAL_MODE;
+    return isPresetName(raw) ? raw : undefined;
+}
+/**
+ * Map a preset onto the launch-only pi toolset. `undefined` = pi's own
+ * default tool set (read, bash, edit, write). Unknown names degrade to the
+ * default.
+ */
+export function piToolset(preset) {
+    return isPresetName(preset) ? PRESETS[preset].toolset : undefined;
+}
+/**
+ * The default preset for FUTURE sessions, as the permission service
+ * resolves it (settings-backed; the profile patch pins the base default).
+ * Undefined when the service is absent or its getter fails — callers fall
+ * back to the pi default toolset.
+ */
+export function defaultPermissionPreset(ctx) {
+    const service = ctx.get("permissionPresets");
+    if (service === undefined)
+        return undefined;
+    try {
+        const preset = service.defaultPreset;
+        return isPresetName(preset) ? preset : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The session's effective preset: the last `permission/preset` event. */
+export function presetFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === "permission/preset" && isPresetName(event.data?.preset))
+            return event.data.preset;
+    }
+    return undefined;
+}
+/**
+ * The three Dash events `pinInitialPermission` stamps for a fresh session,
+ * in its append order (preset, sandbox, approval). Cold replay prepends
+ * them so the UI shows the session's permission after wrapper restarts.
+ */
+export function permissionEventsFor(preset, time) {
+    const spec = PRESETS[preset];
+    return [
+        { type: "permission/preset", time, data: { preset } },
+        { type: "sandbox/mode", time, data: { mode: spec.sandbox } },
+        { type: "approval/policy", time, data: { policy: spec.approval } },
+    ];
+}

package/agent-pi/dist/pi-client.js

@@ -0,0 +1,224 @@
+/**
+ * PiSessionClient — the SDK-line client seam: one pi `AgentSession` per Dash
+ * session, driven in-process (2026-09-17 "sdk" ruling; no sidecar, no
+ * `--mode rpc` subprocess).
+ *
+ * Lifecycle is LAZY by the omp iron law: `spawn()` builds a zero-IO shell and
+ * `ensureStarted()` (first real prompt) runs the injected factory — by default
+ * `createAgentSession` over the shared ModelRuntime with
+ * `SessionManager.create(cwd)` (create) or `SessionManager.open(file)` (resume).
+ * pi's native session JSONL materializes at that moment under `~/.pi`; the
+ * provider records the file into the mapping once it exists.
+ *
+ * Public surface mirrors the codex client seam (`spawn` / `on` / `onFailure` /
+ * `getState` / `prompt` / `followUp` / `steer` / `setModel` / `abort` /
+ * `ensureStarted` / `spawned` / `close`) so the PiAgent port compiles the same
+ * way CodexAgent compiles against CodexSdkClient, plus pi-only surfaces
+ * (`setThinkingLevel`, `compact` — pi compaction is real and wired).
+ *
+ * Events flow through `projectSessionEvent` before reaching listeners; pi
+ * emits its own terminal `agent_end`, so the client never synthesizes one.
+ */
+import { projectSessionEvent } from "./pi-events.js";
+import { getPiModelRuntime } from "./models.js";
+import { trace } from "./knobs.js";
+/** Default factory: the real SDK, over the shared ModelRuntime. */
+let sessionFactory = async ({ cwd, mode }) => {
+    const sdk = (await import("@earendil-works/pi-coding-agent"));
+    const modelRuntime = await getPiModelRuntime();
+    const sessionManager = mode.kind === "resume" ? sdk.SessionManager.open(mode.sessionFile) : sdk.SessionManager.create(cwd);
+    const { session } = await sdk.createAgentSession({
+        modelRuntime,
+        sessionManager,
+        cwd,
+        ...(mode.kind === "create" && mode.tools !== undefined && mode.tools.length > 0 ? { tools: mode.tools } : {}),
+    });
+    return session;
+};
+/** Replace the session factory (tests inject a fake). */
+export function setPiSessionFactory(factory) {
+    sessionFactory = factory;
+}
+function ok(command, data) {
+    return { type: "response", command, success: true, ...(data === undefined ? {} : { data }) };
+}
+export class PiSessionClient {
+    config;
+    #session;
+    #startPromise;
+    #closed = false;
+    #listeners = new Set();
+    #failureListeners = new Set();
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Build the client shell. Zero IO: the factory runs only at
+     * `ensureStarted()`. `args` is accepted for omp-seam parity and must be
+     * empty — unknown values fail loud (the SDK line has no spawn flags).
+     */
+    static async spawn(args, cwd, mode) {
+        if (args.length > 0) {
+            throw new Error(`PiSessionClient: unsupported spawn arg "${String(args[0])}" (SDK line)`);
+        }
+        return new PiSessionClient({ cwd, mode });
+    }
+    /** Register a wire event listener; returns the unsubscriber. */
+    on(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    /** Register a failure listener; returns the unsubscriber. */
+    onFailure(listener) {
+        this.#failureListeners.add(listener);
+        return () => {
+            this.#failureListeners.delete(listener);
+        };
+    }
+    /** Whether the underlying pi session exists (and the client is not closed). */
+    get spawned() {
+        return this.#session !== undefined && !this.#closed;
+    }
+    /** pi's native session file; `null` until the session materializes it. */
+    get sessionFile() {
+        return this.#closed || this.#session === undefined ? null : this.#session.sessionFile ?? null;
+    }
+    /**
+     * pi's own system prompt, once the session started (undefined before —
+     * callers retry on later steps).
+     */
+    systemPrompt() {
+        if (this.#closed || this.#session === undefined)
+            return undefined;
+        const prompt = this.#session.systemPrompt;
+        return typeof prompt === "string" && prompt.trim() !== "" ? prompt : undefined;
+    }
+    /** Materialize the session once; memoized after that. */
+    ensureStarted() {
+        this.#usable();
+        this.#startPromise ??= (async () => {
+            const session = await sessionFactory(this.config);
+            this.#session = session;
+            session.subscribe((event) => this.#pump(event));
+            trace(`session started mode=${this.config.mode.kind} file=${session.sessionFile ?? "none"}`);
+        })();
+        return this.#startPromise;
+    }
+    /** Query streaming state. Does NOT start the session (cold reads stay cold). */
+    getState() {
+        this.#usable();
+        if (this.#session === undefined)
+            return { isStreaming: false };
+        return { isStreaming: this.#session.isStreaming === true };
+    }
+    /** Start a run with a user prompt (fire-and-forget past the lazy boundary). */
+    async prompt(message) {
+        this.#usable();
+        await this.ensureStarted();
+        void this.#session.prompt(message).catch((error) => this.#fail(error));
+        return ok("prompt");
+    }
+    /** Queue a steering message while streaming (pi supports this natively). */
+    async steer(message) {
+        this.#usable();
+        await this.ensureStarted();
+        void this.#session.steer(message).catch((error) => this.#fail(error));
+        return ok("steer");
+    }
+    /** Queue a follow-up for when the agent stops. */
+    async followUp(message) {
+        this.#usable();
+        await this.ensureStarted();
+        void this.#session.followUp(message).catch((error) => this.#fail(error));
+        return ok("follow_up");
+    }
+    /**
+     * Select the model by its real route pair: the provider slug plus the BARE
+     * model id, threaded straight into the shared runtime's `getModel`.
+     * Legacy composite `<provider>/<modelId>` selections are resolved
+     * upstream (agent.ts) before reaching here. An unknown pair logs and
+     * no-ops (never breaks the agent loop mid-session — codex catch
+     * semantics); an incomplete pair is likewise a logged no-op.
+     */
+    async setModel(provider, modelId) {
+        this.#usable();
+        if (provider === "" || modelId === "") {
+            trace(`set_model: incomplete route (${provider}/${modelId}), ignored`);
+            return ok("set_model");
+        }
+        await this.ensureStarted();
+        const runtime = await getPiModelRuntime();
+        const model = runtime.getModel(provider, modelId);
+        if (model === undefined) {
+            trace(`set_model: runtime has no ${provider}/${modelId}, ignored`);
+            return ok("set_model");
+        }
+        this.#session.setModel(model);
+        trace(`set_model → ${provider}/${modelId}`);
+        return ok("set_model");
+    }
+    /** Set the thinking level (off..max); no-op before the session exists. */
+    setThinkingLevel(level) {
+        this.#usable();
+        this.#session?.setThinkingLevel(level);
+    }
+    /** Run pi compaction (wired unlike codex); fire-and-forget with failure channel. */
+    async compact(customInstructions) {
+        this.#usable();
+        await this.ensureStarted();
+        void this.#session.compact(customInstructions).catch((error) => this.#fail(error));
+        return ok("compact");
+    }
+    /** Abort the current operation; resolves when the session is idle again. */
+    async abort() {
+        this.#usable();
+        if (this.#session !== undefined)
+            await this.#session.abort();
+        return ok("abort");
+    }
+    /** Dispose the session. Idempotent; all later operations fail. */
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        try {
+            this.#session?.dispose();
+        }
+        catch (error) {
+            trace(`dispose threw: ${String(error)}`);
+        }
+        this.#fail(new Error("pi session client closed"));
+    }
+    // -------------------------------------------------------------------------
+    #usable() {
+        if (this.#closed)
+            throw new Error("pi session client is closed");
+    }
+    #pump(raw) {
+        const wire = projectSessionEvent(raw);
+        if (wire === null)
+            return;
+        for (const listener of [...this.#listeners]) {
+            try {
+                listener(wire);
+            }
+            catch (error) {
+                process.stderr.write(`pi sdk listener error: ${String(error)}\n`);
+            }
+        }
+    }
+    #fail(error) {
+        const resolved = error instanceof Error ? error : new Error(String(error));
+        trace(`failure: ${resolved.message}`);
+        for (const listener of [...this.#failureListeners]) {
+            try {
+                listener(resolved);
+            }
+            catch (listenerError) {
+                process.stderr.write(`pi sdk failure listener error: ${String(listenerError)}\n`);
+            }
+        }
+    }
+}

package/agent-pi/dist/pi-events.js

@@ -0,0 +1,155 @@
+/**
+ * pi-events — pure projection from pi's `AgentSessionEvent` stream onto the
+ * wire vocabulary the omp/codex bridges share (agent_start / turn_start /
+ * message_* / tool_execution_* / turn_end / agent_end), plus pi-specific
+ * events nothing upstream has: `session_title` (pi owns titles) and the
+ * `compaction_start|end` pair (pi compaction is real and wired here).
+ *
+ * Duck-typed on pi's event shapes (verified against @earendil-works/
+ * pi-agent-core dist 0.84.2): the projection never imports the SDK, so tests
+ * run without touching pi and future pi point releases fail loudly HERE
+ * instead of silently changing the DSH log. Unknown, unmapped, and non-object
+ * events project to `null` — never throw into the SDK's subscribe loop.
+ */
+import { JSONStringifySafe } from "./safe-json.js";
+// Events pi emits that this adapter deliberately does not project (V1):
+// agent_settled (idle bookkeeping), queue_update (client-internal queue),
+// entry_appended (the log is DSH's), thinking_level_changed, auto_retry_* /
+// summarization_retry_* (folded into the turn's outcome), bash_execution_update.
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+function optionalString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function convertContent(blocks) {
+    if (!Array.isArray(blocks))
+        return [];
+    const out = [];
+    for (const raw of blocks) {
+        const block = asRecord(raw);
+        if (block === null)
+            continue;
+        switch (block["type"]) {
+            case "text":
+                if (typeof block["text"] === "string")
+                    out.push({ type: "text", text: block["text"] });
+                break;
+            case "thinking":
+                if (typeof block["thinking"] === "string")
+                    out.push({ type: "thinking", thinking: block["thinking"] });
+                break;
+            case "toolCall": {
+                // The DSH `tool/call` payload wants the RAW JSON string the model
+                // produced; pi parses it into an object, so re-stringify here.
+                const args = block["arguments"];
+                out.push({
+                    type: "toolCall",
+                    id: optionalString(block["id"]) ?? "",
+                    name: optionalString(block["name"]) ?? "",
+                    arguments: typeof args === "string" ? args : JSONStringifySafe(args ?? {}),
+                });
+                break;
+            }
+            default:
+                // images / unknown blocks are not bridged in V1.
+                break;
+        }
+    }
+    return out;
+}
+function convertMessage(raw) {
+    const message = asRecord(raw);
+    if (message === null)
+        return { role: "unknown", content: [] };
+    const wire = {
+        role: optionalString(message["role"]) ?? "unknown",
+        content: convertContent(message["content"]),
+    };
+    const provider = optionalString(message["provider"]);
+    const model = optionalString(message["model"]);
+    if (provider !== undefined)
+        wire.provider = provider;
+    if (model !== undefined)
+        wire.model = model;
+    const usage = asRecord(message["usage"]);
+    if (usage !== null)
+        wire.usage = usage;
+    const stopReason = optionalString(message["stopReason"]);
+    if (stopReason !== undefined)
+        wire.stopReason = stopReason;
+    const errorMessage = optionalString(message["errorMessage"]);
+    if (errorMessage !== undefined)
+        wire.errorMessage = errorMessage;
+    if (typeof message["errorStatus"] === "number")
+        wire.errorStatus = message["errorStatus"];
+    const toolCallId = optionalString(message["toolCallId"]);
+    if (toolCallId !== undefined)
+        wire.toolCallId = toolCallId;
+    if (typeof message["isError"] === "boolean")
+        wire.isError = message["isError"];
+    return wire;
+}
+/**
+ * Project one raw pi event. Returns the wire event, `null` for anything this
+ * adapter does not project. Pure and total: no imports from the SDK, no I/O,
+ * no throws.
+ */
+export function projectSessionEvent(raw) {
+    const event = asRecord(raw);
+    if (event === null)
+        return null;
+    switch (event["type"]) {
+        case "agent_start":
+            return { type: "agent_start" };
+        case "agent_end":
+            return { type: "agent_end" };
+        case "turn_start":
+            return { type: "turn_start" };
+        case "turn_end":
+            return { type: "turn_end" };
+        case "message_start":
+            return { type: "message_start", message: convertMessage(event["message"]) };
+        case "message_end":
+            return { type: "message_end", message: convertMessage(event["message"]) };
+        case "message_update": {
+            const delta = asRecord(event["assistantMessageEvent"]);
+            if (delta === null)
+                return null;
+            return { type: "message_update", assistantMessageEvent: delta };
+        }
+        case "tool_execution_start": {
+            const toolCallId = optionalString(event["toolCallId"]);
+            if (toolCallId === undefined)
+                return null;
+            return {
+                type: "tool_execution_start",
+                toolCallId,
+                toolName: optionalString(event["toolName"]) ?? "",
+                args: event["args"],
+            };
+        }
+        case "tool_execution_end": {
+            const toolCallId = optionalString(event["toolCallId"]);
+            if (toolCallId === undefined)
+                return null;
+            return {
+                type: "tool_execution_end",
+                toolCallId,
+                toolName: optionalString(event["toolName"]) ?? "",
+                result: asRecord(event["result"]) ?? {},
+                isError: event["isError"] === true,
+            };
+        }
+        case "session_info_changed":
+            return { type: "session_title", name: optionalString(event["name"]) };
+        case "compaction_start":
+            return { type: "compaction_start", reason: optionalString(event["reason"]) ?? "manual" };
+        case "compaction_end":
+            return { type: "compaction_end", aborted: event["aborted"] === true };
+        default:
+            return null;
+    }
+}