tarsk 0.3.43 → 0.4.4

package/dist/features/chat/chat-stop.route.d.ts

@@ -0,0 +1,21 @@
+/**
+ * POST /api/chat/stop/:threadId
+ * Stop active agent execution for a thread
+ */
+import type { Context } from "hono";
+import type { ProcessingStateManager } from "../../agent/agent.processing-state-manager.js";
+export declare function stopChatGeneration(c: Context, processingStateManager: ProcessingStateManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    message: string;
+}, 200, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, 200, "json">)>;
+//# sourceMappingURL=chat-stop.route.d.ts.map

package/dist/features/chat/chat-stop.route.js

@@ -0,0 +1,22 @@
+/**
+ * POST /api/chat/stop/:threadId
+ * Stop active agent execution for a thread
+ */
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function stopChatGeneration(c, processingStateManager) {
+    const threadId = c.req.param("threadId");
+    if (!threadId) {
+        return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required", 400);
+    }
+    if (!processingStateManager.isProcessing(threadId)) {
+        return c.json({ success: false, message: "Thread is not currently processing" }, 200);
+    }
+    const aborted = processingStateManager.abortThread(threadId);
+    if (aborted) {
+        console.log(`[chat-stop] Successfully aborted thread ${threadId}`);
+        return c.json({ success: true, message: "Generation stopped" }, 200);
+    }
+    return c.json({ success: false, message: "No active execution found for thread" }, 200);
+}
+//# sourceMappingURL=chat-stop.route.js.map

package/dist/features/chat/chat-subscribe.route.d.ts

@@ -0,0 +1,9 @@
+/**
+ * GET /api/chat/subscribe/:threadId
+ * Subscribe to an in-progress thread's streaming events.
+ * Replays buffered events then streams new events as they arrive.
+ */
+import type { Context } from "hono";
+import type { ProcessingStateManager } from "../../agent/agent.processing-state-manager.js";
+export declare function subscribeToChatStream(c: Context, processingStateManager: ProcessingStateManager): Response;
+//# sourceMappingURL=chat-subscribe.route.d.ts.map

package/dist/features/chat/chat-subscribe.route.js

@@ -0,0 +1,71 @@
+/**
+ * GET /api/chat/subscribe/:threadId
+ * Subscribe to an in-progress thread's streaming events.
+ * Replays buffered events then streams new events as they arrive.
+ */
+import { stream } from "hono/streaming";
+export function subscribeToChatStream(c, processingStateManager) {
+    const threadId = c.req.param("threadId");
+    if (!threadId) {
+        return c.json({ error: "threadId is required" }, 400);
+    }
+    if (!processingStateManager.isProcessing(threadId)) {
+        return c.json({ error: "Thread is not currently processing" }, 404);
+    }
+    return stream(c, async (writer) => {
+        // Replay buffered events
+        const buffered = processingStateManager.getBufferedEvents(threadId);
+        for (const event of buffered) {
+            await writer.write(JSON.stringify(event) + "\n");
+        }
+        // Subscribe to new events
+        let resolve = null;
+        const queue = [];
+        let done = false;
+        const unsubscribe = processingStateManager.subscribe(threadId, (event) => {
+            if (event.type === "complete") {
+                done = true;
+                queue.push(event);
+            }
+            else {
+                queue.push(event);
+            }
+            // Wake up the writer loop
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        });
+        writer.onAbort(() => {
+            done = true;
+            unsubscribe();
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        });
+        try {
+            while (!done) {
+                // Drain all queued events
+                while (queue.length > 0) {
+                    const event = queue.shift();
+                    await writer.write(JSON.stringify(event) + "\n");
+                    if (event.type === "complete") {
+                        done = true;
+                        break;
+                    }
+                }
+                if (!done) {
+                    // Wait for next event
+                    await new Promise((r) => {
+                        resolve = r;
+                    });
+                }
+            }
+        }
+        finally {
+            unsubscribe();
+        }
+    });
+}
+//# sourceMappingURL=chat-subscribe.route.js.map

