@parall/claude-agent 1.30.0 → 1.32.0

package/dist/index.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-import * as os from "node:os";
-import { ParallAgentGateway, createPlatformConfigManager, createLogger, childLogger, isPlatformManagedProfile, parseShutdownDeadlineMs } from "@parall/agent-core";
-import { ApiError, ParallClient, ParallWs } from "@parall/sdk";
-import { buildClaudeRuntimeKey, contextFilePathForSession, resolveClaudeAgentConfig, resolveWsUrl, sessionStateFilePathForRuntime, stepIdFilePathForSession, } from "./config.js";
-import { ClaudeCodeAdapter } from "./dispatch.js";
-import { ClaudeSessionManager } from "./session-manager.js";
-import { ensureClaudeWorkspace } from "./workspace.js";
-const log = createLogger("claude-agent");
+import * as os from 'node:os';
+import { ParallAgentGateway, createPlatformConfigManager, createLogger, createOtelLogger, childLogger, isPlatformManagedProfile, isPlatformModelOverride, resolveRuntimeModel, parseShutdownDeadlineMs, parseForkDeadlineMs, parseDispatchDeadlineMs, parseProviderConfig, clearAllProviderCreds, llmSource, initAgentTelemetry, } from '@parall/agent-core';
+import { ApiError, ParallClient, ParallWs } from '@parall/sdk';
+import { buildClaudeRuntimeKey, contextFilePathForSession, resolveClaudeAgentConfig, resolveWsUrl, sessionStateFilePathForRuntime, stepIdFilePathForSession, } from './config.js';
+import { ClaudeCodeAdapter } from './dispatch.js';
+import { ClaudeSessionManager } from './session-manager.js';
+import { ensureClaudeWorkspace } from './workspace.js';
+const log = createLogger('claude-agent');
 let activeLog = log;
 async function getAgentMeWithLegacyFallback(client, orgId) {
     try {
@@ -20,137 +20,188 @@ async function getAgentMeWithLegacyFallback(client, orgId) {
         return { ...user, agent_profile: null };
     }
 }
-async function main() {
-    const config = resolveClaudeAgentConfig(process.env);
-    if (config.allowApiKey &&
-        (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN)) {
-        // Surface the billing path: default is OAuth (Claude.ai subscription); this
-        // branch means the operator opted into Anthropic API pay-per-use, and the
-        // whole point of the strip default is that "silent" is the bad state.
-        log.warn("PRLL_CLAUDE_ALLOW_API_KEY=1 — ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN will reach the Claude CLI; billing routes through Anthropic API pay-per-use instead of Claude.ai OAuth.");
+function resolveProviderEnv() {
+    const pc = parseProviderConfig(process.env);
+    if (!pc)
+        return;
+    clearAllProviderCreds(process.env);
+    const source = llmSource(pc);
+    if (source === 'parall') {
+        process.env.ANTHROPIC_AUTH_TOKEN = process.env.PRLL_API_KEY;
+        process.env.ANTHROPIC_BASE_URL = `${process.env.PRLL_API_URL}/api/llm`;
+        process.env.PRLL_CLAUDE_ALLOW_API_KEY = '1';
     }
-    const client = new ParallClient({
-        baseUrl: config.apiUrl,
-        token: config.apiKey,
-        swimlaneName: config.swimlaneName,
-    });
-    const me = await getAgentMeWithLegacyFallback(client, config.orgId);
-    const agentUserId = me.id;
-    const agentLog = childLogger(log, agentUserId);
-    activeLog = agentLog;
-    ensureClaudeWorkspace(config.workspaceDir, agentLog, {
-        userId: agentUserId,
-        displayName: me.display_name,
-        description: me.agent_profile?.description ?? undefined,
-    });
-    const runtimeKey = config.runtimeKey || buildClaudeRuntimeKey(agentUserId);
-    const sessionStateFilePath = sessionStateFilePathForRuntime(config.stateDir, runtimeKey);
-    const sessionManager = new ClaudeSessionManager(runtimeKey, sessionStateFilePath, agentLog);
-    const resolvedWsUrl = resolveWsUrl(config.apiUrl, config.wsUrl, config.swimlaneName);
-    const ws = new ParallWs({
-        getTicket: () => client.getWsTicket(),
-        wsUrl: resolvedWsUrl,
-    });
-    const configMgr = createPlatformConfigManager({ client, stateDir: config.stateDir, runtimeType: "claude-code", log: agentLog });
-    const platformDefaults = await configMgr.fetch();
-    let platformManaged = isPlatformManagedProfile(me.agent_profile);
-    const resolvedModel = platformManaged ? (platformDefaults.model ?? config.model) : config.model;
-    const resolvedEffort = platformManaged
-        ? (platformDefaults.thinkingEffort ?? (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined))
-        : (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined);
-    if (platformDefaults.model)
-        agentLog.info(`platform config: model=${platformDefaults.model} (${platformManaged ? "applied" : "ignored, model_management=self"})`);
-    if (platformDefaults.thinkingEffort)
-        agentLog.info(`platform config: thinking_effort=${platformDefaults.thinkingEffort} (${platformManaged ? "applied" : "ignored, model_management=self"})`);
-    const adapter = new ClaudeCodeAdapter({
-        claudeBin: config.claudeBin,
-        claudeHome: config.claudeHome,
-        workspaceDir: config.workspaceDir,
-        model: resolvedModel,
-        permissionMode: config.permissionMode,
-        allowedTools: config.allowedTools,
-        disallowedTools: config.disallowedTools,
-        additionalDirs: config.additionalDirs,
-        appendSystemPrompt: config.appendSystemPrompt,
-        allowApiKey: config.allowApiKey,
-        sessionManager,
-        // Static Parall credentials. The long-lived subprocess must authenticate
-        // against Parall's API across many dispatches, so these cannot come from
-        // a per-dispatch DispatchContext.
-        apiUrl: config.apiUrl,
-        apiKey: config.apiKey,
-        orgId: config.orgId,
-        contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
-        stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
-    });
-    if (resolvedEffort) {
-        adapter.updateConfig({ effort: resolvedEffort });
+    else if (source === 'custom') {
+        if (pc.anthropic_auth_token) {
+            process.env.ANTHROPIC_AUTH_TOKEN = pc.anthropic_auth_token;
+            process.env.PRLL_CLAUDE_ALLOW_API_KEY = '1';
+        }
+        if (pc.anthropic_base_url)
+            process.env.ANTHROPIC_BASE_URL = pc.anthropic_base_url;
     }
-    const gateway = new ParallAgentGateway({
-        accountId: agentUserId,
-        client,
-        ws,
-        connectionLabel: resolvedWsUrl,
-        config: {
-            parall_url: config.apiUrl,
-            api_key: config.apiKey,
-            org_id: config.orgId,
-        },
-        agentUserId,
-        runtimeType: "claude-code",
-        runtimeKey,
-        runtimeRef: {
-            hostname: os.hostname(),
-            pid: process.pid,
-            workspace_dir: config.workspaceDir,
-            claude_home: config.claudeHome,
-        },
-        dispatchAdapter: adapter,
-        log: agentLog,
-        shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
-        contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
-        stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
-        onConfigUpdate: async () => {
-            const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
-            platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
-            const updated = await configMgr.fetch();
-            const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
-            adapter.updateConfig({
-                model: platformManaged ? (updated.model ?? config.model) : (config.model ?? null),
-                effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
-            });
-        },
-        onSessionReady: async () => {
-            const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
-            platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
-            const updated = await configMgr.fetch();
-            const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
-            adapter.updateConfig({
-                model: platformManaged ? (updated.model ?? config.model) : (config.model ?? null),
-                effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
-            });
-        },
-        // Long-lived `claude` subprocesses outlive a single dispatch, so the
-        // gateway's shuttingDown flag alone does not tear them down. Piggyback on
-        // onBeforeDisconnect to close stdin and SIGTERM any survivors after
-        // in-flight drains finish.
-        onBeforeDisconnect: () => adapter.shutdown(),
-        onNewSession: async () => {
-            sessionManager.clearMainSession();
-            await adapter.shutdown();
-        },
-    });
-    const abortController = new AbortController();
-    const abort = () => abortController.abort();
-    process.on("SIGINT", abort);
-    process.on("SIGTERM", abort);
+}
+async function main() {
+    const telemetry = await initAgentTelemetry('parall-claude-agent', 'claude-code');
+    activeLog = createOtelLogger('agent', 'claude-agent');
     try {
-        agentLog.info(`starting self-hosted Claude runtime for ${me.display_name} (${agentUserId})`);
-        await gateway.run(abortController.signal);
+        resolveProviderEnv();
+        const config = resolveClaudeAgentConfig(process.env);
+        if (config.allowApiKey && (process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN)) {
+            // Surface the billing path: default is OAuth (Claude.ai subscription); this
+            // branch means the operator opted into Anthropic API pay-per-use, and the
+            // whole point of the strip default is that "silent" is the bad state.
+            activeLog.warn('PRLL_CLAUDE_ALLOW_API_KEY=1 — ANTHROPIC_API_KEY/ANTHROPIC_AUTH_TOKEN will reach the Claude CLI; billing routes through Anthropic API pay-per-use instead of Claude.ai OAuth.');
+        }
+        const client = new ParallClient({
+            baseUrl: config.apiUrl,
+            token: config.apiKey,
+            swimlaneName: config.swimlaneName,
+        });
+        const me = await getAgentMeWithLegacyFallback(client, config.orgId);
+        const agentUserId = me.id;
+        const agentLog = childLogger(activeLog, agentUserId);
+        activeLog = agentLog;
+        ensureClaudeWorkspace(config.workspaceDir, agentLog, {
+            userId: agentUserId,
+            displayName: me.display_name,
+            description: me.agent_profile?.description ?? undefined,
+        });
+        const runtimeKey = config.runtimeKey || buildClaudeRuntimeKey(agentUserId);
+        const sessionStateFilePath = sessionStateFilePathForRuntime(config.stateDir, runtimeKey);
+        const sessionManager = new ClaudeSessionManager(runtimeKey, sessionStateFilePath, agentLog);
+        const resolvedWsUrl = resolveWsUrl(config.apiUrl, config.wsUrl, config.swimlaneName);
+        const ws = new ParallWs({
+            getTicket: () => client.getWsTicket(),
+            wsUrl: resolvedWsUrl,
+        });
+        const configMgr = createPlatformConfigManager({
+            client,
+            stateDir: config.stateDir,
+            runtimeType: 'claude-code',
+            log: agentLog,
+        });
+        const platformDefaults = await configMgr.fetch();
+        let platformManaged = isPlatformManagedProfile(me.agent_profile);
+        // Model precedence: operator override (platform-managed) > env > server floor.
+        // The server delivers a model floor for Parall-proxy routes even when
+        // model_management=self, so the CLI never falls back to a built-in default
+        // the catalog might reject — but that floor must lose to an explicit env
+        // override (env > floor). A profile is an operator-override only when it is
+        // platform-managed AND not explicitly self-managed: this treats legacy hosted
+        // agents (model_management=null, resolved to platform server-side) as
+        // overrides, while excluding local self agents whose delivered model is a
+        // floor. effort stays an operator override (platform).
+        let platformModelOverride = isPlatformModelOverride(me.agent_profile);
+        const resolvedModel = resolveRuntimeModel(platformModelOverride, platformDefaults.model, config.model);
+        const resolvedEffort = platformManaged
+            ? (platformDefaults.thinkingEffort ??
+                (process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined))
+            : process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || undefined;
+        if (platformDefaults.model)
+            agentLog.info(`platform config: model=${platformDefaults.model} → resolved=${resolvedModel ?? 'cli-default'} (${platformModelOverride ? 'platform-managed' : 'floor/self'})`);
+        if (platformDefaults.thinkingEffort)
+            agentLog.info(`platform config: thinking_effort=${platformDefaults.thinkingEffort} (${platformModelOverride ? 'applied' : 'ignored, model_management=self'})`);
+        const adapter = new ClaudeCodeAdapter({
+            claudeBin: config.claudeBin,
+            claudeHome: config.claudeHome,
+            workspaceDir: config.workspaceDir,
+            model: resolvedModel,
+            permissionMode: config.permissionMode,
+            allowedTools: config.allowedTools,
+            disallowedTools: config.disallowedTools,
+            additionalDirs: config.additionalDirs,
+            appendSystemPrompt: config.appendSystemPrompt,
+            allowApiKey: config.allowApiKey,
+            sessionManager,
+            // Static Parall credentials. The long-lived subprocess must authenticate
+            // against Parall's API across many dispatches, so these cannot come from
+            // a per-dispatch DispatchContext.
+            apiUrl: config.apiUrl,
+            apiKey: config.apiKey,
+            orgId: config.orgId,
+            contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
+            stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
+        });
+        if (resolvedEffort) {
+            adapter.updateConfig({ effort: resolvedEffort });
+        }
+        const gateway = new ParallAgentGateway({
+            accountId: agentUserId,
+            client,
+            ws,
+            connectionLabel: resolvedWsUrl,
+            config: {
+                parall_url: config.apiUrl,
+                api_key: config.apiKey,
+                org_id: config.orgId,
+            },
+            agentUserId,
+            runtimeType: 'claude-code',
+            runtimeKey,
+            runtimeRef: {
+                hostname: os.hostname(),
+                pid: process.pid,
+                workspace_dir: config.workspaceDir,
+                claude_home: config.claudeHome,
+            },
+            dispatchAdapter: adapter,
+            log: agentLog,
+            shutdownDeadlineMs: parseShutdownDeadlineMs(process.env.PRLL_SHUTDOWN_DEADLINE_MS),
+            forkDeadlineMs: parseForkDeadlineMs(process.env.PRLL_FORK_DEADLINE_MS),
+            dispatchDeadlineMs: parseDispatchDeadlineMs(process.env.PRLL_DISPATCH_DEADLINE_MS),
+            contextFilePathForSession: (sessionKey) => contextFilePathForSession(config.stateDir, sessionKey),
+            stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
+            onConfigUpdate: async () => {
+                const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
+                platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
+                platformModelOverride = isPlatformModelOverride(refreshed.agent_profile);
+                const updated = await configMgr.fetch();
+                const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
+                adapter.updateConfig({
+                    model: resolveRuntimeModel(platformModelOverride, updated.model, config.model) ?? null,
+                    effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
+                });
+            },
+            onSessionReady: async () => {
+                const refreshed = await getAgentMeWithLegacyFallback(client, config.orgId);
+                platformManaged = isPlatformManagedProfile(refreshed.agent_profile);
+                platformModelOverride = isPlatformModelOverride(refreshed.agent_profile);
+                const updated = await configMgr.fetch();
+                const localEffort = process.env.CLAUDE_CODE_EFFORT_LEVEL?.trim() || null;
+                adapter.updateConfig({
+                    model: resolveRuntimeModel(platformModelOverride, updated.model, config.model) ?? null,
+                    effort: platformManaged ? (updated.thinkingEffort ?? localEffort) : localEffort,
+                });
+            },
+            // Long-lived `claude` subprocesses outlive a single dispatch, so the
+            // gateway's shuttingDown flag alone does not tear them down. Piggyback on
+            // onBeforeDisconnect to close stdin and SIGTERM any survivors after
+            // in-flight drains finish.
+            onBeforeDisconnect: () => adapter.shutdown(),
+            onNewSession: async () => {
+                sessionManager.clearMainSession();
+                adapter.resetProcesses();
+            },
+            onSessionStale: () => {
+                sessionManager.clearMainSession();
+                adapter.resetProcesses();
+            },
+        });
+        const abortController = new AbortController();
+        const abort = () => abortController.abort();
+        process.on('SIGINT', abort);
+        process.on('SIGTERM', abort);
+        try {
+            agentLog.info(`starting self-hosted Claude runtime for ${me.display_name} (${agentUserId})`);
+            await gateway.run(abortController.signal);
+        }
+        finally {
+            process.off('SIGINT', abort);
+            process.off('SIGTERM', abort);
+        }
     }
     finally {
-        process.off("SIGINT", abort);
-        process.off("SIGTERM", abort);
+        await telemetry.shutdown();
     }
 }
 main().catch((err) => {

package/dist/output-parser.d.ts

@@ -1,10 +1,10 @@
-import type { Readable } from "node:stream";
-import type { RuntimeEvent } from "@parall/agent-core";
+import type { Readable } from 'node:stream';
+import type { RuntimeEvent } from '@parall/agent-core';
 export type ClaudeParsedEvent = RuntimeEvent | {
-    type: "session_id";
+    type: 'session_id';
     sessionId: string;
 } | {
-    type: "turn_end";
+    type: 'turn_end';
     sessionId?: string;
     isError: boolean;
 };

package/dist/output-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output-parser.d.ts","sourceRoot":"","sources":["../src/output-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAWzC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AA4E/D,wBAAuB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,cAAc,CAAC,iBAAiB,CAAC,CA8HlG"}
+{"version":3,"file":"output-parser.d.ts","sourceRoot":"","sources":["../src/output-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,MAAM,MAAM,iBAAiB,GACzB,YAAY,GACZ;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAWzC;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;AA4E/D,wBAAuB,qBAAqB,CAC1C,QAAQ,EAAE,QAAQ,GACjB,cAAc,CAAC,iBAAiB,CAAC,CAiInC"}

package/dist/output-parser.js

@@ -1,28 +1,28 @@
 function asTrimmedString(value) {
-    if (typeof value !== "string")
+    if (typeof value !== 'string')
         return undefined;
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
 function parseEventTimestampMs(event) {
-    if (!event || typeof event !== "object")
+    if (!event || typeof event !== 'object')
         return undefined;
     const timestamp = event.timestamp;
-    if (typeof timestamp !== "string")
+    if (typeof timestamp !== 'string')
         return undefined;
     const ms = Date.parse(timestamp);
     return Number.isFinite(ms) ? ms : undefined;
 }
 function stringifyContent(value) {
-    if (typeof value === "string")
+    if (typeof value === 'string')
         return value;
     if (Array.isArray(value)) {
         return value
             .map((item) => {
-            if (typeof item === "string")
+            if (typeof item === 'string')
                 return item;
-            if (!item || typeof item !== "object")
-                return "";
+            if (!item || typeof item !== 'object')
+                return '';
             const text = asTrimmedString(item.text);
             if (text)
                 return text;
@@ -32,18 +32,18 @@ function stringifyContent(value) {
             return JSON.stringify(item);
         })
             .filter(Boolean)
-            .join("\n");
+            .join('\n');
     }
-    if (value && typeof value === "object") {
+    if (value && typeof value === 'object') {
         return JSON.stringify(value);
     }
-    return "";
+    return '';
 }
 function normalizeToolResultContent(content, fallback) {
     const direct = stringifyContent(content).trim();
     if (direct)
         return direct;
-    if (fallback && typeof fallback === "object") {
+    if (fallback && typeof fallback === 'object') {
         const stdout = asTrimmedString(fallback.stdout);
         const stderr = asTrimmedString(fallback.stderr);
         if (stdout && stderr)
@@ -53,20 +53,20 @@ function normalizeToolResultContent(content, fallback) {
         if (stderr)
             return stderr;
     }
-    return "";
+    return '';
 }
 async function* readJsonLines(readable) {
-    let buffer = "";
-    readable.setEncoding("utf8");
+    let buffer = '';
+    readable.setEncoding('utf8');
     for await (const chunk of readable) {
         buffer += chunk;
-        let newlineIndex = buffer.indexOf("\n");
+        let newlineIndex = buffer.indexOf('\n');
         while (newlineIndex >= 0) {
             const line = buffer.slice(0, newlineIndex).trim();
             buffer = buffer.slice(newlineIndex + 1);
             if (line)
                 yield line;
-            newlineIndex = buffer.indexOf("\n");
+            newlineIndex = buffer.indexOf('\n');
         }
     }
     const tail = buffer.trim();
@@ -83,45 +83,45 @@ export async function* parseClaudeStreamJson(readable) {
         catch {
             continue;
         }
-        if (!event || typeof event !== "object")
+        if (!event || typeof event !== 'object')
             continue;
         const now = Date.now();
         const eventTimestampMs = parseEventTimestampMs(event) ?? now;
         const eventRecord = event;
-        if (eventRecord.type === "system" && eventRecord.subtype === "init") {
+        if (eventRecord.type === 'system' && eventRecord.subtype === 'init') {
             const sessionId = asTrimmedString(eventRecord.session_id);
             if (sessionId) {
-                yield { type: "session_id", sessionId };
+                yield { type: 'session_id', sessionId };
             }
             continue;
         }
-        if (eventRecord.type === "assistant") {
+        if (eventRecord.type === 'assistant') {
             if (eventRecord.error)
                 continue;
             const message = eventRecord.message;
-            const content = message && typeof message === "object"
+            const content = message && typeof message === 'object'
                 ? message.content
                 : undefined;
             if (!Array.isArray(content))
                 continue;
             for (const block of content) {
-                if (!block || typeof block !== "object")
+                if (!block || typeof block !== 'object')
                     continue;
                 const blockRecord = block;
                 switch (blockRecord.type) {
-                    case "thinking": {
+                    case 'thinking': {
                         const text = asTrimmedString(blockRecord.thinking);
                         if (text)
-                            yield { type: "thinking", text };
+                            yield { type: 'thinking', text };
                         break;
                     }
-                    case "text": {
+                    case 'text': {
                         const text = asTrimmedString(blockRecord.text);
                         if (text)
-                            yield { type: "text", text, project: true };
+                            yield { type: 'text', text, project: true };
                         break;
                     }
-                    case "tool_use": {
+                    case 'tool_use': {
                         const callId = asTrimmedString(blockRecord.id);
                         const toolName = asTrimmedString(blockRecord.name);
                         if (!callId || !toolName)
@@ -131,7 +131,7 @@ export async function* parseClaudeStreamJson(readable) {
                             startedAtMs: eventTimestampMs,
                         });
                         yield {
-                            type: "tool_call",
+                            type: 'tool_call',
                             callId,
                             toolName,
                             input: blockRecord.input ?? {},
@@ -143,18 +143,18 @@ export async function* parseClaudeStreamJson(readable) {
             }
             continue;
         }
-        if (eventRecord.type === "user") {
+        if (eventRecord.type === 'user') {
             const message = eventRecord.message;
-            const content = message && typeof message === "object"
+            const content = message && typeof message === 'object'
                 ? message.content
                 : undefined;
             if (!Array.isArray(content))
                 continue;
             for (const block of content) {
-                if (!block || typeof block !== "object")
+                if (!block || typeof block !== 'object')
                     continue;
                 const blockRecord = block;
-                if (blockRecord.type !== "tool_result")
+                if (blockRecord.type !== 'tool_result')
                     continue;
                 const callId = asTrimmedString(blockRecord.tool_use_id);
                 if (!callId)
@@ -162,24 +162,24 @@ export async function* parseClaudeStreamJson(readable) {
                 const meta = toolUses.get(callId);
                 const output = normalizeToolResultContent(blockRecord.content, eventRecord.tool_use_result);
                 yield {
-                    type: "tool_result",
+                    type: 'tool_result',
                     callId,
-                    toolName: meta?.toolName ?? "unknown",
+                    toolName: meta?.toolName ?? 'unknown',
                     output,
-                    ...(blockRecord.is_error === true ? { error: output || "Tool call failed" } : {}),
+                    ...(blockRecord.is_error === true ? { error: output || 'Tool call failed' } : {}),
                     ...(meta ? { durationMs: Math.max(0, eventTimestampMs - meta.startedAtMs) } : {}),
                 };
                 toolUses.delete(callId);
             }
             continue;
         }
-        if (eventRecord.type === "result") {
+        if (eventRecord.type === 'result') {
             const isError = eventRecord.is_error === true;
             if (isError) {
-                const message = asTrimmedString(eventRecord.result)
-                    || asTrimmedString(eventRecord.error)
-                    || "Claude dispatch failed";
-                yield { type: "error", message };
+                const message = asTrimmedString(eventRecord.result) ||
+                    asTrimmedString(eventRecord.error) ||
+                    'Claude dispatch failed';
+                yield { type: 'error', message };
             }
             // Turn boundary: the subprocess lives across many turns, so any
             // tool_use entries that never matched a tool_result this turn
@@ -188,7 +188,7 @@ export async function* parseClaudeStreamJson(readable) {
             // the map grow unbounded or mislabel durations on id collisions.
             toolUses.clear();
             yield {
-                type: "turn_end",
+                type: 'turn_end',
                 sessionId: asTrimmedString(eventRecord.session_id),
                 isError,
             };

package/dist/session-manager.d.ts

@@ -1,5 +1,5 @@
-import type { ChildProcessWithoutNullStreams } from "node:child_process";
-import type { ForkSessionHandle } from "@parall/agent-core";
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+import type { ForkSessionHandle } from '@parall/agent-core';
 type ClaudeSessionManagerLogger = {
     warn(message: string): void;
 };

package/dist/session-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAO5D,KAAK,0BAA0B,GAAG;IAChC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,8BAA8B,CAAC;IACrC,WAAW,EAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAC7E,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;gBAGjD,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,0BAA0B,YAAA;IAKtD,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpD,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAU3C,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQrD,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAYrE,WAAW,CAAC,UAAU,EAAE,MAAM;IAU9B,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI/D,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB;IAsB/D,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB;IAO7D,qEAAqE;IACrE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE5C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;YAQpB,WAAW;IAuCzB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAqBnB,gBAAgB;IAShB,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,OAAO;CAahB"}
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAO5D,KAAK,0BAA0B,GAAG;IAChC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,8BAA8B,CAAC;IACrC,WAAW,EAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;KAAE,CAAC,CAAC;IAC7E,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAEF,qBAAa,oBAAoB;IAM7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAP1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;IAChE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0C;gBAGjD,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,0BAA0B,YAAA;IAKtD,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIpD,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAU3C,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAQrD,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IAYrE,WAAW,CAAC,UAAU,EAAE,MAAM;IAU9B,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAI/D,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB;IAsB/D,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB;IAO7D,qEAAqE;IACrE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAE5C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;YAMpB,WAAW;IAmCzB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,WAAW;IAmBnB,gBAAgB;IAShB,OAAO,CAAC,OAAO;IAgBf,OAAO,CAAC,OAAO;CAoBhB"}

package/dist/session-manager.js

@@ -1,6 +1,6 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { randomUUID } from "node:crypto";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
 export class ClaudeSessionManager {
     mainSessionKey;
     stateFilePath;
@@ -20,10 +20,10 @@ export class ClaudeSessionManager {
     getResumeArgs(sessionKey) {
         const existing = this.sessionIds.get(sessionKey);
         if (existing)
-            return ["--resume", existing];
+            return ['--resume', existing];
         const parent = this.pendingForkParents.get(sessionKey);
         if (parent)
-            return ["--resume", parent, "--fork-session"];
+            return ['--resume', parent, '--fork-session'];
         return [];
     }
     recordSessionId(sessionKey, sessionId) {
@@ -102,7 +102,7 @@ export class ClaudeSessionManager {
         if (handle.proc.exitCode === null && handle.proc.signalCode === null) {
             this.logger?.warn(`claude-agent: SIGTERM timed out for ${sessionKey}, escalating to SIGKILL`);
             try {
-                handle.proc.kill("SIGKILL");
+                handle.proc.kill('SIGKILL');
             }
             catch (error) {
                 this.logger?.warn(`claude-agent: SIGKILL failed for ${sessionKey}: ${String(error)}`);
@@ -131,7 +131,7 @@ export class ClaudeSessionManager {
                 resolve(true);
             }, ms);
             // Don't keep the event loop alive purely on the timeout.
-            if (typeof timer.unref === "function")
+            if (typeof timer.unref === 'function')
                 timer.unref();
             promise
                 .catch(() => {
@@ -157,7 +157,7 @@ export class ClaudeSessionManager {
         }
         if (handle.proc.exitCode === null && handle.proc.signalCode === null) {
             try {
-                handle.proc.kill("SIGTERM");
+                handle.proc.kill('SIGTERM');
             }
             catch (error) {
                 this.logger?.warn(`claude-agent: failed to SIGTERM claude subprocess (${reason}): ${String(error)}`);
@@ -175,9 +175,11 @@ export class ClaudeSessionManager {
     }
     restore() {
         try {
-            const raw = fs.readFileSync(this.stateFilePath, "utf8");
+            const raw = fs.readFileSync(this.stateFilePath, 'utf8');
             const parsed = JSON.parse(raw);
-            if (parsed.runtimeKey === this.mainSessionKey && typeof parsed.sessionId === "string" && parsed.sessionId.trim()) {
+            if (parsed.runtimeKey === this.mainSessionKey &&
+                typeof parsed.sessionId === 'string' &&
+                parsed.sessionId.trim()) {
                 this.sessionIds.set(this.mainSessionKey, parsed.sessionId.trim());
             }
         }