@parall/claude-agent 1.15.1

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+export type ClaudeAgentConfig = {
+    apiUrl: string;
+    apiKey: string;
+    orgId: string;
+    wsUrl?: string;
+    swimlaneName?: string;
+    claudeBin: string;
+    claudeHome: string;
+    stateDir: string;
+    workspaceDir: string;
+    model?: string;
+    permissionMode: string;
+    allowedTools: string[];
+    disallowedTools: string[];
+    additionalDirs: string[];
+    appendSystemPrompt?: string;
+    runtimeKey?: string;
+};
+export declare function resolveClaudeAgentConfig(env?: NodeJS.ProcessEnv): ClaudeAgentConfig;
+export declare function resolveWsUrl(apiUrl: string, explicitWsUrl?: string, swimlaneName?: string): string;
+export declare function buildClaudeRuntimeKey(agentUserId: string): string;
+export declare function sessionStateFilePathForRuntime(stateDir: string, runtimeKey: string): string;
+export declare function stepIdFilePathForSession(stateDir: string, sessionKey: string): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,wBAAgB,wBAAwB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,iBAAiB,CA2BhG;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAMlG;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAG3F;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAGrF"}

package/dist/config.js

@@ -0,0 +1,66 @@
+import * as os from "node:os";
+import * as path from "node:path";
+function requireEnv(env, name) {
+    const value = env[name]?.trim();
+    if (!value) {
+        throw new Error(`Missing required env var: ${name}`);
+    }
+    return value;
+}
+function parseList(value) {
+    if (!value)
+        return [];
+    return value
+        .split(/[,\n]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function resolvePath(value) {
+    return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+}
+export function resolveClaudeAgentConfig(env = process.env) {
+    const apiUrl = requireEnv(env, "PRLL_API_URL");
+    const apiKey = requireEnv(env, "PRLL_API_KEY");
+    const orgId = requireEnv(env, "PRLL_ORG_ID");
+    const claudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os.homedir());
+    const stateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(claudeHome, ".parall-agent"));
+    const workspaceDir = resolvePath(env.PRLL_CLAUDE_WORKSPACE_DIR?.trim() || path.join(stateDir, "workspace"));
+    const additionalDirs = parseList(env.PRLL_CLAUDE_ADD_DIRS).map(resolvePath);
+    return {
+        apiUrl,
+        apiKey,
+        orgId,
+        wsUrl: env.PRLL_WS_URL?.trim() || undefined,
+        swimlaneName: env.PRLL_SWIMLANE_NAME?.trim() || undefined,
+        claudeBin: env.PRLL_CLAUDE_BIN?.trim() || "claude",
+        claudeHome,
+        stateDir,
+        workspaceDir,
+        model: env.PRLL_CLAUDE_MODEL?.trim() || undefined,
+        permissionMode: env.PRLL_CLAUDE_PERMISSION_MODE?.trim() || "bypassPermissions",
+        allowedTools: parseList(env.PRLL_CLAUDE_ALLOWED_TOOLS),
+        disallowedTools: parseList(env.PRLL_CLAUDE_DISALLOWED_TOOLS),
+        additionalDirs,
+        appendSystemPrompt: env.PRLL_CLAUDE_APPEND_SYSTEM_PROMPT?.trim() || undefined,
+        runtimeKey: env.PRLL_CLAUDE_RUNTIME_KEY?.trim() || undefined,
+    };
+}
+export function resolveWsUrl(apiUrl, explicitWsUrl, swimlaneName) {
+    const base = explicitWsUrl || `${apiUrl.replace(/\/$/, "").replace(/^http/, "ws")}/ws`;
+    if (!swimlaneName)
+        return base;
+    const url = new URL(base);
+    url.searchParams.set("swimlane", swimlaneName);
+    return url.toString();
+}
+export function buildClaudeRuntimeKey(agentUserId) {
+    return `agent:main:claude:${agentUserId}:orchestrator`;
+}
+export function sessionStateFilePathForRuntime(stateDir, runtimeKey) {
+    const fileName = Buffer.from(runtimeKey).toString("base64url");
+    return path.join(stateDir, "sessions", `${fileName}.json`);
+}
+export function stepIdFilePathForSession(stateDir, sessionKey) {
+    const fileName = Buffer.from(sessionKey).toString("base64url");
+    return path.join(stateDir, "step-ids", `${fileName}.txt`);
+}

package/dist/dispatch.d.ts