package/dist/features/chat/chat.routes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Chat routes for the REST API
+ *
+ * Handles chat message processing:
+ * - POST /api/chat - Send a message to the agent
+ * - DELETE /api/chat/:threadId - Start a new conversation
+ */
+import { Hono } from "hono";
+import type { ThreadManager } from "../threads/threads.manager.js";
+import type { AgentExecutor } from "../../agent/agent.executor.js";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ProcessingStateManager } from "../../agent/agent.processing-state-manager.js";
+/**
+ * Creates chat routes
+ * @param threadManager - The ThreadManager instance
+ * @param agentExecutor - The AgentExecutor instance
+ * @param conversationManager - The ConversationManager instance
+ * @param processingStateManager - The ProcessingStateManager instance
+ * @returns Hono router with chat routes
+ */
+export declare function createChatRoutes(threadManager: ThreadManager, agentExecutor: AgentExecutor, conversationManager: ConversationManager, processingStateManager: ProcessingStateManager): Hono;
+//# sourceMappingURL=chat.routes.d.ts.map

package/dist/features/chat/chat.routes.js

@@ -0,0 +1,29 @@
+/**
+ * Chat routes for the REST API
+ *
+ * Handles chat message processing:
+ * - POST /api/chat - Send a message to the agent
+ * - DELETE /api/chat/:threadId - Start a new conversation
+ */
+import { Hono } from "hono";
+import { postChatMessage } from "./chat-post.route.js";
+import { deleteChat } from "./chat-delete.route.js";
+import { subscribeToChatStream } from "./chat-subscribe.route.js";
+import { stopChatGeneration } from "./chat-stop.route.js";
+/**
+ * Creates chat routes
+ * @param threadManager - The ThreadManager instance
+ * @param agentExecutor - The AgentExecutor instance
+ * @param conversationManager - The ConversationManager instance
+ * @param processingStateManager - The ProcessingStateManager instance
+ * @returns Hono router with chat routes
+ */
+export function createChatRoutes(threadManager, agentExecutor, conversationManager, processingStateManager) {
+    const router = new Hono();
+    router.post("/", (c) => postChatMessage(c, threadManager, agentExecutor, conversationManager, processingStateManager));
+    router.post("/stop/:threadId", (c) => stopChatGeneration(c, processingStateManager));
+    router.get("/subscribe/:threadId", (c) => subscribeToChatStream(c, processingStateManager));
+    router.delete("/:threadId", (c) => deleteChat(c, threadManager));
+    return router;
+}
+//# sourceMappingURL=chat.routes.js.map

package/dist/features/conversations/conversations-delete.route.d.ts

