tarsk 0.4.4 → 0.4.6

package/dist/database/database.test-utils.js

@@ -1,39 +0,0 @@
-/**
- * Test Database Utilities
- *
- * Provides in-memory SQLite database for testing using libsql-js
- * for compatibility with Node test environment.
- */
-import { createClient } from "@libsql/client";
-import { initializeSchema } from './database.js';
-/**
- * Initialize database schema with all required tables for testing
- * @param db libsql-js database instance
- */
-async function initializeTestSchema(db) {
-    await initializeSchema(db);
-}
-/**
- * Create an in-memory database for testing
- * @returns SQLite database instance compatible with libsql-js API
- */
-export async function createTestDatabase() {
-    const db = createClient({
-        url: ":memory:",
-    });
-    await initializeTestSchema(db);
-    return db;
-}
-/**
- * Mock the database module for testing
- * @returns Mock database functions
- */
-export async function createMockDatabase() {
-    const db = await createTestDatabase();
-    return {
-        initializeDatabase: () => db,
-        getDatabase: () => db,
-        getDatabasePath: () => ":memory:",
-    };
-}
-//# sourceMappingURL=database.test-utils.js.map

package/dist/database/database.types.d.ts

@@ -1,3 +0,0 @@
-import { Client } from "@libsql/client";
-export type Database = Client;
-//# sourceMappingURL=database.types.d.ts.map

package/dist/database/database.types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=database.types.js.map

package/dist/features/agents/agents.manager.d.ts

@@ -1,24 +0,0 @@
-/**
- * Agent Manager
- *
- * Loads and manages agent definitions from AGENT.md files with frontmatter.
- * Agents can be stored in:
- * - Project-specific: ./.agents/agents/ (relative to thread path)
- * - Global: ~/.agents/agents/
- *
- * Project agents override global ones with the same name.
- */
-import type { AgentDefinition } from "@tarsk/shared";
-/**
- * AgentsManager handles loading and validating agent definitions
- */
-export declare class AgentsManager {
-    /**
-     * Load all available agent definitions for a given thread.
-     * Project agents override global ones with the same name.
-     */
-    loadAgents(threadPath: string): Promise<AgentDefinition[]>;
-    private loadAgentsFromDir;
-    getAgent(name: string, threadPath: string): Promise<AgentDefinition | null>;
-}
-//# sourceMappingURL=agents.manager.d.ts.map

package/dist/features/agents/agents.manager.js

