@farazirfan/costar-server-executor 1.7.37 → 1.7.39

package/dist/agent/agent.js

@@ -6,6 +6,7 @@ import { runEmbeddedPiAgent } from "./pi-embedded-runner/run.js";
 import { runWithModelFallback } from "./model-fallback.js";
 import { ensureAgentWorkspace, } from "../workspace/index.js";
 import { compactEmbeddedPiSessionDirect } from "./pi-embedded-runner/compact.js";
+import { SessionManager } from "@mariozechner/pi-coding-agent";
 import path from "node:path";
 import os from "node:os";
 import fs from "node:fs";
@@ -274,6 +275,13 @@ export class Agent {
                     // Run embedded pi agent (core OpenClaw function)
                     // cronDeps is passed through so tools are created inside the runner
                     // with full context (OpenClaw pattern: no pre-built tool arrays)
+                    // subagentDeps provides sessions_spawn + subagents tools to main session
+                    const subagentDeps = {
+                        userId: this.userId,
+                        agent: this,
+                        maxSpawnDepth: 1,
+                        maxChildren: 5,
+                    };
                     return await runEmbeddedPiAgent({
                         sessionId,
                         sessionFile,
@@ -290,6 +298,7 @@ export class Agent {
                         runId: sessionId,
                         skillEntries,
                         cronDeps: this.cronDeps,
+                        subagentDeps,
                         onPartialReply: options.onPartialReply,
                         onToolResult: options.onPartialReply,
                         onToolStart: options.onToolStart,
@@ -564,6 +573,153 @@ export class Agent {
             this._busy = false;
         }
     }
+    // ═══════════════════════════════════════════════════════════════════
+    // SUB-AGENT SESSION SUPPORT
+    // Pattern: OpenClaw's subagent-spawn.ts — runs child worker in isolated
+    // session. Unlike runIsolatedAgentTurn, this does NOT set _busy, uses
+    // unique session per spawn, and strips spawn/cron/message tools.
+    // ═══════════════════════════════════════════════════════════════════
+    /**
+     * Run a sub-agent in an isolated session (fire-and-forget pattern).
+     * Similar to runIsolatedAgentTurn but designed for concurrent spawning:
+     *
+     * Key differences from runIsolatedAgentTurn:
+     * 1. Does NOT set this._busy — multiple sub-agents can run concurrently
+     * 2. Unique session per spawn — no session reuse/freshness logic
+     * 3. No cronDeps — sub-agents can't create cron jobs
+     * 4. No subagentDeps — sub-agents can't spawn (depth limit enforcement)
+     * 5. Passes abortSignal for kill support
+     * 6. deleteAfterRun defaults to true (one-shot tasks)
+     *
+     * Pattern: OpenClaw's spawnSubagentDirect + runCronIsolatedAgentTurn
+     */
+    async runSubagentTurn(prompt, options = {}) {
+        // NOTE: Does NOT set this._busy — sub-agents run concurrently
+        // Unique session per sub-agent (no reuse, no store file)
+        const subagentSessionId = `${this.userId}-subagent-${crypto.randomUUID()}`;
+        const subagentSessionFile = path.join(this.sessionDir, `${subagentSessionId}.json`);
+        const deleteAfterRun = options.deleteAfterRun !== false; // Default: true
+        const timeoutMs = options.timeoutMs ?? 600_000;
+        try {
+            console.log(`\n${"─".repeat(60)}`);
+            console.log(`[AGENT] Starting SUB-AGENT turn`);
+            console.log(`[AGENT] Sub-agent session: ${subagentSessionId}`);
+            console.log(`[AGENT] Sub-agent file: ${subagentSessionFile}`);
+            console.log(`[AGENT] Provider/Model: ${this.getProviderModel()}`);
+            if (options.sessionLabel) {
+                console.log(`[AGENT] Label: ${options.sessionLabel}`);
+            }
+            // Ensure workspace files exist (same as regular turn)
+            if (!this.workspaceSynced) {
+                await this.syncWorkspaceFromStorage();
+            }
+            const [provider, model] = this.parseProviderModel();
+            const skillEntries = this.buildSkillEntries();
+            // Build special system prompt for sub-agent sessions
+            const subagentSystemPrompt = buildIsolatedSessionSystemPrompt({
+                label: options.sessionLabel,
+            });
+            // Run with model fallback using the SUB-AGENT session file
+            const fallbackResult = await runWithModelFallback({
+                cfg: this.config,
+                provider,
+                model,
+                agentDir: process.cwd(),
+                run: async (fallbackProvider, fallbackModel) => {
+                    console.log(`[AGENT] Sub-agent run with ${fallbackProvider}/${fallbackModel}`);
+                    return await runEmbeddedPiAgent({
+                        sessionId: subagentSessionId,
+                        sessionFile: subagentSessionFile,
+                        workspaceDir: this.workspaceDir,
+                        agentDir: process.cwd(),
+                        config: this.config,
+                        prompt,
+                        provider: fallbackProvider,
+                        model: fallbackModel,
+                        thinkLevel: "off",
+                        verboseLevel: "normal",
+                        reasoningLevel: "off",
+                        timeoutMs,
+                        runId: subagentSessionId,
+                        skillEntries,
+                        // NOTE: No cronDeps — sub-agents can't create cron jobs
+                        // NOTE: No subagentDeps — sub-agents can't spawn (tool stripping)
+                        // Lane isolation
+                        lane: "subagent",
+                        // Disable message tool — output goes through announce pipeline
+                        disableMessageTool: true,
+                        // Special system prompt for sub-agent sessions
+                        extraSystemPrompt: subagentSystemPrompt,
+                        // Abort signal for kill support
+                        abortSignal: options.abortSignal,
+                    });
+                },
+            });
+            const result = fallbackResult.result;
+            console.log(`[AGENT] Sub-agent run completed with ${fallbackResult.provider}/${fallbackResult.model}`);
+            console.log(`[AGENT] Duration: ${result.meta.durationMs}ms`);
+            console.log(`[AGENT] Tokens: ${result.meta.agentMeta.usage?.inputTokens}/${result.meta.agentMeta.usage?.outputTokens}`);
+            if (result.didSendViaMessagingTool) {
+                console.log(`[AGENT] Sub-agent sent via messaging tool — will skip announce to avoid duplicate`);
+            }
+            // Extract response text
+            const payloads = result.payloads ?? [];
+            const outputText = pickLastNonEmptyText(payloads) ?? "";
+            return {
+                success: !result.meta.error,
+                response: outputText,
+                outputText,
+                toolCalls: 0,
+                stopReason: result.meta.stopReason,
+                turns: 1,
+                inputTokens: result.meta.agentMeta.usage?.inputTokens ?? 0,
+                outputTokens: result.meta.agentMeta.usage?.outputTokens ?? 0,
+                error: result.meta.error?.message,
+                didSendViaMessagingTool: result.didSendViaMessagingTool ?? false,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[AGENT] Sub-agent turn error:`, message);
+            return {
+                success: false,
+                error: message,
+                turns: 1,
+                didSendViaMessagingTool: false,
+            };
+        }
+        finally {
+            // Session cleanup — default: DELETE (sub-agent sessions are one-shot)
+            if (deleteAfterRun) {
+                try {
+                    if (fs.existsSync(subagentSessionFile)) {
+                        fs.unlinkSync(subagentSessionFile);
+                        console.log(`[AGENT] Cleaned up sub-agent session: ${subagentSessionFile}`);
+                    }
+                }
+                catch (err) {
+                    console.warn(`[AGENT] Failed to clean up sub-agent session:`, err);
+                }
+                // Clean up backup files
+                try {
+                    const dir = path.dirname(subagentSessionFile);
+                    const base = path.basename(subagentSessionFile);
+                    const files = fs.readdirSync(dir);
+                    for (const f of files) {
+                        if (f.startsWith(base) && f.endsWith(".bak")) {
+                            fs.unlinkSync(path.join(dir, f));
+                        }
+                    }
+                }
+                catch {
+                    // best-effort
+                }
+            }
+            else {
+                console.log(`[AGENT] Kept sub-agent session file: ${subagentSessionFile}`);
+            }
+        }
+    }
     /**
      * Inject an isolated run's result into the MAIN session as a compact
      * system message. The main agent sees one summary message and decides
@@ -608,6 +764,456 @@ export class Agent {
         // Execute in the MAIN session — agent sees one compact message
         return await this.executeTurn(triggerMessage, { maxTurns: 25 });
     }
+    // ═══════════════════════════════════════════════════════════════════
+    // CLIENT SESSION API
+    // Shared main session between client (Flutter) and server (TypeScript).
+    // Client reads/writes generic {role, content} messages; server translates
+    // to/from pi-agent JSONL session format. Follows OpenClaw isolated session pattern.
+    // ═══════════════════════════════════════════════════════════════════
+    _clientTurnActive = false;
+    _clientLockTimeout = null;
+    /**
+     * Acquire the main session for a client turn.
+     * Sets _busy = true to prevent server merges (injectIsolatedResult)
+     * while client is running its agent loop.
+     * Auto-expires after 5 min as safety against client crashes.
+     */
+    acquireForClient() {
+        if (this._busy)
+            return false;
+        this._busy = true;
+        this._clientTurnActive = true;
+        // Auto-expire after 5 min (safety: client crash/disconnect)
+        this._clientLockTimeout = setTimeout(() => {
+            if (this._clientTurnActive) {
+                console.warn("[AGENT] Client lock auto-expired after 5 min");
+                this._busy = false;
+                this._clientTurnActive = false;
+            }
+        }, 300_000);
+        console.log("[AGENT] Client acquired main session");
+        return true;
+    }
+    /**
+     * Release the main session after client turn completes.
+     */
+    releaseClient() {
+        this._clientTurnActive = false;
+        this._busy = false;
+        if (this._clientLockTimeout) {
+            clearTimeout(this._clientLockTimeout);
+            this._clientLockTimeout = null;
+        }
+        console.log("[AGENT] Client released main session");
+    }
+    /**
+     * Check if client currently holds the session.
+     */
+    isClientTurnActive() {
+        return this._clientTurnActive;
+    }
+    /**
+     * Read the main session as generic {role, content} messages.
+     * Converts pi-agent JSONL → generic message format.
+     * Server tool calls are summarized as text (client doesn't have server tool schemas).
+     */
+    getSessionMessages(tokenLimit = 15000) {
+        if (!fs.existsSync(this.sessionFile)) {
+            return { messages: [], tokenCount: 0 };
+        }
+        try {
+            // Open session and build context (resolves compaction, tree traversal)
+            const manager = SessionManager.open(this.sessionFile);
+            const context = manager.buildSessionContext();
+            // Convert pi-agent AgentMessages → generic messages
+            const genericMessages = this.convertToGenericMessages(context.messages);
+            // Trim to tokenLimit from the end (keep most recent)
+            const trimmed = this.trimToTokenLimit(genericMessages, tokenLimit);
+            // Estimate total token count
+            const tokenCount = this.estimateMessageTokens(trimmed);
+            return { messages: trimmed, tokenCount };
+        }
+        catch (err) {
+            console.error("[AGENT] Error reading session messages:", err);
+            return { messages: [], tokenCount: 0 };
+        }
+    }
+    /**
+     * Append generic {role, content} messages to the main session as JSONL entries.
+     * Converts generic message format → pi-agent JSONL.
+     * Optionally triggers compaction if session grows too large.
+     */
+    async appendClientMessages(messages) {
+        try {
+            // Open or create session
+            let manager;
+            if (fs.existsSync(this.sessionFile)) {
+                manager = SessionManager.open(this.sessionFile);
+            }
+            else {
+                manager = SessionManager.create(this.workspaceDir, this.sessionDir);
+                // Rename to our expected session file if different
+                const createdFile = manager.getSessionFile() || "";
+                if (createdFile && createdFile !== this.sessionFile) {
+                    // Move it to expected location
+                    fs.renameSync(createdFile, this.sessionFile);
+                    manager = SessionManager.open(this.sessionFile);
+                }
+            }
+            // Convert generic messages → pi-agent messages and append
+            for (const msg of messages) {
+                const piMessage = this.convertFromGenericMessage(msg);
+                if (piMessage) {
+                    manager.appendMessage(piMessage);
+                }
+            }
+            // Check if compaction is needed (estimate tokens)
+            const context = manager.buildSessionContext();
+            let totalTokens = 0;
+            for (const m of context.messages) {
+                totalTokens += this.estimatePiMessageTokens(m);
+            }
+            let compacted = false;
+            // Trigger compaction if over 150k tokens (leave room for response)
+            if (totalTokens > 150_000) {
+                console.log(`[AGENT] Session at ${totalTokens} tokens after client append — triggering compaction`);
+                try {
+                    const result = await this.compactSession();
+                    compacted = result.compacted === true;
+                }
+                catch (err) {
+                    console.error("[AGENT] Post-append compaction failed:", err);
+                }
+            }
+            return { compacted };
+        }
+        catch (err) {
+            console.error("[AGENT] Error appending client messages:", err);
+            return { compacted: false };
+        }
+    }
+    /**
+     * Mid-turn compaction for client overflow recovery.
+     * Takes in-memory generic messages, runs pi-agent compaction,
+     * returns compacted generic messages sized to fit targetContextTokens.
+     * Does NOT write to session file (client is still mid-turn).
+     * Uses server's configured model for summarization (model-agnostic).
+     */
+    async compactClientContext(messages, targetContextTokens) {
+        try {
+            // Convert generic messages → pi-agent messages
+            const piMessages = [];
+            for (const msg of messages) {
+                const piMsg = this.convertFromGenericMessage(msg);
+                if (piMsg)
+                    piMessages.push(piMsg);
+            }
+            // Create a temporary in-memory session with these messages
+            const tempSessionFile = path.join(this.sessionDir, `${this.userId}-compact-temp-${crypto.randomUUID()}.json`);
+            try {
+                // Create temp session and populate it
+                const tempManager = SessionManager.create(this.workspaceDir, this.sessionDir);
+                const tempCreatedFile = tempManager.getSessionFile() || "";
+                // Append all messages to temp session
+                for (const piMsg of piMessages) {
+                    tempManager.appendMessage(piMsg);
+                }
+                // Rename to expected path
+                if (tempCreatedFile && tempCreatedFile !== tempSessionFile) {
+                    fs.renameSync(tempCreatedFile, tempSessionFile);
+                }
+                // Run pi-agent compaction on the temp session
+                const [provider, model] = this.parseProviderModel();
+                const compactParams = {
+                    sessionId: `compact-temp-${Date.now()}`,
+                    sessionFile: tempSessionFile,
+                    workspaceDir: this.workspaceDir,
+                    agentDir: process.cwd(),
+                    config: this.config,
+                    provider,
+                    model,
+                    thinkLevel: "off",
+                    customInstructions: `Summarize preserving all important context. Target: fit within ${targetContextTokens} tokens.`,
+                };
+                await compactEmbeddedPiSessionDirect(compactParams);
+                // Read back the compacted session
+                const compactedManager = SessionManager.open(tempSessionFile);
+                const compactedContext = compactedManager.buildSessionContext();
+                // Convert back to generic messages
+                const compactedMessages = this.convertToGenericMessages(compactedContext.messages);
+                const tokenCount = this.estimateMessageTokens(compactedMessages);
+                return { messages: compactedMessages, tokenCount };
+            }
+            finally {
+                // Cleanup temp file
+                try {
+                    if (fs.existsSync(tempSessionFile))
+                        fs.unlinkSync(tempSessionFile);
+                }
+                catch {
+                    // best-effort cleanup
+                }
+            }
+        }
+        catch (err) {
+            console.error("[AGENT] Client context compaction failed:", err);
+            // Return original messages if compaction fails
+            return { messages, tokenCount: this.estimateMessageTokens(messages) };
+        }
+    }
+    // ── Generic message ↔ Pi-agent message conversion helpers ──
+    /**
+     * Convert pi-agent AgentMessages → generic {role, content} messages.
+     * Server tool calls are summarized as text to avoid exposing
+     * server-only tool schemas to the client.
+     */
+    convertToGenericMessages(piMessages) {
+        const result = [];
+        // Known client tool names — tools that exist on the Flutter client.
+        // Server-only tools (browser, exec, pty, etc.) get summarized as text.
+        // We detect server tools by checking if the message has assistant metadata
+        // from the server's pi-agent runs (provider/model fields).
+        for (let i = 0; i < piMessages.length; i++) {
+            const msg = piMessages[i];
+            if (msg.role === "user") {
+                // User messages pass through directly
+                if (typeof msg.content === "string") {
+                    result.push({ role: "user", content: msg.content });
+                }
+                else if (Array.isArray(msg.content)) {
+                    // Content blocks array
+                    const blocks = msg.content.map((block) => {
+                        if (block.type === "text")
+                            return { type: "text", text: block.text };
+                        if (block.type === "image")
+                            return { type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } };
+                        return block;
+                    });
+                    result.push({ role: "user", content: blocks });
+                }
+            }
+            else if (msg.role === "assistant") {
+                // Assistant messages: convert content blocks
+                if (!Array.isArray(msg.content))
+                    continue;
+                const blocks = [];
+                for (const block of msg.content) {
+                    if (block.type === "text" && block.text) {
+                        blocks.push({ type: "text", text: block.text });
+                    }
+                    else if (block.type === "toolCall") {
+                        blocks.push({
+                            type: "tool_use",
+                            id: block.id,
+                            name: block.name,
+                            input: block.arguments || {},
+                        });
+                    }
+                    else if (block.type === "thinking" && block.thinking) {
+                        // Include thinking blocks for models that support it
+                        blocks.push({ type: "thinking", thinking: block.thinking });
+                    }
+                }
+                if (blocks.length > 0) {
+                    result.push({ role: "assistant", content: blocks });
+                }
+            }
+            else if (msg.role === "toolResult") {
+                // Tool results → Claude API tool_result blocks within user message
+                const textContent = Array.isArray(msg.content)
+                    ? msg.content.map((c) => c.type === "text" ? c.text : "").join("")
+                    : String(msg.content || "");
+                result.push({
+                    role: "user",
+                    content: [
+                        {
+                            type: "tool_result",
+                            tool_use_id: msg.toolCallId,
+                            content: textContent,
+                            is_error: msg.isError || false,
+                        },
+                    ],
+                });
+            }
+            else if (msg.role === "compactionSummary") {
+                // Compaction summaries → user message with context prefix
+                result.push({
+                    role: "user",
+                    content: `[Previous conversation summary]\n${msg.summary}`,
+                });
+            }
+            else if (msg.role === "branchSummary") {
+                // Branch summaries → user message
+                result.push({
+                    role: "user",
+                    content: `[Branch summary]\n${msg.summary}`,
+                });
+            }
+            else if (msg.role === "custom" && msg.display !== false) {
+                // Custom messages that should be displayed
+                const content = typeof msg.content === "string"
+                    ? msg.content
+                    : Array.isArray(msg.content)
+                        ? msg.content.map((c) => c.text || "").join("")
+                        : "";
+                if (content) {
+                    result.push({ role: "user", content });
+                }
+            }
+            // Skip bashExecution and other non-standard roles
+        }
+        return result;
+    }
+    /**
+     * Convert a single generic {role, content} message → pi-agent message format.
+     * Used when appending client turn messages to the session.
+     */
+    convertFromGenericMessage(msg) {
+        const role = msg.role;
+        const content = msg.content;
+        const timestamp = Date.now();
+        if (role === "user") {
+            if (typeof content === "string") {
+                return { role: "user", content, timestamp };
+            }
+            // Check if it's a tool_result array
+            if (Array.isArray(content)) {
+                const firstBlock = content[0];
+                if (firstBlock?.type === "tool_result") {
+                    // This is actually a tool result message
+                    return {
+                        role: "toolResult",
+                        toolCallId: firstBlock.tool_use_id,
+                        toolName: "", // Not available in generic message format
+                        content: [{ type: "text", text: firstBlock.content || "" }],
+                        isError: firstBlock.is_error || false,
+                        timestamp,
+                    };
+                }
+                // Regular user message with content blocks
+                const blocks = content.map((block) => {
+                    if (block.type === "text")
+                        return { type: "text", text: block.text };
+                    if (block.type === "image") {
+                        return {
+                            type: "image",
+                            data: block.source?.data || "",
+                            mimeType: block.source?.media_type || "image/png",
+                        };
+                    }
+                    return block;
+                });
+                return { role: "user", content: blocks, timestamp };
+            }
+            return null;
+        }
+        if (role === "assistant") {
+            if (!Array.isArray(content)) {
+                return { role: "assistant", content: [{ type: "text", text: String(content || "") }], timestamp };
+            }
+            // Convert generic content blocks → pi-agent content blocks
+            const blocks = content.map((block) => {
+                if (block.type === "text")
+                    return { type: "text", text: block.text };
+                if (block.type === "tool_use") {
+                    return {
+                        type: "toolCall",
+                        id: block.id,
+                        name: block.name,
+                        arguments: block.input || {},
+                    };
+                }
+                if (block.type === "thinking")
+                    return { type: "thinking", thinking: block.thinking };
+                return block;
+            });
+            return {
+                role: "assistant",
+                content: blocks,
+                timestamp,
+                // Minimal metadata — server doesn't need full provider info for client turns
+                stopReason: "stop",
+            };
+        }
+        return null;
+    }
+    /**
+     * Trim generic messages to fit within a token limit.
+     * Keeps the most recent messages.
+     */
+    trimToTokenLimit(messages, tokenLimit) {
+        if (messages.length === 0)
+            return messages;
+        // Estimate total tokens
+        const total = this.estimateMessageTokens(messages);
+        if (total <= tokenLimit)
+            return messages;
+        // Work backwards, accumulating tokens
+        const result = [];
+        let accumulated = 0;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const msgTokens = this.estimateMessageTokens([messages[i]]);
+            if (accumulated + msgTokens > tokenLimit && result.length > 0)
+                break;
+            result.unshift(messages[i]);
+            accumulated += msgTokens;
+        }
+        return result;
+    }
+    /**
+     * Estimate token count for generic messages.
+     * Uses chars/4 approximation (same as pi-agent).
+     */
+    estimateMessageTokens(messages) {
+        let totalChars = 0;
+        for (const msg of messages) {
+            const m = msg;
+            const content = m.content;
+            if (typeof content === "string") {
+                totalChars += content.length;
+            }
+            else if (Array.isArray(content)) {
+                for (const block of content) {
+                    const b = block;
+                    if (b.text)
+                        totalChars += String(b.text).length;
+                    if (b.thinking)
+                        totalChars += String(b.thinking).length;
+                    if (b.content)
+                        totalChars += String(b.content).length; // tool_result content
+                    if (b.input)
+                        totalChars += JSON.stringify(b.input).length; // tool_use input
+                    if (b.name)
+                        totalChars += String(b.name).length;
+                }
+            }
+        }
+        return Math.ceil(totalChars / 4);
+    }
+    /**
+     * Estimate token count for a pi-agent message.
+     */
+    estimatePiMessageTokens(msg) {
+        let chars = 0;
+        if (typeof msg.content === "string") {
+            chars = msg.content.length;
+        }
+        else if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.text)
+                    chars += block.text.length;
+                if (block.thinking)
+                    chars += block.thinking.length;
+                if (block.arguments)
+                    chars += JSON.stringify(block.arguments).length;
+                if (block.name)
+                    chars += block.name.length;
+            }
+        }
+        if (msg.summary)
+            chars += msg.summary.length;
+        return Math.ceil(chars / 4);
+    }
     /**
      * Get conversation history
      */