@@ -0,0 +1,16 @@
+/**
+ * DELETE /api/conversations/:threadId/:conversationId
+ * Clear conversation history for a specific conversation (not all conversations)
+ */
+import type { Context } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ThreadManager } from "../threads/threads.manager.js";
+export declare function deleteConversation(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=conversations-delete.route.d.ts.map

package/dist/features/conversations/conversations-delete.route.js

@@ -0,0 +1,34 @@
+/**
+ * DELETE /api/conversations/:threadId/:conversationId
+ * Clear conversation history for a specific conversation (not all conversations)
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function deleteConversation(c, conversationManager, threadManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        const conversationId = c.req.param("conversationId");
+        if (!threadId || typeof threadId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
+        }
+        if (!conversationId || typeof conversationId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "conversationId is required and must be a string", 400);
+        }
+        // Verify thread exists
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        // Clear conversation history
+        await conversationManager.clearChatHistory(thread.path, conversationId);
+        return successResponse(c, {
+            message: "Conversation history cleared successfully",
+            threadId,
+            conversationId,
+        }, 200);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.HISTORY_CLEAR_ERROR, "Failed to clear conversation history", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=conversations-delete.route.js.map

package/dist/features/conversations/conversations-get-all.route.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /api/conversations/:threadId
+ * Get all conversation history for a thread (all conversations)
+ */
+import type { Context } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ThreadManager } from "../threads/threads.manager.js";
+export declare function getAllConversations(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=conversations-get-all.route.d.ts.map

package/dist/features/conversations/conversations-get-all.route.js

@@ -0,0 +1,39 @@
+/**
+ * GET /api/conversations/:threadId
+ * Get all conversation history for a thread (all conversations)
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function getAllConversations(c, conversationManager, threadManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        if (!threadId || typeof threadId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
+        }
+        // Verify thread exists
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        // Get conversation history
+        const history = await conversationManager.getConversationHistory(thread.path);
+        if (!history) {
+            return successResponse(c, {
+                threadId,
+                messages: [],
+                lastUpdated: new Date().toISOString(),
+                conversationIds: [],
+            }, 200);
+        }
+        // Get all conversation IDs for this thread
+        const conversationIds = await conversationManager.getConversationIds(thread.path);
+        return successResponse(c, {
+            ...history,
+            conversationIds,
+        }, 200);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.HISTORY_FETCH_ERROR, "Failed to fetch conversation history", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=conversations-get-all.route.js.map

package/dist/features/conversations/conversations-get-by-id.route.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /api/conversations/:threadId/:conversationId
+ * Get conversation history for a specific conversation within a thread
+ */
+import type { Context } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ThreadManager } from "../threads/threads.manager.js";
+export declare function getConversationById(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=conversations-get-by-id.route.d.ts.map

package/dist/features/conversations/conversations-get-by-id.route.js

@@ -0,0 +1,38 @@
+/**
+ * GET /api/conversations/:threadId/:conversationId
+ * Get conversation history for a specific conversation within a thread
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function getConversationById(c, conversationManager, threadManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        const conversationId = c.req.param("conversationId");
+        if (!threadId || typeof threadId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
+        }
+        if (!conversationId || typeof conversationId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "conversationId is required and must be a string", 400);
+        }
+        // Verify thread exists
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        // Get conversation history for specific conversation
+        const history = await conversationManager.getConversationHistoryByConversationId(thread.path, conversationId);
+        if (!history) {
+            return successResponse(c, {
+                threadId,
+                conversationId,
+                messages: [],
+                lastUpdated: new Date().toISOString(),
+            }, 200);
+        }
+        return successResponse(c, history, 200);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.HISTORY_FETCH_ERROR, "Failed to fetch conversation history", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=conversations-get-by-id.route.js.map

package/dist/features/conversations/conversations-get-deleted.route.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GET /api/conversations/:threadId/deleted
+ * Get deleted conversation history for a thread
+ */
+import type { Context } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+export declare function getDeletedConversations(c: Context, conversationManager: ConversationManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=conversations-get-deleted.route.d.ts.map

package/dist/features/conversations/conversations-get-deleted.route.js

@@ -0,0 +1,34 @@
+/**
+ * GET /api/conversations/:threadId/deleted
+ * Get deleted conversation history for a thread
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function getDeletedConversations(c, conversationManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        if (!threadId || typeof threadId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
+        }
+        // Get deleted conversation history (even if thread doesn't exist anymore)
+        const deletedHistory = await conversationManager.getDeletedConversationHistory(`/data/${threadId}`);
+        if (!deletedHistory) {
+            return successResponse(c, {
+                threadId,
+                messages: [],
+                lastUpdated: new Date().toISOString(),
+                conversationIds: [],
+            }, 200);
+        }
+        // Get deleted conversation IDs for this thread
+        const deletedConversationIds = await conversationManager.getDeletedConversationIds(`/data/${threadId}`);
+        return successResponse(c, {
+            ...deletedHistory,
+            conversationIds: deletedConversationIds,
+        }, 200);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.DELETED_HISTORY_FETCH_ERROR, "Failed to fetch deleted conversation history", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=conversations-get-deleted.route.js.map

package/dist/features/conversations/conversations-get-messages.route.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /api/conversations/:threadId/:conversationId/messages/:count
+ * Get the last N messages from a specific conversation
+ */
+import type { Context } from "hono";
+import type { ConversationManager } from "../conversations/conversations.manager.js";
+import type { ThreadManager } from "../threads/threads.manager.js";
+export declare function getConversationMessages(c: Context, conversationManager: ConversationManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=conversations-get-messages.route.d.ts.map

package/dist/features/conversations/conversations-get-messages.route.js

@@ -0,0 +1,49 @@
+/**
+ * GET /api/conversations/:threadId/:conversationId/messages/:count
+ * Get the last N messages from a specific conversation
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function getConversationMessages(c, conversationManager, threadManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        const conversationId = c.req.param("conversationId");
+        const countParam = c.req.param("count");
+        if (!threadId || typeof threadId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
+        }
+        if (!conversationId || typeof conversationId !== "string") {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "conversationId is required and must be a string", 400);
+        }
+        // Parse and validate count parameter
+        let count = 10; // default
+        if (countParam) {
+            const parsedCount = parseInt(countParam, 10);
+            if (isNaN(parsedCount) || parsedCount < 1) {
+                return errorResponse(c, ErrorCodes.INVALID_REQUEST, "count must be a positive integer", 400);
+            }
+            if (parsedCount > 100) {
+                return errorResponse(c, ErrorCodes.INVALID_REQUEST, "count cannot exceed 100", 400);
+            }
+            count = parsedCount;
+        }
+        // Verify thread exists
+        const thread = await threadManager.getThread(threadId);
+        if (!thread) {
+            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
+        }
+        // Get last N messages
+        const messages = await conversationManager.getLastMessages(thread.path, conversationId, count);
+        return successResponse(c, {
+            threadId,
+            conversationId,
+            count,
+            messages,
+            totalMessages: messages.length,
+        }, 200);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.HISTORY_FETCH_ERROR, "Failed to fetch conversation messages", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=conversations-get-messages.route.js.map

package/dist/features/conversations/conversations.content.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Helpers for extracting and normalizing conversation content from agent events.
+ * Used when saving completed messages (store only final answer) and when
+ * mapping stream events to thinking vs content for the UI.
+ */
+import type { AgentEvent, ConversationMessage } from "@tarsk/shared";
+/**
+ * Formats completed conversation messages into a single context string to prepend
+ * to the next user prompt so the model retains conversation history.
+ */
+export declare function formatConversationContext(messages: ConversationMessage[], maxMessages?: number): string;
+/**
+ * Parses assistant message content into content blocks when it is a JSON array
+ * (e.g. [{ type: 'reasoning', text: '...' }, { type: 'text', text: '...' }, { type: 'tool_use', ... }]).
+ * Returns null if content is not a structured array.
+ */
+export declare function parseAssistantContentBlocks(content: string): Array<{
+    type: string;
+    [key: string]: unknown;
+}> | null;
+/** Returns true if content looks like tool result/use JSON */
+export declare function isToolLikeContent(content: string): boolean;
+/**
+ * Returns only the final assistant answer text from events (no user message, no tool JSON).
+ * Use this when persisting response content so the stored file stays clean.
+ */
+export declare function extractAssistantContent(events: AgentEvent[] | undefined, fallback: string): string;
+//# sourceMappingURL=conversations.content.d.ts.map

package/dist/features/conversations/conversations.content.js

@@ -0,0 +1,142 @@
+/**
+ * Helpers for extracting and normalizing conversation content from agent events.
+ * Used when saving completed messages (store only final answer) and when
+ * mapping stream events to thinking vs content for the UI.
+ */
+/** Max number of prior exchanges to include in context (user + assistant pairs) */
+const DEFAULT_MAX_CONTEXT_MESSAGES = 10;
+/**
+ * Formats completed conversation messages into a single context string to prepend
+ * to the next user prompt so the model retains conversation history.
+ */
+export function formatConversationContext(messages, maxMessages = DEFAULT_MAX_CONTEXT_MESSAGES) {
+    const completed = messages.filter((m) => m.response != null);
+    const recent = completed.slice(-maxMessages);
+    if (recent.length === 0)
+        return "";
+    const lines = ["Previous conversation:"];
+    for (const m of recent) {
+        lines.push(`User: ${m.request.message}`);
+        lines.push(`Assistant: ${m.response.content}`);
+    }
+    return lines.join("\n");
+}
+const extractTextBlocksFromContent = (content) => {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .filter((block) => block && typeof block === "object" && block.type === "text")
+                .map((block) => (typeof block.text === "string" ? block.text : ""))
+                .filter((text) => text.length > 0);
+        }
+        if (parsed &&
+            typeof parsed === "object" &&
+            "text" in parsed &&
+            typeof parsed.text === "string") {
+            return [parsed.text];
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [];
+};
+/**
+ * Parses assistant message content into content blocks when it is a JSON array
+ * (e.g. [{ type: 'reasoning', text: '...' }, { type: 'text', text: '...' }, { type: 'tool_use', ... }]).
+ * Returns null if content is not a structured array.
+ */
+export function parseAssistantContentBlocks(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith("["))
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return null;
+        const blocks = [];
+        for (const item of parsed) {
+            if (item && typeof item === "object" && "type" in item) {
+                blocks.push(item);
+            }
+        }
+        return blocks.length > 0 ? blocks : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Returns true if content looks like tool result/use JSON */
+export function isToolLikeContent(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith("[") && !trimmed.startsWith("{"))
+        return false;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed.some((item) => item &&
+                typeof item === "object" &&
+                "type" in item &&
+                (item.type === "tool-result" ||
+                    item.type === "tool_use"));
+        }
+        return (typeof parsed === "object" &&
+            parsed !== null &&
+            "type" in parsed &&
+            (parsed.type === "tool-result" ||
+                parsed.type === "tool_use"));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns only the final assistant answer text from events (no user message, no tool JSON).
+ * Use this when persisting response content so the stored file stays clean.
+ */
+export function extractAssistantContent(events, fallback) {
+    if (!events || events.length === 0) {
+        return fallback;
+    }
+    const resultEvent = [...events].reverse().find((event) => event.type === "result");
+    if (resultEvent &&
+        typeof resultEvent.content === "string" &&
+        resultEvent.content.trim().length > 0) {
+        return resultEvent.content;
+    }
+    const assistantMessages = events.filter((event) => event.type === "message" && event.role === "assistant");
+    let lastTextBlock = null;
+    const assistantChunks = [];
+    for (const event of assistantMessages) {
+        if (typeof event.content !== "string") {
+            continue;
+        }
+        if (isToolLikeContent(event.content)) {
+            continue;
+        }
+        assistantChunks.push(event.content);
+        const textBlocks = extractTextBlocksFromContent(event.content);
+        if (textBlocks.length > 0) {
+            lastTextBlock = textBlocks[textBlocks.length - 1];
+        }
+    }
+    if (lastTextBlock) {
+        return lastTextBlock;
+    }
+    if (assistantChunks.length === 0) {
+        // Fall back to the last error event content so the message is saved to history
+        const lastError = [...events].reverse().find((e) => e.type === "error");
+        if (lastError && typeof lastError.content === "string" && lastError.content.trim().length > 0) {
+            return lastError.content;
+        }
+        return fallback;
+    }
+    const combined = assistantChunks.join("");
+    return combined.trim().length > 0 ? combined : fallback;
+}
+//# sourceMappingURL=conversations.content.js.map