@@ -1,200 +0,0 @@
-/**
- * Agent Manager
- *
- * Loads and manages agent definitions from AGENT.md files with frontmatter.
- * Agents can be stored in:
- * - Project-specific: ./.agents/agents/ (relative to thread path)
- * - Global: ~/.agents/agents/
- *
- * Project agents override global ones with the same name.
- */
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
-import { existsSync } from "fs";
-import { homedir } from "os";
-/**
- * Parse frontmatter from AGENT.md content.
- * Returns { metadata, content } where content is the body after frontmatter.
- */
-function parseFrontmatter(markdown) {
-    const lines = markdown.split("\n");
-    if (lines[0]?.trim() !== "---") {
-        return { metadata: {}, content: markdown.trim() };
-    }
-    let endIndex = -1;
-    for (let i = 1; i < lines.length; i++) {
-        if (lines[i]?.trim() === "---") {
-            endIndex = i;
-            break;
-        }
-    }
-    if (endIndex === -1) {
-        return { metadata: {}, content: markdown.trim() };
-    }
-    const frontmatterLines = lines.slice(1, endIndex);
-    const metadata = {};
-    for (const line of frontmatterLines) {
-        const colonIndex = line.indexOf(":");
-        if (colonIndex === -1)
-            continue;
-        const key = line.slice(0, colonIndex).trim();
-        const value = line.slice(colonIndex + 1).trim();
-        if (key === "name") {
-            metadata.name = value;
-        }
-        else if (key === "description") {
-            metadata.description = value;
-        }
-        else if (key === "tools") {
-            metadata.tools = value;
-        }
-        else if (key === "agents") {
-            // Parse comma or space separated list, strip brackets if present
-            const cleaned = value.replace(/[[\]]/g, "");
-            metadata.agents = cleaned
-                .split(/[,\s]+/)
-                .map((s) => s.trim())
-                .filter(Boolean);
-        }
-        else if (key === "user-invocable") {
-            metadata.userInvocable = value.toLowerCase() !== "false";
-        }
-        else if (key === "disable-model-invocation") {
-            metadata.disableModelInvocation = value.toLowerCase() === "true";
-        }
-        else if (key === "model") {
-            metadata.model = value;
-        }
-        else if (key === "provider") {
-            metadata.provider = value;
-        }
-    }
-    const content = lines
-        .slice(endIndex + 1)
-        .join("\n")
-        .trim();
-    return { metadata, content };
-}
-/**
- * Validate agent name format — same rules as skill names.
- * 1-64 chars, lowercase alphanumeric + hyphens, no leading/trailing/consecutive hyphens.
- */
-function validateAgentName(name) {
-    if (!name || name.length === 0 || name.length > 64)
-        return false;
-    if (!/^[a-z0-9-]+$/.test(name))
-        return false;
-    if (name.startsWith("-") || name.endsWith("-"))
-        return false;
-    if (name.includes("--"))
-        return false;
-    return true;
-}
-function validateDescription(description) {
-    return !!description && description.length > 0 && description.length <= 1024;
-}
-function getGlobalAgentsDir() {
-    return join(homedir(), ".agents", "agents");
-}
-function getProjectAgentsDir(threadPath) {
-    return join(threadPath, ".agents", "agents");
-}
-/**
- * AgentsManager handles loading and validating agent definitions
- */
-export class AgentsManager {
-    /**
-     * Load all available agent definitions for a given thread.
-     * Project agents override global ones with the same name.
-     */
-    async loadAgents(threadPath) {
-        const agents = new Map();
-        const globalDir = getGlobalAgentsDir();
-        if (existsSync(globalDir)) {
-            const globalAgents = await this.loadAgentsFromDir(globalDir, "global");
-            for (const agent of globalAgents) {
-                agents.set(agent.name, agent);
-            }
-        }
-        const projectDir = getProjectAgentsDir(threadPath);
-        if (existsSync(projectDir)) {
-            const projectAgents = await this.loadAgentsFromDir(projectDir, "project");
-            for (const agent of projectAgents) {
-                agents.set(agent.name, agent);
-            }
-        }
-        return Array.from(agents.values());
-    }
-    async loadAgentsFromDir(dir, scope) {
-        const agents = [];
-        try {
-            const entries = await readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (!entry.isDirectory())
-                    continue;
-                const agentDirName = entry.name;
-                const agentPath = join(dir, agentDirName);
-                const agentFilePath = join(agentPath, "AGENT.md");
-                if (!existsSync(agentFilePath)) {
-                    console.warn(`[agents] Skipping agent directory ${agentDirName}: AGENT.md not found`);
-                    continue;
-                }
-                try {
-                    const fileContent = await readFile(agentFilePath, "utf-8");
-                    const { metadata, content } = parseFrontmatter(fileContent);
-                    if (!metadata.name) {
-                        console.warn(`[agents] Skipping agent in ${agentDirName}: missing 'name' in frontmatter`);
-                        continue;
-                    }
-                    if (!metadata.description) {
-                        console.warn(`[agents] Skipping agent in ${agentDirName}: missing 'description' in frontmatter`);
-                        continue;
-                    }
-                    if (!validateAgentName(metadata.name)) {
-                        console.warn(`[agents] Skipping agent in ${agentDirName}: invalid name '${metadata.name}'. ` +
-                            `Must be 1-64 chars, lowercase alphanumeric + hyphens.`);
-                        continue;
-                    }
-                    if (!validateDescription(metadata.description)) {
-                        console.warn(`[agents] Skipping agent in ${agentDirName}: description must be 1-1024 characters`);
-                        continue;
-                    }
-                    if (metadata.name !== agentDirName) {
-                        console.warn(`[agents] Skipping agent in ${agentDirName}: directory name must match frontmatter name '${metadata.name}'`);
-                        continue;
-                    }
-                    const agent = {
-                        name: metadata.name,
-                        description: metadata.description,
-                        scope,
-                        agentPath,
-                        userInvocable: metadata.userInvocable ?? true,
-                        disableModelInvocation: metadata.disableModelInvocation ?? false,
-                        systemPrompt: content,
-                    };
-                    if (metadata.tools)
-                        agent.tools = metadata.tools;
-                    if (metadata.agents)
-                        agent.agents = metadata.agents;
-                    if (metadata.model)
-                        agent.model = metadata.model;
-                    if (metadata.provider)
-                        agent.provider = metadata.provider;
-                    agents.push(agent);
-                }
-                catch (error) {
-                    console.error(`[agents] Failed to load agent from ${agentDirName}:`, error);
-                }
-            }
-        }
-        catch (error) {
-            console.error(`[agents] Failed to load agents from ${dir}:`, error);
-        }
-        return agents;
-    }
-    async getAgent(name, threadPath) {
-        const agents = await this.loadAgents(threadPath);
-        return agents.find((a) => a.name === name) ?? null;
-    }
-}
-//# sourceMappingURL=agents.manager.js.map

