@getpaseo/server 0.1.69 → 0.1.71

package/dist/server/server/agent/providers/{claude-agent.js → claude/agent.js}

@@ -3,20 +3,20 @@ import fs from "node:fs";
 import { promises } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { query, } from "@anthropic-ai/claude-agent-sdk";
-import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./claude/tool-call-mapper.js";
-import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./claude/task-notification-tool-call.js";
-import { getClaudeModels, normalizeClaudeRuntimeModelId } from "./claude/claude-models.js";
-import { parsePartialJsonObject } from "./claude/partial-json.js";
-import { ClaudeSidechainTracker } from "./claude/sidechain-tracker.js";
-import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
-import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
-import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
-import { createProviderEnv, createProviderEnvSpec, } from "../provider-launch-config.js";
-import { findExecutable, isCommandAvailable } from "../../../utils/executable.js";
-import { withTimeout } from "../../../utils/promise-timeout.js";
-import { execCommand, spawnProcess } from "../../../utils/spawn.js";
-import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js";
+import { mapClaudeCanceledToolCall, mapClaudeCompletedToolCall, mapClaudeFailedToolCall, mapClaudeRunningToolCall, } from "./tool-call-mapper.js";
+import { mapTaskNotificationSystemRecordToToolCall, mapTaskNotificationUserContentToToolCall, } from "./task-notification-tool-call.js";
+import { getClaudeModels, normalizeClaudeRuntimeModelId } from "./models.js";
+import { parsePartialJsonObject } from "./partial-json.js";
+import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
+import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, toDiagnosticErrorMessage, } from "../diagnostic-utils.js";
+import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
+import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
+import { claudeQuery } from "./query.js";
+import { createProviderEnv, createProviderEnvSpec, } from "../../provider-launch-config.js";
+import { findExecutable, isCommandAvailable } from "../../../../utils/executable.js";
+import { withTimeout } from "../../../../utils/promise-timeout.js";
+import { execCommand } from "../../../../utils/spawn.js";
+import { getOrchestratorModeInstructions } from "../../orchestrator-instructions.js";
 const fsPromises = promises;
 const CLAUDE_SETTING_SOURCES = ["user", "project"];
 function readNonEmptyString(value) {
@@ -61,6 +61,21 @@ export function normalizeClaudeAskUserQuestionUpdatedInput(updatedInput, fallbac
         answers: normalizedAnswers,
     };
 }
+function isObjectRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toObjectRecord(value) {
+    return isObjectRecord(value) ? value : undefined;
+}
+function isUnknownArray(value) {
+    return Array.isArray(value);
+}
+function isImageMimeType(value) {
+    return (value === "image/jpeg" ||
+        value === "image/png" ||
+        value === "image/gif" ||
+        value === "image/webp");
+}
 const CLAUDE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
@@ -134,60 +149,6 @@ function extractSessionIdRaw(msg) {
         return msg.session.id;
     return "";
 }