@@ -0,0 +1,16 @@
+import type { CleanupForkOpts, DispatchAdapter, DispatchOpts, ForkOpts, RuntimeEvent } from "@parall/agent-core";
+import type { ClaudeAgentConfig } from "./config.js";
+import { ClaudeSessionManager } from "./session-manager.js";
+type ClaudeCodeAdapterOptions = Pick<ClaudeAgentConfig, "additionalDirs" | "allowedTools" | "appendSystemPrompt" | "claudeBin" | "claudeHome" | "disallowedTools" | "model" | "permissionMode" | "workspaceDir"> & {
+    sessionManager: ClaudeSessionManager;
+};
+export declare class ClaudeCodeAdapter implements DispatchAdapter {
+    private readonly opts;
+    constructor(opts: ClaudeCodeAdapterOptions);
+    dispatch({ bodyForAgent, sessionKey, context }: DispatchOpts): AsyncIterable<RuntimeEvent>;
+    forkSession({ sessionKey }: ForkOpts): import("@parall/agent-core").ForkSessionHandle | null;
+    cleanupFork({ fork }: CleanupForkOpts): void;
+    private buildArgs;
+}
+export {};
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../src/dispatch.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,QAAQ,EACR,YAAY,EACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D,KAAK,wBAAwB,GAAG,IAAI,CAClC,iBAAiB,EACf,gBAAgB,GAChB,cAAc,GACd,oBAAoB,GACpB,WAAW,GACX,YAAY,GACZ,iBAAiB,GACjB,OAAO,GACP,gBAAgB,GAChB,cAAc,CACjB,GAAG;IACF,cAAc,EAAE,oBAAoB,CAAC;CACtC,CAAC;AAgBF,qBAAa,iBAAkB,YAAW,eAAe;IAC3C,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,wBAAwB;IAEpD,QAAQ,CAAC,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,YAAY,GAAG,aAAa,CAAC,YAAY,CAAC;IA2FjG,WAAW,CAAC,EAAE,UAAU,EAAE,EAAE,QAAQ;IAIpC,WAAW,CAAC,EAAE,IAAI,EAAE,EAAE,eAAe;IAIrC,OAAO,CAAC,SAAS;CAkClB"}

package/dist/dispatch.js