package/dist/features/ask-user/ask-user.routes.d.ts

@@ -1,9 +0,0 @@
-/**
- * Ask-user routes for the REST API
- *
- * Handles user responses to agent questions:
- * - POST /api/ask-user/respond - Submit an answer to a pending question
- */
-import { Hono } from "hono";
-export declare function createAskUserRoutes(): Hono;
-//# sourceMappingURL=ask-user.routes.d.ts.map

package/dist/features/ask-user/ask-user.routes.js

@@ -1,35 +0,0 @@
-/**
- * Ask-user routes for the REST API
- *
- * Handles user responses to agent questions:
- * - POST /api/ask-user/respond - Submit an answer to a pending question
- */
-import { Hono } from "hono";
-import { submitAnswer } from "../../tools/ask-user.js";
-import { errorResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-export function createAskUserRoutes() {
-    const router = new Hono();
-    router.post("/respond", async (c) => {
-        try {
-            const body = await c.req.json();
-            const { toolCallId, answer } = body;
-            if (!toolCallId || typeof toolCallId !== "string") {
-                return errorResponse(c, ErrorCodes.INVALID_REQUEST, "toolCallId is required and must be a string", 400);
-            }
-            if (answer === undefined || answer === null || typeof answer !== "string") {
-                return errorResponse(c, ErrorCodes.INVALID_REQUEST, "answer is required and must be a string", 400);
-            }
-            const resolved = submitAnswer(toolCallId, answer);
-            if (!resolved) {
-                return errorResponse(c, ErrorCodes.INVALID_REQUEST, "No pending question found for this toolCallId", 404);
-            }
-            return c.json({ success: true });
-        }
-        catch (error) {
-            return errorResponse(c, ErrorCodes.REQUEST_PARSE_ERROR, "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
-        }
-    });
-    return router;
-}
-//# sourceMappingURL=ask-user.routes.js.map

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

@@ -1,15 +0,0 @@
-/**
- * DELETE /api/chat/:threadId
- * Start a new conversation (generates new conversation ID) and deletes all todos for the thread
- */
-import type { Context } from "hono";
-import type { ThreadManager } from "../threads/threads.manager.js";
-export declare function deleteChat(c: Context, 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=chat-delete.route.d.ts.map

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

@@ -1,36 +0,0 @@
-/**
- * DELETE /api/chat/:threadId
- * Start a new conversation (generates new conversation ID) and deletes all todos for the thread
- */
-import { randomUUID } from "crypto";
-import { errorResponse, successResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-import { getDatabase } from "../../database/database.js";
-export async function deleteChat(c, 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);
-        }
-        // Get thread metadata
-        const thread = await threadManager.getThread(threadId);
-        if (!thread) {
-            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-        }
-        // Delete all todos for this thread
-        const db = await getDatabase();
-        await db.execute({
-            sql: "DELETE FROM todos WHERE threadId = ?",
-            args: [threadId],
-        });
-        // Generate a new conversation ID
-        const newConversationId = randomUUID();
-        // Update thread with new conversation ID
-        await threadManager.updateThread(threadId, { currentConversationId: newConversationId });
-        return successResponse(c, { message: "New conversation started", conversationId: newConversationId }, 200);
-    }
-    catch (error) {
-        return errorResponse(c, ErrorCodes.NEW_CONVERSATION_ERROR, "Failed to start new conversation", 500, error instanceof Error ? error.message : String(error));
-    }
-}
-//# sourceMappingURL=chat-delete.route.js.map

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

@@ -1,11 +0,0 @@
-/**
- * POST /api/chat
- * Send a message to the agent
- */
-import type { Context } 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";
-export declare function postChatMessage(c: Context, threadManager: ThreadManager, agentExecutor: AgentExecutor, conversationManager: ConversationManager, processingStateManager: ProcessingStateManager): Promise<Response>;
-//# sourceMappingURL=chat-post.route.d.ts.map

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

@@ -1,270 +0,0 @@
-/**
- * POST /api/chat
- * Send a message to the agent
- */
-import { randomUUID } from "crypto";
-import { SkillManager } from "../skills/skills.manager.js";
-import { activateSkills } from "../skills/skills.activation.js";
-import { AgentsManager } from "../agents/agents.manager.js";
-import { delay } from "../../core/utils.js";
-import { streamAsyncGenerator } from "../../core/stream-helper.js";
-import { extractAssistantContent, formatConversationContext, isToolLikeContent, } from "../conversations/conversations.content.js";
-import { errorResponse } from "../../core/route-helpers.js";
-import { ErrorCodes } from "../../core/error-responses.js";
-import { readFile, unlink } from "fs/promises";
-import { join } from "path";
-import { getDatabase } from "../../database/database.js";
-import { clearWorkingByThreadId, getTodoByThreadId, updateTodo, } from "../project-todos/project-todos.database.js";
-import { invalidateGitStatusCache } from "../git/git-status-cache.database.js";
-export async function postChatMessage(c, threadManager, agentExecutor, conversationManager, processingStateManager) {
-    try {
-        const body = await c.req.json();
-        const { threadId, content, model: baseModel, provider, attachments, planMode } = body;
-        // Prepend provider name (lowercased) to the model if provider is provided
-        let model = baseModel;
-        if (provider && typeof provider === "string") {
-            const providerPrefix = provider.toLowerCase();
-            // Only prepend if the model doesn't already start with this provider prefix
-            if (!model.startsWith(providerPrefix + "/")) {
-                model = `${providerPrefix}/${model}`;
-            }
-        }
-        // Validate required fields
-        if (!threadId || typeof threadId !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "threadId is required and must be a string", 400);
-        }
-        if (!content || typeof content !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "content is required and must be a string", 400);
-        }
-        if (!model || typeof model !== "string") {
-            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "model is required and must be a string", 400);
-        }
-        console.log(`[chat] User message (thread: ${threadId}): ${content}`);
-        // Get thread metadata to build execution context
-        const thread = await threadManager.getThread(threadId);
-        if (!thread) {
-            return errorResponse(c, ErrorCodes.THREAD_NOT_FOUND, `Thread not found: ${threadId}`, 404);
-        }
-        // Capture thread path for use in generators
-        const threadPath = thread.path;
-        // Check if this is a replay request
-        if (content.trim().toLowerCase() === "replay") {
-            console.log("[ChatRoute] Replay request detected");
-            // Get conversation ID for replay
-            const conversationId = thread.currentConversationId;
-            if (!conversationId) {
-                return errorResponse(c, ErrorCodes.NO_CONVERSATION, "No active conversation found to replay", 404);
-            }
-            // Get the last message from conversation history
-            const lastMessages = await conversationManager.getLastMessages(threadPath, conversationId, 1);
-            if (lastMessages.length === 0) {
-                return errorResponse(c, ErrorCodes.NO_HISTORY, "No previous conversation found to replay", 404);
-            }
-            const lastMessage = lastMessages[0];
-            // Check if message has a completed response
-            if (!lastMessage.response) {
-                return errorResponse(c, ErrorCodes.NO_RESPONSE, "Previous message has no completed response to replay", 404);
-            }
-            console.log("[ChatRoute] Replaying message:", {
-                messageId: lastMessage.id,
-                timestamp: lastMessage.timestamp,
-                eventCount: lastMessage.response.events.length,
-            });
-            // Extract response to ensure TypeScript narrowing
-            const response = lastMessage.response;
-            // Create a generator for replay events
-            async function* replayGenerator() {
-                // First, send a replay indicator event
-                const replayEvent = {
-                    type: "message",
-                    role: "system",
-                    content: `🔄 Replaying previous conversation from ${lastMessage.timestamp}`,
-                };
-                await delay(1000);
-                yield replayEvent;
-                // Then stream all the captured events
-                for (const event of response.events) {
-                    console.log("[ChatRoute] Replaying event:", event);
-                    await delay(1000);
-                    yield event;
-                }
-                // Finally, send a completion indicator
-                const completeEvent = {
-                    type: "message",
-                    role: "system",
-                    content: "✓ Replay complete",
-                };
-                await delay(1000);
-                yield completeEvent;
-            }
-            return streamAsyncGenerator(c, replayGenerator());
-        }
-        // Normal chat flow - capture and execute
-        // Use current conversation ID or generate a new one
-        let conversationId = thread.currentConversationId;
-        if (!conversationId) {
-            conversationId = randomUUID();
-            // Delete all todos for this thread when starting a new conversation
-            const db = await getDatabase();
-            await db.execute({
-                sql: "DELETE FROM todos WHERE threadId = ?",
-                args: [threadId],
-            });
-            // Update thread with the new conversation ID to maintain conversation continuity
-            await threadManager.updateThread(threadId, { currentConversationId: conversationId });
-        }
-        // Load and activate skills
-        const skillManager = new SkillManager();
-        const allSkills = await skillManager.loadSkills(threadPath);
-        const activatedSkills = await activateSkills(allSkills, content, thread);
-        if (activatedSkills.length > 0) {
-            console.log("[ChatRoute] Activated skills:", activatedSkills.map((s) => s.name).join(", "));
-        }
-        // Load agent definitions
-        const agentsManager = new AgentsManager();
-        const agents = await agentsManager.loadAgents(threadPath);
-        if (agents.length > 0) {
-            console.log("[ChatRoute] Loaded agents:", agents.map((a) => a.name).join(", "));
-        }
-        // Build execution context with activated skills and agents
-        const context = {
-            threadId,
-            threadPath,
-            model,
-            provider,
-            attachments,
-            planMode,
-            skills: activatedSkills,
-            agents,
-        };
-        console.log("[ChatRoute] Execution context:", {
-            threadId,
-            threadPath,
-            model,
-            planMode,
-            conversationId,
-            attachmentCount: attachments?.length ?? 0,
-            attachmentDetails: (attachments ?? []).map((a) => ({
-                name: a.name,
-                mimeType: a.mimeType,
-                contentLength: a.content?.length ?? 0,
-            })),
-        });
-        // Start capturing the conversation
-        const messageId = await conversationManager.startMessage(threadId, threadPath, conversationId, content, model, attachments, planMode);
-        // Load prior conversation context (completed messages only, excluding current, from current conversation)
-        const history = await conversationManager.getConversationHistoryByConversationId(threadPath, conversationId);
-        const priorMessages = (history?.messages ?? []).filter((m) => m.id !== messageId && m.response != null);
-        const contextBlock = formatConversationContext(priorMessages);
-        const promptWithContext = contextBlock.length > 0 ? `${contextBlock}\n\nCurrent message:\nUser: ${content}` : content;
-        // Use the request's abort signal to handle client disconnect
-        const abortController = new AbortController();
-        const requestSignal = c.req.raw.signal;
-        // If the request is already aborted, abort our controller
-        if (requestSignal.aborted) {
-            abortController.abort();
-        }
-        else {
-            // Listen for request abort and propagate to our controller
-            requestSignal.addEventListener("abort", () => {
-                abortController.abort();
-            }, { once: true });
-        }
-        // Mark thread as processing and register the abort controller so the
-        // stop endpoint can cancel execution independently of connection state
-        processingStateManager.setProcessing(threadId);
-        processingStateManager.registerAbortController(threadId, abortController);
-        // Create a generator for chat execution events
-        async function* chatExecutionGenerator() {
-            const capturedEvents = [];
-            let fullContent = "";
-            try {
-                for await (const event of agentExecutor.execute(promptWithContext, context, abortController.signal)) {
-                    // Capture the event
-                    capturedEvents.push(event);
-                    // Accumulate content from message events (for fallback when extracting)
-                    if (event.type === "message" && event.content) {
-                        fullContent += event.content;
-                    }
-                    // Emit thinking progress for tool-related messages so the UI shows progress
-                    if (event.type === "message" &&
-                        typeof event.content === "string" &&
-                        (event.role === "tool" || isToolLikeContent(event.content))) {
-                        const thinkingEvent = { type: "thinking", content: event.content };
-                        processingStateManager.pushEvent(threadId, thinkingEvent);
-                        yield thinkingEvent;
-                        continue;
-                    }
-                    // Buffer the event for late subscribers
-                    processingStateManager.pushEvent(threadId, event);
-                    yield event;
-                }
-                const finalContent = extractAssistantContent(capturedEvents, fullContent);
-                await conversationManager.completeMessage(messageId, finalContent, capturedEvents);
-                console.log("[ChatRoute] Conversation captured:", {
-                    messageId,
-                    eventCount: capturedEvents.length,
-                    contentLength: finalContent.length,
-                });
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                const errorEvent = {
-                    type: "error",
-                    content: errorMessage,
-                    error: {
-                        code: ErrorCodes.STREAM_ERROR,
-                        message: errorMessage,
-                        details: error instanceof Error ? { stack: error.stack } : undefined,
-                    },
-                };
-                capturedEvents.push(errorEvent);
-                yield errorEvent;
-                try {
-                    const finalContent = extractAssistantContent(capturedEvents, fullContent);
-                    await conversationManager.completeMessage(messageId, finalContent, capturedEvents);
-                }
-                catch (saveError) {
-                    console.error("[ChatRoute] Failed to save partial conversation:", saveError);
-                }
-            }
-            finally {
-                processingStateManager.clearProcessing(threadId);
-                try {
-                    const db = await getDatabase();
-                    await invalidateGitStatusCache(db, threadId);
-                    await clearWorkingByThreadId(db, threadId);
-                    try {
-                        const todo = await getTodoByThreadId(db, threadId);
-                        if (todo && todo.status === "Plan") {
-                            const planFilePath = join(threadPath, `${todo.id}-plan.md`);
-                            try {
-                                const planContent = await readFile(planFilePath, "utf-8");
-                                await updateTodo(db, todo.id, { description: planContent.trim() });
-                                await unlink(planFilePath);
-                            }
-                            catch {
-                                // Plan file not found or unreadable — skip silently
-                            }
-                        }
-                    }
-                    catch (e) {
-                        console.error("[ChatRoute] Failed to process plan file for todo:", e);
-                    }
-                }
-                catch (e) {
-                    console.error("[ChatRoute] Failed to clear working state for thread todos:", e);
-                }
-            }
-        }
-        async function* withCompleteSignal() {
-            yield* chatExecutionGenerator();
-            yield { type: "complete" };
-        }
-        return streamAsyncGenerator(c, withCompleteSignal(), { abortController });
-    }
-    catch (error) {
-        return errorResponse(c, ErrorCodes.REQUEST_PARSE_ERROR, "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
-    }
-}
-//# sourceMappingURL=chat-post.route.js.map