-function resolveClaudeSpawnCommand(spawnOptions, runtimeSettings) {
-    const commandConfig = runtimeSettings?.command;
-    if (!commandConfig || commandConfig.mode === "default") {
-        return {
-            command: spawnOptions.command,
-            args: [...spawnOptions.args],
-        };
-    }
-    if (commandConfig.mode === "append") {
-        return {
-            command: spawnOptions.command,
-            args: [...spawnOptions.args, ...(commandConfig.args ?? [])],
-        };
-    }
-    return {
-        command: commandConfig.argv[0],
-        args: [...commandConfig.argv.slice(1), ...spawnOptions.args],
-    };
-}
-function applyRuntimeSettingsToClaudeOptions(options, runtimeSettings, launchEnv) {
-    return {
-        ...options,
-        spawnClaudeCodeProcess: (spawnOptions) => {
-            const resolved = resolveClaudeSpawnCommand(spawnOptions, runtimeSettings);
-            // When the SDK passes a default JS runtime ("node"/"bun"), replace it with
-            // process.execPath — the actual node binary running the daemon. This avoids
-            // PATH lookup failures in the managed runtime bundle.
-            // When the SDK passes a native binary path (from pathToClaudeCodeExecutable)
-            // or the user overrides the command via runtime settings, use that directly.
-            const isDefaultRuntime = resolved.command === "node" || resolved.command === "bun";
-            const command = isDefaultRuntime ? process.execPath : resolved.command;
-            const child = spawnProcess(command, resolved.args, {
-                cwd: spawnOptions.cwd,
-                ...createProviderEnvSpec({
-                    baseEnv: spawnOptions.env,
-                    runtimeSettings,
-                    overlays: [launchEnv],
-                }),
-                signal: spawnOptions.signal,
-                stdio: ["pipe", "pipe", "pipe"],
-                // Bypass cmd.exe on Windows: the SDK passes --mcp-config with inline JSON
-                // containing double quotes, which cmd.exe mangles (strips quotes, breaks parsing).
-                // The command is always a resolved binary path, so shell routing is unnecessary.
-                shell: false,
-            });
-            if (typeof options.stderr === "function") {
-                child.stderr?.on("data", (chunk) => {
-                    options.stderr?.(chunk.toString());
-                });
-            }
-            return child;
-        },
-    };
-}
 function isClaudeThinkingEffort(value) {
     return (value === "low" ||
         value === "medium" ||
@@ -210,11 +171,11 @@ function summarizeClaudeOptionsForLog(options) {
         if (typeof systemPromptRaw === "string") {
             return { mode: "string", preset: null };
         }
-        const prompt = systemPromptRaw;
-        const promptType = typeof prompt.type === "string" ? prompt.type : "custom";
+        const prompt = toObjectRecord(systemPromptRaw);
+        const promptType = typeof prompt?.type === "string" ? prompt.type : "custom";
         return {
             mode: promptType === "preset" ? "preset" : "custom",
-            preset: typeof prompt.preset === "string" && prompt.preset.length > 0 ? prompt.preset : null,
+            preset: typeof prompt?.preset === "string" && prompt.preset.length > 0 ? prompt.preset : null,
         };
     })();
     const mcpServerNames = options.mcpServers ? Object.keys(options.mcpServers).sort() : [];
@@ -276,7 +237,11 @@ function normalizeForDeterministicString(value, seen) {
             return "[circular]";
         }
         seen.add(objectValue);
-        const record = value;
+        const record = toObjectRecord(value);
+        if (!record) {
+            seen.delete(objectValue);
+            return "[invalid]";
+        }
         const normalized = {};
         for (const key of Object.keys(record).sort()) {
             normalized[key] = normalizeForDeterministicString(record[key], seen);
@@ -284,7 +249,10 @@ function normalizeForDeterministicString(value, seen) {
         seen.delete(objectValue);
         return normalized;
     }
-    return String(value);
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return "[unsupported]";
 }
 function deterministicStringify(value) {
     if (typeof value === "undefined") {
@@ -298,12 +266,13 @@ function deterministicStringify(value) {
         return JSON.stringify(normalized);
     }
     catch {
-        try {
-            return String(value);
+        if (typeof value === "string") {
+            return value;
         }
-        catch {
-            return "[unserializable]";
+        if (typeof value === "number" || typeof value === "boolean") {
+            return String(value);
         }
+        return "[unserializable]";
     }
 }
 function coerceToolResultContentToString(content) {
@@ -344,20 +313,21 @@ function collectClaudeTextContentParts(content) {
         const normalized = normalizeClaudeTranscriptText(content);
         return normalized ? [normalized] : [];
     }
-    if (!Array.isArray(content)) {
+    if (!isUnknownArray(content)) {
         return [];
     }
     const parts = [];
     for (const block of content) {
-        if (!block || typeof block !== "object") {
+        const blockRecord = toObjectRecord(block);
+        if (!blockRecord) {
             continue;
         }
-        const text = normalizeClaudeTranscriptText(block.text);
+        const text = normalizeClaudeTranscriptText(blockRecord.text);
         if (text) {
             parts.push(text);
             continue;
         }
-        const input = normalizeClaudeTranscriptText(block.input);
+        const input = normalizeClaudeTranscriptText(blockRecord.input);
         if (input) {
             parts.push(input);
         }
@@ -537,6 +507,7 @@ function toClaudeSdkMcpConfig(config) {
                 headers: config.headers,
             };
     }
+    throw new Error("Unhandled MCP server config type");
 }
 function isClaudeContentChunk(value) {
     return isMetadata(value) && typeof value.type === "string";
@@ -627,7 +598,7 @@ class TimelineAssembler {
         return this.applyAbsoluteFragments(state, fragments);
     }
     consumeStreamEvent(message, runId, messageIdHint) {
-        const event = message.event;
+        const event = toObjectRecord(message.event) ?? {};
         const eventType = readTrimmedString(event.type);
         const streamEventMessageId = this.readMessageIdFromStreamEvent(event) ?? messageIdHint;
         if (eventType === "message_start") {
@@ -810,19 +781,20 @@ class TimelineAssembler {
         return fragments;
     }
     readMessageIdFromAssistantMessage(message) {
-        const candidate = message;
-        return (readTrimmedString(candidate.message_id) ?? readTrimmedString(candidate.message?.id) ?? null);
+        const candidate = toObjectRecord(message);
+        const messageContainer = toObjectRecord(candidate?.message);
+        return (readTrimmedString(candidate?.message_id) ?? readTrimmedString(messageContainer?.id) ?? null);
     }
     readMessageIdFromStreamEvent(event) {
-        const message = event.message;
-        return readTrimmedString(event.message_id) ?? readTrimmedString(message?.id) ?? null;
+        const messageContainer = toObjectRecord(event.message);
+        return readTrimmedString(event.message_id) ?? readTrimmedString(messageContainer?.id) ?? null;
     }
 }
 function isSyntheticUserEntry(entry) {
-    if (!entry || typeof entry !== "object") {
+    const candidate = toObjectRecord(entry);
+    if (!candidate) {
         return false;
     }
-    const candidate = entry;
     return candidate.isSynthetic === true || candidate.isMeta === true;
 }
 function firstTrimmedString(sources) {
@@ -835,11 +807,11 @@ function firstTrimmedString(sources) {
     return null;
 }
 export function readEventIdentifiers(message) {
-    const root = message;
+    const root = toObjectRecord(message) ?? {};
     const messageType = readTrimmedString(root.type);
-    const streamEvent = root.event;
-    const streamEventMessage = streamEvent?.message;
-    const messageContainer = root.message;
+    const streamEvent = toObjectRecord(root.event);
+    const streamEventMessage = toObjectRecord(streamEvent?.message);
+    const messageContainer = toObjectRecord(root.message);
     const messageIdFromUuid = messageType === "user" ? root.uuid : undefined;
     return {
         taskId: firstTrimmedString([
@@ -873,7 +845,8 @@ export class ClaudeAgentClient {
         this.defaults = options.defaults;
         this.logger = options.logger.child({ module: "agent", provider: "claude" });
         this.runtimeSettings = options.runtimeSettings;
-        this.queryFactory = options.queryFactory ?? query;
+        this.queryFactory = options.queryFactory;
+        this.resolveBinary = options.resolveBinary ?? (() => resolveClaudeBinary(this.runtimeSettings));
     }
     async createSession(config, launchContext, options) {
         const claudeConfig = this.assertConfig(config);
@@ -884,6 +857,7 @@ export class ClaudeAgentClient {
             persistSession: options?.persistSession,
             logger: this.logger,
             queryFactory: this.queryFactory,
+            resolveBinary: this.resolveBinary,
         });
     }
     async resumeSession(handle, overrides, launchContext) {
@@ -905,6 +879,7 @@ export class ClaudeAgentClient {
             launchEnv: launchContext?.env,
             logger: this.logger,
             queryFactory: this.queryFactory,
+            resolveBinary: this.resolveBinary,
         });
     }
     async listModels(_options) {
@@ -929,9 +904,7 @@ export class ClaudeAgentClient {
         if (command?.mode === "replace") {
             return await isCommandAvailable(command.argv[0]);
         }
-        // Default mode uses @anthropic-ai/claude-agent-sdk's bundled cli.js run
-        // via process.execPath. No external `claude` binary is required.
-        return true;
+        return await isCommandAvailable("claude");
     }
     async getDiagnostic() {
         try {
@@ -980,6 +953,20 @@ export class ClaudeAgentClient {
         return { ...config, provider: "claude" };
     }
 }
+async function resolveClaudeBinary(runtimeSettings) {
+    const command = runtimeSettings?.command;
+    if (command?.mode === "replace") {
+        const foundOverride = await findExecutable(command.argv[0]);
+        if (foundOverride) {
+            return foundOverride;
+        }
+    }
+    const found = await findExecutable("claude");
+    if (found) {
+        return found;
+    }
+    throw new Error("Claude binary not found. Install Claude Code (https://github.com/anthropics/claude-code) and ensure it is available in your shell PATH.");
+}
 async function resolveClaudeVersion(runtimeSettings) {
     const command = runtimeSettings?.command;
     const envSpec = createProviderEnvSpec({ runtimeSettings });
@@ -1012,11 +999,11 @@ async function resolveClaudeAuth(runtimeSettings) {
             });
         }
         catch (error) {
-            const err = error;
-            return {
-                stdout: err.stdout ?? "",
-                stderr: err.stderr ?? err.message ?? "",
-            };
+            const err = toObjectRecord(error);
+            const stdout = typeof err?.stdout === "string" ? err.stdout : "";
+            const stderr = typeof err?.stderr === "string" ? err.stderr : "";
+            const fallbackMessage = typeof err?.message === "string" ? err.message : "";
+            return { stdout, stderr: stderr || fallbackMessage };
         }
     };
     try {
@@ -1042,15 +1029,17 @@ async function resolveClaudeAuth(runtimeSettings) {
     }
 }
 function extractContextWindowSize(modelUsage) {
-    if (!modelUsage || typeof modelUsage !== "object") {
+    const usageRecord = toObjectRecord(modelUsage);
+    if (!usageRecord) {
         return undefined;
     }
     let maxContextWindow;
-    for (const value of Object.values(modelUsage)) {
-        if (!value || typeof value !== "object") {
+    for (const value of Object.values(usageRecord)) {
+        const valueRecord = toObjectRecord(value);
+        if (!valueRecord) {
             continue;
         }
-        const contextWindow = value.contextWindow;
+        const contextWindow = valueRecord.contextWindow;
         if (typeof contextWindow !== "number" ||
             !Number.isFinite(contextWindow) ||
             contextWindow <= 0) {
@@ -1077,8 +1066,8 @@ function readUsageFromTaskNotification(message) {
     return readUsageTotalTokens(message.usage);
 }
 function readStreamRequestInputTokens(event) {
-    const messageUsage = event.message?.usage;
-    if (!messageUsage || typeof messageUsage !== "object") {
+    const messageUsage = toObjectRecord(toObjectRecord(event.message)?.usage);
+    if (!messageUsage) {
         return undefined;
     }
     const usage = messageUsage;
@@ -1099,7 +1088,7 @@ function readStreamRequestInputTokens(event) {
     return inputTokens + cacheCreationInputTokens + cacheReadInputTokens;
 }
 function readStreamRequestOutputTokens(event) {
-    const outputTokens = event.usage?.output_tokens;
+    const outputTokens = toObjectRecord(event.usage)?.output_tokens;
     if (typeof outputTokens !== "number" || !Number.isFinite(outputTokens) || outputTokens < 0) {
         return undefined;
     }
@@ -1217,7 +1206,8 @@ class ClaudeAgentSession {
         this.runtimeSettings = options.runtimeSettings;
         this.persistSession = options.persistSession;
         this.logger = options.logger;
-        this.queryFactory = options.queryFactory ?? query;
+        this.queryFactory = options.queryFactory;
+        this.resolveBinary = options.resolveBinary;
         const handle = options.handle;
         if (handle) {
             if (!handle.sessionId) {
@@ -1525,6 +1515,21 @@ class ClaudeAgentSession {
         await this.awaitWithTimeout(this.query?.return?.(), "close query return");
         this.query = null;
         this.input = null;
+        if (this.persistSession === false && this.claudeSessionId) {
+            // Claude Code currently ignores --no-session-persistence outside --print mode
+            // (see `claude --help`), so the SDK's persistSession=false is silently dropped
+            // in stream-json mode. Sweep the transcript ourselves so ephemeral runs
+            // (metadata generator, branch-name generator) don't show up as resumable.
+            const historyPath = this.resolveHistoryPath(this.claudeSessionId);
+            if (historyPath) {
+                try {
+                    await promises.rm(historyPath, { force: true });
+                }
+                catch (error) {
+                    this.logger.warn({ err: error, historyPath, claudeSessionId: this.claudeSessionId }, "Failed to delete ephemeral Claude session transcript");
+                }
+            }
+        }
         this.logger.trace({ claudeSessionId: this.claudeSessionId, turnState: this.turnState }, "Claude session close: completed");
     }
     async listCommands() {
@@ -1745,7 +1750,11 @@ class ClaudeAgentSession {
         const options = await this.buildOptions();
         this.logger.debug({ options: summarizeClaudeOptionsForLog(options) }, "claude query");
         this.input = input;
-        this.query = this.queryFactory({ prompt: input.iterable, options });
+        this.query = claudeQuery({ prompt: input.iterable, options }, {
+            runtimeSettings: this.runtimeSettings,
+            launchEnv: this.launchEnv,
+            queryFactory: this.queryFactory,
+        });
         // Do not kick off background control-plane queries here. Methods like
         // supportedCommands()/setPermissionMode() may execute immediately after
         // ensureQuery() (for listCommands()/setMode()), and sharing the same query
@@ -1772,12 +1781,7 @@ class ClaudeAgentSession {
             ? this.config.thinkingOptionId
             : undefined;
         if (thinkingOptionId && isClaudeThinkingEffort(thinkingOptionId)) {
-            // SDK 0.2.71 types `effort` as 'low' | 'medium' | 'high' | 'max'; Opus 4.7
-            // adds 'xhigh' which the binary accepts but the typings don't yet expose.
-            return {
-                thinking: { type: "adaptive" },
-                effort: thinkingOptionId,
-            };
+            return { thinking: { type: "adaptive" }, effort: thinkingOptionId };
         }
         return { thinking: undefined, effort: undefined };
     }
@@ -1803,7 +1807,7 @@ class ClaudeAgentSession {
                 this.launchEnv,
             ],
         });
-        const claudeBinary = await findExecutable("claude");
+        const claudeBinary = await this.resolveBinary();
         this.logger.debug({
             claudeBinary,
             pathEnvKey: resolvePathEnvKey(),
@@ -1821,7 +1825,7 @@ class ClaudeAgentSession {
             allowDangerouslySkipPermissions: true,
             agents: this.defaults?.agents,
             canUseTool: this.handlePermissionRequest,
-            ...(claudeBinary ? { pathToClaudeCodeExecutable: claudeBinary } : {}),
+            pathToClaudeCodeExecutable: claudeBinary,
             // Use Claude Code preset system prompt and load CLAUDE.md files
             // Append provider-agnostic system prompt and orchestrator instructions for agents.
             systemPrompt: {
@@ -1861,10 +1865,7 @@ class ClaudeAgentSession {
                 ...this.runtimeSettings.disallowedTools,
             ];
         }
-        return this.applyRuntimeSettings(base);
-    }
-    applyRuntimeSettings(options) {
-        return applyRuntimeSettingsToClaudeOptions(options, this.runtimeSettings, this.launchEnv);
+        return base;
     }
     normalizeMcpServers(servers) {
         const result = {};
@@ -1881,14 +1882,16 @@ class ClaudeAgentSession {
                     content.push({ type: "text", text: chunk.text });
                 }
                 else if (chunk.type === "image") {
-                    content.push({
-                        type: "image",
-                        source: {
-                            type: "base64",
-                            media_type: chunk.mimeType,
-                            data: chunk.data,
-                        },
-                    });
+                    if (isImageMimeType(chunk.mimeType)) {
+                        content.push({
+                            type: "image",
+                            source: {
+                                type: "base64",
+                                media_type: chunk.mimeType,
+                                data: chunk.data,
+                            },
+                        });
+                    }
                 }
                 else {
                     content.push({ type: "text", text: renderPromptAttachmentAsText(chunk) });
@@ -2107,7 +2110,7 @@ class ClaudeAgentSession {
             this.logger.trace({ err: error }, "Claude query pump exited unexpectedly");
         });
         this.queryPumpPromise = pump;
-        pump.finally(() => {
+        void pump.finally(() => {
             if (this.queryPumpPromise === pump) {
                 this.queryPumpPromise = null;
             }
@@ -2386,7 +2389,7 @@ class ClaudeAgentSession {
             return;
         }
         if (message.subtype === "status") {
-            const status = message.status;
+            const status = toObjectRecord(message)?.status;
             if (status === "compacting") {
                 this.compacting = true;
                 events.push({
@@ -2412,6 +2415,16 @@ class ClaudeAgentSession {
             return;
         }
         if (message.subtype === "task_notification") {
+            // TODO: subagent timelines are best-effort. Subagent task_notifications
+            // arrive without parent_tool_use_id but with tool_use_id pointing at the
+            // parent's Task call, so they slip past the sidechain router and pollute
+            // the parent timeline. Drop them here; eventually thread them into the
+            // parent Task tool call's sub_agent log instead.
+            const taskUseId = message.tool_use_id;
+            const cachedTool = taskUseId ? this.toolUseCache.get(taskUseId) : undefined;
+            if (cachedTool?.name === "Task") {
+                return;
+            }
             const taskNotificationItem = mapTaskNotificationSystemRecordToToolCall(message);
             if (taskNotificationItem) {
                 events.push({
@@ -2523,8 +2536,12 @@ class ClaudeAgentSession {
         };
     }
     captureSessionIdFromMessage(message) {
-        const msg = message;
-        const sessionId = extractSessionIdRaw(msg).trim();
+        const msgRecord = toObjectRecord(message) ?? {};
+        const sessionId = extractSessionIdRaw({
+            session_id: msgRecord.session_id,
+            sessionId: msgRecord.sessionId,
+            session: isObjectRecord(msgRecord.session) ? { id: msgRecord.session.id } : null,
+        }).trim();
         if (!sessionId) {
             return { threadStartedSessionId: null, notice: null };
         }
@@ -2552,8 +2569,12 @@ class ClaudeAgentSession {
         if (message.subtype !== "init") {
             return { threadStartedSessionId: null, notice: null };
         }
-        const msg = message;
-        const newSessionId = extractSessionIdRaw(msg).trim();
+        const msgRecord = toObjectRecord(message) ?? {};
+        const newSessionId = extractSessionIdRaw({
+            session_id: msgRecord.session_id,
+            sessionId: msgRecord.sessionId,
+            session: isObjectRecord(msgRecord.session) ? { id: msgRecord.session.id } : null,
+        }).trim();
         if (!newSessionId) {
             return { threadStartedSessionId: null, notice: null };
         }
@@ -2676,10 +2697,10 @@ class ClaudeAgentSession {
         };
     }
     trackStreamEventUsage(event) {
-        if (!event || typeof event !== "object") {
+        const streamEvent = toObjectRecord(event);
+        if (!streamEvent) {
             return null;
         }
-        const streamEvent = event;
         const eventType = readTrimmedString(streamEvent.type);
         if (eventType === "message_start") {
             const inputTokens = readStreamRequestInputTokens(streamEvent);
@@ -2793,7 +2814,12 @@ class ClaudeAgentSession {
         }
         let entry;
         try {
-            entry = JSON.parse(trimmed);
+            const parsed = JSON.parse(trimmed);
+            const record = toObjectRecord(parsed);
+            if (!record) {
+                return;
+            }
+            entry = record;
         }
         catch {
             return;
@@ -3334,12 +3360,20 @@ function hasToolLikeBlock(block) {
     return type.includes("tool");
 }
 function readCompactionMetadata(source) {
-    const candidates = [source.compact_metadata, source.compactMetadata, source.compactionMetadata];
+    const sourceRecord = toObjectRecord(source);
+    if (!sourceRecord) {
+        return null;
+    }
+    const candidates = [
+        sourceRecord.compact_metadata,
+        sourceRecord.compactMetadata,
+        sourceRecord.compactionMetadata,
+    ];
     for (const candidate of candidates) {
-        if (!candidate || typeof candidate !== "object") {
+        const metadata = toObjectRecord(candidate);
+        if (!metadata) {
             continue;
         }
-        const metadata = candidate;
         const trigger = typeof metadata.trigger === "string" ? metadata.trigger : undefined;
         const preTokensRaw = metadata.preTokens ?? metadata.pre_tokens;
         const preTokens = typeof preTokensRaw === "number" ? preTokensRaw : undefined;
@@ -3529,10 +3563,10 @@ function isFinishedAccumulator(acc) {
     return Boolean(acc.sessionId && acc.cwd && acc.title);
 }
 function applyClaudeSessionEntryToAccumulator(entryRaw, acc) {
-    if (!entryRaw || typeof entryRaw !== "object") {
+    const entry = toObjectRecord(entryRaw);
+    if (!entry) {
         return;
     }
-    const entry = entryRaw;
     if (entry.isSidechain) {
         return;
     }
@@ -3616,10 +3650,10 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
     };
 }
 function extractClaudeUserText(messageRaw) {
-    if (!messageRaw || typeof messageRaw !== "object") {
+    const message = toObjectRecord(messageRaw);
+    if (!message) {
         return null;
     }
-    const message = messageRaw;
     if (typeof message.content === "string") {
         const normalized = message.content.trim();
         return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
@@ -3628,12 +3662,11 @@ function extractClaudeUserText(messageRaw) {
         const normalized = message.text.trim();
         return normalized && !isClaudeTranscriptNoiseText(normalized) ? normalized : null;
     }
-    if (Array.isArray(message.content)) {
+    if (isUnknownArray(message.content)) {
         for (const block of message.content) {
-            if (block &&
-                typeof block === "object" &&
-                typeof block.text === "string") {
-                const normalized = block.text.trim();
+            const blockRecord = toObjectRecord(block);
+            if (blockRecord && typeof blockRecord.text === "string") {
+                const normalized = blockRecord.text.trim();
                 if (normalized && !isClaudeTranscriptNoiseText(normalized)) {
                     return normalized;
                 }
@@ -3642,4 +3675,4 @@ function extractClaudeUserText(messageRaw) {
     }
     return null;
 }
-//# sourceMappingURL=claude-agent.js.map
+//# sourceMappingURL=agent.js.map