@@ -0,0 +1,138 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { parseClaudeStreamJson } from "./output-parser.js";
+function extractBashCommand(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const command = input.command;
+    return typeof command === "string" && command.trim() ? command.trim() : undefined;
+}
+function isParallSendCommand(command) {
+    if (!command)
+        return false;
+    const normalized = command.replace(/\s+/g, " ").trim();
+    const invokesParallCli = /(?:^| )(?:parall|npx @parall\/cli(?:@latest)?|pnpm (?:exec|dlx) parall)(?: |$)/.test(normalized);
+    if (!invokesParallCli)
+        return false;
+    return /\b(messages send|dm)\b/.test(normalized);
+}
+export class ClaudeCodeAdapter {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async *dispatch({ bodyForAgent, sessionKey, context }) {
+        const args = this.buildArgs(sessionKey, bodyForAgent);
+        const env = {
+            ...process.env,
+            HOME: this.opts.claudeHome,
+            PRLL_API_URL: context.apiUrl,
+            PRLL_API_KEY: context.apiKey,
+            PRLL_ORG_ID: context.orgId,
+            PRLL_SESSION_ID: context.sessionId ?? "",
+            PRLL_CHAT_ID: context.chatId ?? "",
+            PRLL_TRIGGER_MESSAGE_ID: context.triggerMessageId ?? "",
+            PRLL_NO_REPLY: context.noReply ? "1" : "",
+            PRLL_STEP_ID_FILE: context.stepIdFilePath ?? "",
+        };
+        context.log?.info(`claude-agent[${context.accountId}]: spawn ${this.opts.claudeBin} ${args.slice(0, -1).join(" ")}`);
+        const proc = spawn(this.opts.claudeBin, args, {
+            cwd: this.opts.workspaceDir,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (!proc.stdout || !proc.stderr) {
+            throw new Error("Claude subprocess did not provide stdio pipes");
+        }
+        const stderr = [];
+        proc.stderr.on("data", (chunk) => {
+            stderr.push(chunk.toString());
+        });
+        const exitPromise = new Promise((resolve, reject) => {
+            proc.once("error", reject);
+            proc.once("close", (code, signal) => resolve({ code, signal }));
+        });
+        const groupKey = randomUUID();
+        let sawError = false;
+        let suppressProjectedText = false;
+        let completed = false;
+        try {
+            for await (const event of parseClaudeStreamJson(proc.stdout)) {
+                if (event.type === "session_id") {
+                    this.opts.sessionManager.recordSessionId(sessionKey, event.sessionId);
+                    continue;
+                }
+                if (event.type === "tool_call" && isParallSendCommand(extractBashCommand(event.input))) {
+                    suppressProjectedText = true;
+                }
+                if (event.type === "error") {
+                    sawError = true;
+                    yield event;
+                    continue;
+                }
+                if (event.type === "text") {
+                    const project = suppressProjectedText ? false : event.project;
+                    suppressProjectedText = false;
+                    yield {
+                        ...event,
+                        project,
+                        groupKey,
+                    };
+                    continue;
+                }
+                yield {
+                    ...event,
+                    groupKey,
+                };
+            }
+            completed = true;
+        }
+        finally {
+            if (!completed && proc.exitCode === null && proc.signalCode === null) {
+                proc.kill("SIGTERM");
+            }
+            const { code, signal } = await exitPromise;
+            if ((code ?? 0) !== 0 && !sawError) {
+                const detail = stderr.join("").trim();
+                yield {
+                    type: "error",
+                    message: detail || `Claude exited with code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`,
+                };
+            }
+        }
+    }
+    forkSession({ sessionKey }) {
+        return this.opts.sessionManager.createForkSession(sessionKey);
+    }
+    cleanupFork({ fork }) {
+        this.opts.sessionManager.cleanupFork(fork.sessionKey);
+    }
+    buildArgs(sessionKey, prompt) {
+        const args = [
+            "--print",
+            "--verbose",
+            "--output-format",
+            "stream-json",
+            "--permission-mode",
+            this.opts.permissionMode,
+        ];
+        if (this.opts.model) {
+            args.push("--model", this.opts.model);
+        }
+        if (this.opts.allowedTools.length > 0) {
+            args.push("--allowedTools", this.opts.allowedTools.join(","));
+        }
+        if (this.opts.disallowedTools.length > 0) {
+            args.push("--disallowedTools", this.opts.disallowedTools.join(","));
+        }
+        if (this.opts.appendSystemPrompt) {
+            args.push("--append-system-prompt", this.opts.appendSystemPrompt);
+        }
+        if (this.opts.additionalDirs.length > 0) {
+            args.push("--add-dir", ...this.opts.additionalDirs);
+        }
+        args.push(...this.opts.sessionManager.getResumeArgs(sessionKey));
+        args.push(prompt);
+        return args;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import * as os from "node:os";
+import { ParallAgentGateway } from "@parall/agent-core";
+import { ParallClient, ParallWs } from "@parall/sdk";
+import { buildClaudeRuntimeKey, resolveClaudeAgentConfig, resolveWsUrl, sessionStateFilePathForRuntime, stepIdFilePathForSession, } from "./config.js";
+import { ClaudeCodeAdapter } from "./dispatch.js";
+import { ClaudeSessionManager } from "./session-manager.js";
+import { ensureClaudeWorkspace } from "./workspace.js";
+function createLogger(prefix) {
+    return {
+        info: (msg) => console.log(`[${prefix}] ${msg}`),
+        warn: (msg) => console.warn(`[${prefix}] ${msg}`),
+        error: (msg) => console.error(`[${prefix}] ${msg}`),
+    };
+}
+async function main() {
+    const config = resolveClaudeAgentConfig(process.env);
+    ensureClaudeWorkspace(config.workspaceDir);
+    const log = createLogger("claude-agent");
+    const client = new ParallClient({
+        baseUrl: config.apiUrl,
+        token: config.apiKey,
+        swimlaneName: config.swimlaneName,
+    });
+    const me = await client.getMe();
+    const agentUserId = me.id;
+    const runtimeKey = config.runtimeKey || buildClaudeRuntimeKey(agentUserId);
+    const sessionStateFilePath = sessionStateFilePathForRuntime(config.stateDir, runtimeKey);
+    const sessionManager = new ClaudeSessionManager(runtimeKey, sessionStateFilePath, log);
+    const resolvedWsUrl = resolveWsUrl(config.apiUrl, config.wsUrl, config.swimlaneName);
+    const ws = new ParallWs({
+        getTicket: () => client.getWsTicket(),
+        wsUrl: resolvedWsUrl,
+    });
+    const adapter = new ClaudeCodeAdapter({
+        claudeBin: config.claudeBin,
+        claudeHome: config.claudeHome,
+        workspaceDir: config.workspaceDir,
+        model: config.model,
+        permissionMode: config.permissionMode,
+        allowedTools: config.allowedTools,
+        disallowedTools: config.disallowedTools,
+        additionalDirs: config.additionalDirs,
+        appendSystemPrompt: config.appendSystemPrompt,
+        sessionManager,
+    });
+    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,
+        stepIdFilePathForSession: (sessionKey) => stepIdFilePathForSession(config.stateDir, sessionKey),
+    });
+    const abortController = new AbortController();
+    const abort = () => abortController.abort();
+    process.on("SIGINT", abort);
+    process.on("SIGTERM", abort);
+    try {
+        log.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);
+    }
+}
+main().catch((err) => {
+    console.error(`[claude-agent] fatal: ${String(err)}`);
+    process.exitCode = 1;
+});

package/dist/output-parser.d.ts

@@ -0,0 +1,8 @@
+import type { Readable } from "node:stream";
+import type { RuntimeEvent } from "@parall/agent-core";
+export type ClaudeParsedEvent = RuntimeEvent | {
+    type: "session_id";
+    sessionId: string;
+};
+export declare function parseClaudeStreamJson(readable: Readable): AsyncGenerator<ClaudeParsedEvent>;
+//# sourceMappingURL=output-parser.d.ts.map

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

@@ -0,0 +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,CAAC;AA4E9C,wBAAuB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,GAAG,cAAc,CAAC,iBAAiB,CAAC,CAgHlG"}

package/dist/output-parser.js

@@ -0,0 +1,183 @@
+function asTrimmedString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parseEventTimestampMs(event) {
+    if (!event || typeof event !== "object")
+        return undefined;
+    const timestamp = event.timestamp;
+    if (typeof timestamp !== "string")
+        return undefined;
+    const ms = Date.parse(timestamp);
+    return Number.isFinite(ms) ? ms : undefined;
+}
+function stringifyContent(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => {
+            if (typeof item === "string")
+                return item;
+            if (!item || typeof item !== "object")
+                return "";
+            const text = asTrimmedString(item.text);
+            if (text)
+                return text;
+            const thinking = asTrimmedString(item.thinking);
+            if (thinking)
+                return thinking;
+            return JSON.stringify(item);
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (value && typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return "";
+}
+function normalizeToolResultContent(content, fallback) {
+    const direct = stringifyContent(content).trim();
+    if (direct)
+        return direct;
+    if (fallback && typeof fallback === "object") {
+        const stdout = asTrimmedString(fallback.stdout);
+        const stderr = asTrimmedString(fallback.stderr);
+        if (stdout && stderr)
+            return `${stdout}\n${stderr}`;
+        if (stdout)
+            return stdout;
+        if (stderr)
+            return stderr;
+    }
+    return "";
+}
+async function* readJsonLines(readable) {
+    let buffer = "";
+    readable.setEncoding("utf8");
+    for await (const chunk of readable) {
+        buffer += chunk;
+        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");
+        }
+    }
+    const tail = buffer.trim();
+    if (tail)
+        yield tail;
+}
+export async function* parseClaudeStreamJson(readable) {
+    const toolUses = new Map();
+    for await (const line of readJsonLines(readable)) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        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") {
+            const sessionId = asTrimmedString(eventRecord.session_id);
+            if (sessionId) {
+                yield { type: "session_id", sessionId };
+            }
+            continue;
+        }
+        if (eventRecord.type === "assistant") {
+            if (eventRecord.error)
+                continue;
+            const message = eventRecord.message;
+            const content = message && typeof message === "object"
+                ? message.content
+                : undefined;
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (!block || typeof block !== "object")
+                    continue;
+                const blockRecord = block;
+                switch (blockRecord.type) {
+                    case "thinking": {
+                        const text = asTrimmedString(blockRecord.thinking);
+                        if (text)
+                            yield { type: "thinking", text };
+                        break;
+                    }
+                    case "text": {
+                        const text = asTrimmedString(blockRecord.text);
+                        if (text)
+                            yield { type: "text", text, project: true };
+                        break;
+                    }
+                    case "tool_use": {
+                        const callId = asTrimmedString(blockRecord.id);
+                        const toolName = asTrimmedString(blockRecord.name);
+                        if (!callId || !toolName)
+                            break;
+                        toolUses.set(callId, {
+                            toolName,
+                            startedAtMs: eventTimestampMs,
+                        });
+                        yield {
+                            type: "tool_call",
+                            callId,
+                            toolName,
+                            input: blockRecord.input ?? {},
+                            startedAt: new Date(eventTimestampMs).toISOString(),
+                        };
+                        break;
+                    }
+                }
+            }
+            continue;
+        }
+        if (eventRecord.type === "user") {
+            const message = eventRecord.message;
+            const content = message && typeof message === "object"
+                ? message.content
+                : undefined;
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (!block || typeof block !== "object")
+                    continue;
+                const blockRecord = block;
+                if (blockRecord.type !== "tool_result")
+                    continue;
+                const callId = asTrimmedString(blockRecord.tool_use_id);
+                if (!callId)
+                    continue;
+                const meta = toolUses.get(callId);
+                const output = normalizeToolResultContent(blockRecord.content, eventRecord.tool_use_result);
+                yield {
+                    type: "tool_result",
+                    callId,
+                    toolName: meta?.toolName ?? "unknown",
+                    output,
+                    ...(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" && eventRecord.is_error === true) {
+            const message = asTrimmedString(eventRecord.result)
+                || asTrimmedString(eventRecord.error)
+                || "Claude dispatch failed";
+            yield { type: "error", message };
+        }
+    }
+}

package/dist/session-manager.d.ts

@@ -0,0 +1,20 @@
+import type { ForkSessionHandle } from "@parall/agent-core";
+type ClaudeSessionManagerLogger = {
+    warn(message: string): void;
+};
+export declare class ClaudeSessionManager {
+    private readonly mainSessionKey;
+    private readonly stateFilePath;
+    private readonly logger?;
+    private readonly sessionIds;
+    private readonly pendingForkParents;
+    constructor(mainSessionKey: string, stateFilePath: string, logger?: ClaudeSessionManagerLogger | undefined);
+    getResumeArgs(sessionKey: string): string[];
+    recordSessionId(sessionKey: string, sessionId: string): void;
+    createForkSession(parentSessionKey: string): ForkSessionHandle | null;
+    cleanupFork(sessionKey: string): void;
+    private restore;
+    private persist;
+}
+export {};
+//# sourceMappingURL=session-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAO5D,KAAK,0BAA0B,GAAG;IAChC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,CAAC;AAEF,qBAAa,oBAAoB;IAK7B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAN1B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA6B;IACxD,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAA6B;gBAG7C,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,0BAA0B,YAAA;IAKtD,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;IAK9B,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,OAAO;CAahB"}

package/dist/session-manager.js

@@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomUUID } from "node:crypto";
+export class ClaudeSessionManager {
+    mainSessionKey;
+    stateFilePath;
+    logger;
+    sessionIds = new Map();
+    pendingForkParents = new Map();
+    constructor(mainSessionKey, stateFilePath, logger) {
+        this.mainSessionKey = mainSessionKey;
+        this.stateFilePath = stateFilePath;
+        this.logger = logger;
+        this.restore();
+    }
+    getResumeArgs(sessionKey) {
+        const existing = this.sessionIds.get(sessionKey);
+        if (existing)
+            return ["--resume", existing];
+        const parent = this.pendingForkParents.get(sessionKey);
+        if (parent)
+            return ["--resume", parent, "--fork-session"];
+        return [];
+    }
+    recordSessionId(sessionKey, sessionId) {
+        this.sessionIds.set(sessionKey, sessionId);
+        this.pendingForkParents.delete(sessionKey);
+        if (sessionKey === this.mainSessionKey) {
+            this.persist(sessionId);
+        }
+    }
+    createForkSession(parentSessionKey) {
+        const parentSessionId = this.sessionIds.get(parentSessionKey);
+        if (!parentSessionId)
+            return null;
+        const sessionKey = `claude-fork:${randomUUID()}`;
+        this.pendingForkParents.set(sessionKey, parentSessionId);
+        return {
+            sessionKey,
+            parentSessionId,
+        };
+    }
+    cleanupFork(sessionKey) {
+        this.pendingForkParents.delete(sessionKey);
+        this.sessionIds.delete(sessionKey);
+    }
+    restore() {
+        try {
+            const raw = fs.readFileSync(this.stateFilePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (parsed.runtimeKey === this.mainSessionKey && typeof parsed.sessionId === "string" && parsed.sessionId.trim()) {
+                this.sessionIds.set(this.mainSessionKey, parsed.sessionId.trim());
+            }
+        }
+        catch {
+            // No persisted main session yet.
+        }
+    }
+    persist(sessionId) {
+        try {
+            fs.mkdirSync(path.dirname(this.stateFilePath), { recursive: true });
+            fs.writeFileSync(this.stateFilePath, JSON.stringify({
+                runtimeKey: this.mainSessionKey,
+                sessionId,
+            }, null, 2));
+        }
+        catch (error) {
+            this.logger?.warn(`claude-agent: failed to persist main session state at ${this.stateFilePath}: ${String(error)}`);
+        }
+    }
+}

package/dist/workspace.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureClaudeWorkspace(workspaceDir: string): void;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../src/workspace.ts"],"names":[],"mappings":"AA8BA,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,QAQzD"}