@thoughtflow/core 0.1.2

package/dist/conversation.class.js

@@ -0,0 +1,1221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conversation = void 0;
+const contracts_1 = require("./contracts");
+const ollama_adapter_1 = require("./adapters/llm/ollama.adapter");
+const conversation_events_bus_1 = require("./events/conversation-events.bus");
+const abort_controller_class_1 = require("./libs/abort-controller.class");
+const conversation_runner_class_1 = require("./libs/conversation-runner.class");
+const context_window_class_1 = require("./libs/context-window.class");
+const message_history_class_1 = require("./libs/message-history.class");
+const prompt_builder_class_1 = require("./libs/prompt-builder.class");
+const status_machine_class_1 = require("./libs/status-machine.class");
+const stream_emitter_class_1 = require("./libs/stream-emitter.class");
+const runtime_policy_llm_adapter_1 = require("./libs/runtime-policy-llm.adapter");
+const tool_registry_class_1 = require("./tools/tool-registry.class");
+const debug_logger_class_1 = require("./libs/debug-logger.class");
+const crypto_1 = require("crypto");
+const storage_1 = require("./storage");
+const zod_1 = require("zod");
+const tool_router_1 = require("./libs/tool-router");
+const subagent_job_manager_1 = require("./libs/subagent-job-manager");
+const subagent_job_tool_1 = require("./tools/subagent-job.tool");
+const core_preset_1 = require("./quick/core-preset");
+const context_document_manager_1 = require("./contexts/context-document-manager");
+const context_decomposer_1 = require("./contexts/context-decomposer");
+const context_router_1 = require("./contexts/context-router");
+const model_ref_resolver_1 = require("./libs/model-ref-resolver");
+class Conversation {
+    config;
+    conversationId = `conv_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    /** Stable uuidv4 identifier for this conversation session — used for storage namespacing. */
+    sessionId;
+    /** Thread identifier alias (same value as sessionId). */
+    threadId;
+    _history;
+    statusMachine = new status_machine_class_1.StatusMachine();
+    eventsBus;
+    abortController = new abort_controller_class_1.ConversationAbortController();
+    promptBuilder = new prompt_builder_class_1.PromptBuilder();
+    toolRegistry;
+    runner;
+    streamEmitter;
+    skills;
+    llmAdapter;
+    messageStorage;
+    interruptStorage;
+    interruptResolutionStorage;
+    checkpointStorage;
+    initInfo = { models: [] };
+    initPromise;
+    threadIterationsUsed = 0;
+    setAdapter(adapter, model) {
+        this.llmAdapter = adapter;
+        this.model = model;
+    }
+    checkpointStep = 0;
+    model;
+    contextConfig;
+    contextRouter;
+    contextDocCache = [];
+    contextDecompositionResult;
+    /** Suppress stream events — set during analysis to prevent noise in chat. */
+    suppressStream = false;
+    /** Knowledge document injected at session start — accessible across turns. */
+    knowledgeDoc;
+    constructor(config) {
+        this.config = config;
+        this.sessionId = config.threadId ?? config.sessionId ?? (0, crypto_1.randomUUID)();
+        this.threadId = this.sessionId;
+        this._history = new message_history_class_1.MessageHistory(config.payloadOffloadCacheDir, config.payloadOffloadThreshold);
+        this.eventsBus = new conversation_events_bus_1.ConversationEventsBus({
+            enableReasoningStream: config.reasoningStream === true,
+        });
+        const baseLlmAdapter = config.llmAdapter ??
+            new ollama_adapter_1.OllamaAdapter({
+                baseUrl: this.resolveBaseUrl(config)
+            });
+        this.llmAdapter = new runtime_policy_llm_adapter_1.RuntimePolicyLlmAdapter(baseLlmAdapter, config.llmRuntimePolicy);
+        this.messageStorage = config.storage?.messages ?? new storage_1.InMemoryAdapter();
+        this.interruptStorage = config.storage?.interrupts ?? new storage_1.InMemoryAdapter();
+        this.interruptResolutionStorage =
+            config.storage?.interruptResolutions ?? new storage_1.InMemoryAdapter();
+        this.checkpointStorage = config.storage?.checkpoints ?? new storage_1.InMemoryAdapter();
+        this.model = config.model ?? "qwen3:8b";
+        this.contextConfig = config.context;
+        this.toolRegistry = new tool_registry_class_1.ToolRegistry(config.tools ?? []);
+        this.skills = config.skills ?? [];
+        // Install default middleware: duplicate detection prevents LLM loops
+        if (!config.skipDefaultMiddleware) {
+            this.toolRegistry.use((0, tool_registry_class_1.createDuplicateDetectionMiddleware)());
+        }
+        // Register middleware declared in config
+        for (const mw of config.middleware ?? []) {
+            this.toolRegistry.use(mw);
+        }
+        // Install plugins declared in config
+        for (const plugin of config.plugins ?? []) {
+            this.use(plugin);
+        }
+        // Auto-register subagent_job tool if subagentJobs config is provided
+        const jobManager = config.subagentJobs
+            ? new subagent_job_manager_1.SubAgentJobManager(config.subagentJobs)
+            : undefined;
+        if (jobManager && config.subagentProfiles) {
+            const profiles = {};
+            for (const [label, subagent] of Object.entries(config.subagentProfiles)) {
+                profiles[label] = { subagent };
+            }
+            /* Skip if already registered (e.g. by McpToolRegistry) to avoid duplicate error */
+            try {
+                this.toolRegistry.register(new subagent_job_tool_1.SubagentJobTool({ jobManager, profiles }));
+            }
+            catch {
+                // already registered — that's fine
+            }
+        }
+        // Auto-register core reasoning tools (solve_complex, problem_tree, adaptive_lookup, comparative_analysis)
+        if (!config.skipCoreTools) {
+            const coreTools = (0, core_preset_1.createCoreTools)();
+            for (const tool of coreTools.tools) {
+                this.toolRegistry.register(tool);
+            }
+        }
+        // Create ToolRouter if configured
+        const toolRouter = config.toolRouter
+            ? new tool_router_1.ToolRouter(config.toolRouter)
+            : undefined;
+        // Optionally wrap ToolRegistry with a context window manager
+        // Auto-configure from numCtx when no explicit contextWindow given
+        const contextWindowManager = config.contextWindow
+            ? new context_window_class_1.ContextWindowManager(config.contextWindow)
+            : config.numCtx
+                ? new context_window_class_1.ContextWindowManager({
+                    strategy: "sliding-window",
+                    maxMessages: 999,
+                    maxTokens: Math.floor(config.numCtx * 0.75),
+                })
+                : undefined;
+        const logger = new debug_logger_class_1.DebugLogger(config.debugLevel ?? "off");
+        this.streamEmitter = new stream_emitter_class_1.StreamEmitter(this.eventsBus, config);
+        this.runner = new conversation_runner_class_1.ConversationRunner({
+            conversationId: this.conversationId,
+            sessionId: this.sessionId,
+            getModel: () => this.model,
+            selectModel: this.config.modelRouter,
+            thinking: this.config.thinking,
+            temperature: this.config.temperature,
+            numCtx: this.config.numCtx,
+            seed: this.config.seed ?? Math.floor(Math.random() * 2147483647),
+            stallDetection: this.config.stallDetection,
+            onTurnComplete: async (messages) => this.handleTurnComplete(messages),
+            llmAdapter: this.llmAdapter,
+            history: this._history,
+            statusMachine: this.statusMachine,
+            eventsBus: this.eventsBus,
+            toolRegistry: this.toolRegistry,
+            contextWindowManager,
+            logger,
+            toolFilter: this.config.toolFilter,
+            toolRetryPolicy: this.config.toolRetryPolicy,
+            normalizeRuntimeMetadata: (metadata) => this.normalizeRuntimeContext(metadata, "runner"),
+            beforeModelHook: this.config.beforeModelHook,
+            afterModelHook: this.config.afterModelHook,
+            interruptOn: this.config.interruptOn,
+            interruptDescriptionPrefix: this.config.interruptDescriptionPrefix,
+            toolRouter: toolRouter ? {
+                selectTools: (userMessage, availableTools, ctx) => toolRouter.selectTools(userMessage, availableTools, ctx),
+            } : undefined,
+            caller: { callStructured: this.callStructured.bind(this) },
+        });
+        this.initPromise = this.initialize();
+    }
+    get events$() {
+        return this.eventsBus.events$;
+    }
+    get messages$() {
+        return this.eventsBus.messages$;
+    }
+    get status$() {
+        return this.eventsBus.status$;
+    }
+    get status() {
+        return this.statusMachine.current;
+    }
+    get selectedModel() {
+        return this.model;
+    }
+    get pendingInterrupt() {
+        return this.runner.getPendingInterrupt();
+    }
+    get isInterrupted() {
+        return this.runner.hasPendingInterrupt();
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    async ready() {
+        await this.initPromise;
+        return this.getInitInfoSnapshot();
+    }
+    async getAvailableModels(forceRefresh = false) {
+        await this.initPromise;
+        if (!forceRefresh && this.initInfo.models.length > 0) {
+            return this.initInfo.models.map((model) => ({ ...model }));
+        }
+        const models = await this.llmAdapter.listModels();
+        this.initInfo.models = models;
+        this.applyModelFallback(models);
+        return models.map((model) => ({ ...model }));
+    }
+    async preflight(forceRefresh = false) {
+        await this.initPromise;
+        if (!forceRefresh && this.initInfo.preflight) {
+            return {
+                ...this.initInfo.preflight,
+                availableModels: this.initInfo.preflight.availableModels.map((model) => ({ ...model })),
+                capabilities: { ...this.initInfo.preflight.capabilities },
+                warnings: [...this.initInfo.preflight.warnings]
+            };
+        }
+        const result = await this.runPreflight();
+        this.initInfo.preflight = result;
+        return {
+            ...result,
+            availableModels: result.availableModels.map((model) => ({ ...model })),
+            capabilities: { ...result.capabilities },
+            warnings: [...result.warnings]
+        };
+    }
+    async sendPrompt(prompt, options) {
+        await this.initPromise;
+        const internalSignal = this.abortController.start();
+        // If caller provides an external signal, combine both so either can abort
+        const signal = options?.signal
+            ? AbortSignal.any([internalSignal, options.signal])
+            : internalSignal;
+        const runtimeMetadata = this.resolveRuntimeContext(options?.metadata, "sendPrompt");
+        const builtPrompt = await this.buildPrompt(prompt, options, runtimeMetadata);
+        try {
+            const { signal: _s, metadata: _m, skillNames: _sn, ...safeOptions } = options ?? {};
+            const result = await this.runner.runTurn(builtPrompt, {
+                signal,
+                maxIterations: this.resolveMaxIterationsBudget(),
+                maxToolCalls: this.config.maxToolCallsPerRun,
+                maxToolCallsPerTool: this.config.maxToolCallsPerTool,
+                ...safeOptions,
+                metadata: runtimeMetadata,
+            });
+            this.threadIterationsUsed += result.iterationsUsed;
+            await this.persistPendingInterruptSnapshot();
+            this.abortController.clear();
+            return result;
+        }
+        catch (error) {
+            this.abortController.clear();
+            throw error;
+        }
+    }
+    async resume(response, options) {
+        await this.initPromise;
+        const internalSignal = this.abortController.start();
+        const signal = options?.signal
+            ? AbortSignal.any([internalSignal, options.signal])
+            : internalSignal;
+        const pendingInterruptId = this.runner.getPendingInterrupt()?.id;
+        const runtimeMetadata = this.resolveRuntimeContext(options?.metadata, "resume");
+        try {
+            const { signal: _s, metadata: _m, ...safeOptions } = options ?? {};
+            const result = await this.runner.resumeTurn(response, {
+                signal,
+                maxIterations: this.resolveMaxIterationsBudget(),
+                maxToolCalls: this.config.maxToolCallsPerRun,
+                maxToolCallsPerTool: this.config.maxToolCallsPerTool,
+                ...safeOptions,
+                metadata: runtimeMetadata,
+            });
+            this.threadIterationsUsed += result.iterationsUsed;
+            await this.persistPendingInterruptSnapshot();
+            await this.persistInterruptResolution(pendingInterruptId, response);
+            this.abortController.clear();
+            return result;
+        }
+        catch (error) {
+            this.abortController.clear();
+            throw error;
+        }
+    }
+    async callStructured(prompt, schema, options) {
+        return this.executeStructuredCall(prompt, schema, options, false);
+    }
+    async callStructuredStreaming(prompt, schema, options) {
+        return this.executeStructuredCall(prompt, schema, options, true);
+    }
+    /**
+     * Run a tool-calling loop: sends the prompt, lets the LLM call tools, returns final result.
+     * Tools are already configured via Conversation constructor → config.tools.
+     * Optionally restricts which tools the LLM can use via toolNames.
+     */
+    async callWithTools(prompt, options) {
+        const tools = this.config.tools ? [...this.config.tools] : [];
+        if (options?.toolNames && options.toolNames.length > 0) {
+            const allowed = new Set(options.toolNames);
+            this.config.tools = tools.filter(t => allowed.has(t.name));
+        }
+        try {
+            return await this.sendPrompt(prompt, {
+                signal: options?.signal,
+                metadata: options?.metadata,
+            });
+        }
+        finally {
+            this.config.tools = tools;
+        }
+    }
+    async executeStructuredCall(prompt, schema, options, useStreaming) {
+        await this.initPromise;
+        const internalSignal = this.abortController.start();
+        const signal = options?.signal
+            ? AbortSignal.any([internalSignal, options.signal])
+            : internalSignal;
+        const runtimeMetadata = this.resolveRuntimeContext(options?.metadata, "callStructured");
+        const retries = Math.max(1, options?.maxRetries ?? 3);
+        const builtPrompt = await this.buildPrompt(prompt, options, runtimeMetadata);
+        const responseSchema = this.zodToJsonSchema(schema);
+        const onStructuredChunk = options?.onChunk;
+        const structuredToolName = "__structured_output__";
+        const structuredMode = await this.resolveStructuredOutputMode(options?.structuredOutputStrategy);
+        const systemPrompt = this.withStructuredOutputInstruction(builtPrompt.systemPrompt, structuredMode, structuredToolName);
+        const requestMessages = [
+            ...this.history.snapshot(),
+            this.createTransientMessage("system", systemPrompt),
+            this.createTransientMessage("user", builtPrompt.userPrompt)
+        ];
+        let lastRawOutput;
+        let lastParseError;
+        this.transition(contracts_1.ConversationStatus.RUNNING);
+        try {
+            let effectiveMode = structuredMode;
+            for (let attempt = 1; attempt <= retries; attempt++) {
+                const attemptMessages = attempt === 1
+                    ? requestMessages
+                    : [
+                        ...requestMessages,
+                        this.createTransientMessage("assistant", lastRawOutput ?? ""),
+                        this.createTransientMessage("user", effectiveMode === "tool"
+                            ? `Your previous response did not contain a valid '${structuredToolName}' tool call for this schema. Error: ${lastParseError ?? "unknown"}. Call '${structuredToolName}' exactly once with corrected arguments.`
+                            : `Your previous output was invalid JSON for this schema. Error: ${lastParseError ?? "unknown"}. Return only corrected JSON.`)
+                    ];
+                const requestTools = effectiveMode === "tool"
+                    ? [
+                        {
+                            name: structuredToolName,
+                            description: "Return the final structured result by calling this tool with arguments that exactly match the required schema.",
+                            inputJsonSchema: responseSchema ?? { type: "object", properties: {} },
+                        },
+                    ]
+                    : [];
+                const request = {
+                    model: this.model,
+                    messages: attemptMessages,
+                    tools: requestTools,
+                    responseFormat: effectiveMode === "tool" ? "text" : "json",
+                    responseSchema,
+                    structuredOutput: {
+                        strategy: effectiveMode === "tool" ? "prompt-json" : effectiveMode,
+                        schemaName: "conversation_structured_response",
+                        strict: true,
+                    },
+                    signal,
+                    thinking: this.config.thinking,
+                    temperature: this.config.temperature,
+                    numCtx: this.config.numCtx,
+                    seed: this.config.seed
+                };
+                await this.config.beforeModelHook?.({
+                    phase: "structured",
+                    iteration: attempt,
+                    model: this.model,
+                    messages: request.messages,
+                    metadata: { ...runtimeMetadata },
+                });
+                let response;
+                try {
+                    const shouldStream = useStreaming && effectiveMode !== "tool";
+                    response = shouldStream
+                        ? await this.llmAdapter.streamChat(request, (chunk) => {
+                            if (!this.suppressStream)
+                                this.eventsBus.pushStreamChunk(chunk);
+                            if (typeof onStructuredChunk === "function") {
+                                onStructuredChunk(chunk);
+                            }
+                        })
+                        : await this.llmAdapter.chat(request);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    // Fall back to tool mode when provider rejects response_format (e.g. DeepSeek)
+                    if (effectiveMode !== "tool" &&
+                        (errMsg.includes("response_format") ||
+                            errMsg.includes("json_schema") ||
+                            errMsg.includes("json_object") ||
+                            errMsg.includes("This response_format type is unavailable"))) {
+                        effectiveMode = "tool";
+                        attempt = 0; // Reset retry counter for new mode
+                        continue;
+                    }
+                    throw err;
+                }
+                await this.config.afterModelHook?.({
+                    phase: "structured",
+                    iteration: attempt,
+                    model: this.model,
+                    messages: request.messages,
+                    metadata: { ...runtimeMetadata },
+                    response: response.message,
+                });
+                lastRawOutput = response.message.content ?? "";
+                let candidateData;
+                if (effectiveMode === "tool") {
+                    const fromTool = this.extractStructuredToolPayload(response.message.toolCalls, structuredToolName);
+                    if (fromTool.success) {
+                        candidateData = fromTool.data;
+                        lastRawOutput = JSON.stringify(fromTool.data);
+                    }
+                    else {
+                        const parsed = this.parseStructuredJson(lastRawOutput);
+                        if (!parsed.success) {
+                            lastParseError = `${fromTool.error}; ${parsed.error}`;
+                            continue;
+                        }
+                        candidateData = parsed.data;
+                    }
+                }
+                else {
+                    const parsed = this.parseStructuredJson(lastRawOutput);
+                    if (!parsed.success) {
+                        lastParseError = parsed.error;
+                        continue;
+                    }
+                    candidateData = parsed.data;
+                }
+                const validated = schema.safeParse(candidateData);
+                if (!validated.success) {
+                    const autoRepairEnabled = options?.autoRepairStructuredOutput !== false;
+                    if (autoRepairEnabled) {
+                        const repaired = this.tryAutoRepairStructuredData(candidateData, schema);
+                        if (repaired.success) {
+                            const systemMessage = this._history.push("system", builtPrompt.systemPrompt, {
+                                turn: "system",
+                                ...runtimeMetadata
+                            });
+                            this.eventsBus.pushMessage(systemMessage);
+                            const userMessage = this._history.push("user", builtPrompt.userPrompt, {
+                                turn: "user",
+                                ...runtimeMetadata
+                            });
+                            this.eventsBus.pushMessage(userMessage);
+                            const assistantMessage = this.history.pushAssistant(lastRawOutput);
+                            this.eventsBus.pushMessage(assistantMessage);
+                            await this.handleTurnComplete(this.history.snapshot());
+                            this.transition(contracts_1.ConversationStatus.COMPLETED);
+                            this.abortController.clear();
+                            return repaired.data;
+                        }
+                    }
+                    lastParseError = validated.error.message;
+                    continue;
+                }
+                const systemMessage = this.history.push("system", builtPrompt.systemPrompt, {
+                    turn: "system",
+                    ...runtimeMetadata
+                });
+                this.eventsBus.pushMessage(systemMessage);
+                const userMessage = this.history.push("user", builtPrompt.userPrompt, {
+                    turn: "user",
+                    ...runtimeMetadata
+                });
+                this.eventsBus.pushMessage(userMessage);
+                const assistantMessage = this.history.pushAssistant(lastRawOutput);
+                this.eventsBus.pushMessage(assistantMessage);
+                await this.handleTurnComplete(this.history.snapshot());
+                this.transition(contracts_1.ConversationStatus.COMPLETED);
+                this.abortController.clear();
+                return validated.data;
+            }
+            const error = new Error(`callStructured failed after ${retries} attempts. Last error: ${lastParseError ?? "Unknown parse/validation error"}`);
+            error.name = "CallStructuredRetryError";
+            error.attempts = retries;
+            error.lastRawOutput = lastRawOutput;
+            error.lastParseError = lastParseError;
+            this.transition(contracts_1.ConversationStatus.FAILED);
+            throw error;
+        }
+        catch (error) {
+            if (this.isAbortError(error)) {
+                this.transition(contracts_1.ConversationStatus.CANCELLED);
+            }
+            this.abortController.clear();
+            throw error;
+        }
+    }
+    async loadHistory(sessionId = this.sessionId) {
+        await this.initPromise;
+        if (sessionId !== this.sessionId) {
+            throw new Error(`Conversation sessionId mismatch. Create Conversation with sessionId='${sessionId}' to resume this session.`);
+        }
+        const stored = await this.messageStorage.search({ sessionId });
+        const ordered = [...stored].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        this.history.replace(ordered.map((item) => this.fromStoredMessage(item)));
+        this.threadIterationsUsed = this.estimateIterationsFromHistory(this.history.snapshot());
+        await this.restorePendingInterruptSnapshot(sessionId);
+        return this.history.snapshot();
+    }
+    async getInterruptResolutions(sessionId = this.sessionId) {
+        await this.initPromise;
+        if (sessionId !== this.sessionId) {
+            throw new Error(`Conversation sessionId mismatch. Create Conversation with sessionId='${sessionId}' to inspect this session.`);
+        }
+        const entries = await this.interruptResolutionStorage.search({ sessionId });
+        return [...entries]
+            .sort((a, b) => a.resolvedAt.localeCompare(b.resolvedAt))
+            .map((entry) => ({
+            ...entry,
+            decisions: entry.decisions.map((decision) => this.cloneInterruptDecision(decision)),
+        }));
+    }
+    async getCheckpoints(sessionId = this.sessionId) {
+        await this.initPromise;
+        if (sessionId !== this.sessionId) {
+            throw new Error(`Conversation sessionId mismatch. Create Conversation with sessionId='${sessionId}' to inspect this session.`);
+        }
+        const entries = await this.checkpointStorage.search({ sessionId });
+        return [...entries]
+            .sort((a, b) => a.step - b.step)
+            .map((entry) => ({ ...entry }));
+    }
+    async runLoop(nextPrompt, options) {
+        const results = [];
+        while (true) {
+            const prompt = await nextPrompt();
+            if (!prompt) {
+                break;
+            }
+            const result = await this.sendPrompt(prompt, options);
+            results.push(result);
+            if (result.status === contracts_1.ConversationStatus.CANCELLED || result.status === contracts_1.ConversationStatus.FAILED) {
+                break;
+            }
+        }
+        return results;
+    }
+    stop(reason) {
+        this.abortController.abort(reason);
+    }
+    dispose() {
+        this.streamEmitter.dispose();
+        this.abortController.abort("Conversation disposed");
+        this.abortController.clear();
+    }
+    /**
+     * Get the message history object for this conversation.
+     * Can be used to access raw messages or resolve offloaded payloads.
+     */
+    get history() {
+        return this._history;
+    }
+    /** Workspace root directory, e.g. for resolving file paths. */
+    get rootDir() {
+        return this.config.rootDir;
+    }
+    /**
+     * Get the LLM adapter instance for this conversation.
+     * Useful for accessing the underlying adapter and its methods.
+     */
+    getLlmAdapter() {
+        return this.llmAdapter;
+    }
+    /**
+     * Clear all messages from the conversation history.
+     * Also cleans up any offloaded payloads from the filesystem.
+     */
+    clearHistory() {
+        this._history.clear();
+    }
+    /**
+     * Install a plugin into this conversation. The plugin's install() callback
+     * receives the conversation's ToolRegistry and rootDir. Plugins can be
+     * added at any time, but must be installed before the first sendPrompt()
+     * to guarantee their tools are available for that turn.
+     */
+    use(plugin) {
+        const ctx = {
+            toolRegistry: this.toolRegistry,
+            rootDir: this.config.rootDir,
+        };
+        plugin.install(ctx);
+    }
+    /**
+     * Get all context documents as a flat array of { name, content } objects.
+     */
+    getContextDocuments() {
+        if (!this.contextConfig?.documents)
+            return [];
+        return Object.entries(this.contextConfig.documents).map(([name, content]) => ({
+            name,
+            content
+        }));
+    }
+    /**
+     * Apply context document inheritance to a subagent's system prompt
+     * based on the configured injection policy.
+     *
+     * @param subagent The subagent to modify (mutated in-place)
+     * @param prompt   Optional user prompt for relevant-only routing
+     */
+    async applyContextToSubagent(subagent, prompt) {
+        const injection = this.contextConfig?.injection;
+        if (!injection || injection.subagentBehavior === 'none' || !this.contextConfig?.documents) {
+            return;
+        }
+        let docs;
+        if (injection.subagentBehavior === 'inherit-all') {
+            docs = this.getContextDocuments();
+        }
+        else if (injection.subagentBehavior === 'inherit-relevant') {
+            if (this.contextRouter && this.contextDocCache.length > 0 && prompt) {
+                const relevantNames = await this.contextRouter.route(prompt, this.contextDocCache);
+                const cfg = this.contextConfig;
+                const relevantSet = new Set(relevantNames);
+                docs = this.contextDocCache
+                    .filter(c => relevantSet.has(c.name))
+                    .map(c => {
+                    const content = cfg.documents?.[c.name] ?? "";
+                    return { name: c.name, content };
+                });
+            }
+            else {
+                docs = this.getContextDocuments();
+            }
+        }
+        else {
+            docs = this.getContextDocuments();
+        }
+        if (docs.length > 0) {
+            const contextBlock = docs
+                .map(d => `### ${d.name}\n${d.content}`)
+                .join('\n\n---\n\n');
+            subagent.systemPrompt = `${subagent.systemPrompt}\n\n## Inherited Context Documents\n\n${contextBlock}`;
+        }
+    }
+    async buildPrompt(prompt, options, runtimeMetadata) {
+        const selectedSkills = this.selectSkills(options?.skillNames);
+        let contextDocs;
+        // Inject knowledge document if set (from project store)
+        if (this.knowledgeDoc) {
+            contextDocs = [this.knowledgeDoc];
+        }
+        if (this.contextRouter && this.contextDocCache.length > 0) {
+            const relevantNames = await this.contextRouter.route(prompt, this.contextDocCache);
+            if (relevantNames.length > 0) {
+                const cfg = this.contextConfig;
+                const injection = cfg.injection ?? {};
+                const max = injection.maxDocuments;
+                const relevantSet = new Set(max ? relevantNames.slice(0, max) : relevantNames);
+                const ctxDocs = this.contextDocCache
+                    .filter(c => relevantSet.has(c.name))
+                    .map(c => {
+                    const content = cfg.documents?.[c.name] ?? "";
+                    return { name: c.name, content };
+                });
+                contextDocs = contextDocs ? [...contextDocs, ...ctxDocs] : ctxDocs;
+            }
+        }
+        return this.promptBuilder.build({
+            systemPrompt: this.config.systemPrompt,
+            userLanguage: this.config.userLanguage,
+            userPrompt: prompt,
+            skills: selectedSkills,
+            contextDocs,
+            runtimeContext: {
+                conversationId: this.conversationId,
+                metadata: runtimeMetadata ?? this.resolveRuntimeContext(options?.metadata, "buildPrompt")
+            }
+        });
+    }
+    resolveRuntimeContext(metadata, source) {
+        const merged = {
+            ...(this.config.metadata ?? {}),
+            ...(metadata ?? {}),
+        };
+        return this.normalizeRuntimeContext(merged, source);
+    }
+    normalizeRuntimeContext(metadata, source) {
+        const schema = this.config.contextSchema;
+        if (!schema) {
+            return { ...metadata };
+        }
+        const parsed = schema.safeParse(metadata);
+        if (!parsed.success) {
+            throw new Error(`Invalid runtime context for ${source}: ${parsed.error.issues
+                .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+                .join("; ")}`);
+        }
+        const data = parsed.data;
+        if (!data || typeof data !== "object" || Array.isArray(data)) {
+            throw new Error(`Invalid runtime context for ${source}: schema must resolve to an object value.`);
+        }
+        return { ...data };
+    }
+    resolveMaxIterationsBudget() {
+        const perRun = this.normalizePositiveInt(this.config.maxIterationsPerRun);
+        const perThread = this.normalizePositiveInt(this.config.maxIterationsPerThread);
+        if (perRun === undefined && perThread === undefined) {
+            return undefined;
+        }
+        let budget = Number.POSITIVE_INFINITY;
+        if (perRun !== undefined) {
+            budget = Math.min(budget, perRun);
+        }
+        if (perThread !== undefined) {
+            const remaining = Math.max(0, perThread - this.threadIterationsUsed);
+            budget = Math.min(budget, remaining);
+        }
+        if (!Number.isFinite(budget)) {
+            return undefined;
+        }
+        return Math.max(0, Math.floor(budget));
+    }
+    normalizePositiveInt(value) {
+        if (typeof value !== "number") {
+            return undefined;
+        }
+        if (!Number.isFinite(value)) {
+            return undefined;
+        }
+        const normalized = Math.floor(value);
+        return normalized > 0 ? normalized : undefined;
+    }
+    estimateIterationsFromHistory(messages) {
+        return messages.filter((message) => message.role === "assistant").length;
+    }
+    selectSkills(skillNames) {
+        if (!skillNames || skillNames.length === 0) {
+            return this.skills;
+        }
+        const wanted = new Set(skillNames);
+        return this.skills.filter((skill) => wanted.has(skill.name));
+    }
+    async initialize() {
+        try {
+            await this.messageStorage.initialize?.();
+            await this.interruptStorage.initialize?.();
+            await this.interruptResolutionStorage.initialize?.();
+            await this.checkpointStorage.initialize?.();
+            const checkpoints = await this.checkpointStorage.search({ sessionId: this.sessionId });
+            if (checkpoints.length > 0) {
+                const maxStep = Math.max(...checkpoints.map((entry) => entry.step));
+                this.checkpointStep = Number.isFinite(maxStep) ? maxStep : 0;
+            }
+            if (this.contextConfig?.documents) {
+                await this.initializeContextDocuments();
+            }
+            if (this.config.loadModelsOnInit !== false) {
+                this.initInfo.models = await this.llmAdapter.listModels();
+                this.applyModelFallback(this.initInfo.models);
+            }
+            if (this.config.runPreflightOnInit !== false) {
+                this.initInfo.preflight = await this.runPreflight();
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error("Conversation initialization failed");
+            this.config.onError?.(err);
+            // Re-throw so ready() rejects — silent failure is worse than a clear error
+            throw err;
+        }
+    }
+    async initializeContextDocuments() {
+        const cfg = this.contextConfig;
+        const cacheDir = cfg.decompose?.cacheDir ?? ".thoughtflow/context-cache.json";
+        const manager = new context_document_manager_1.ContextDocumentManager(cfg.documents, cacheDir);
+        const changedDocs = manager.getChangedDocs();
+        const existingCache = manager.loadCache();
+        if (changedDocs.length > 0 && cfg.decompose?.enabled !== false) {
+            const resolver = new model_ref_resolver_1.ModelRefResolver();
+            const { adapter, model } = resolver.resolve(cfg.decompose?.model, { adapter: this.llmAdapter, model: this.model });
+            const decomposer = new context_decomposer_1.ContextDecomposer(adapter, model);
+            const tools = this.toolRegistry.getAll();
+            const result = await decomposer.decompose(changedDocs, tools);
+            const mergedCache = this.mergeCache(existingCache, result.documents);
+            manager.saveCache(mergedCache);
+            this.contextDocCache = mergedCache;
+            this.contextDecompositionResult = result;
+        }
+        else {
+            this.contextDocCache = existingCache;
+        }
+        if (this.contextDocCache.length > 0 && cfg.routing) {
+            const resolver = new model_ref_resolver_1.ModelRefResolver();
+            const { adapter, model } = resolver.resolve(cfg.routing.model, { adapter: this.llmAdapter, model: this.model });
+            this.contextRouter = new context_router_1.ContextRouter(cfg.routing, adapter, model);
+        }
+    }
+    mergeCache(existing, newEntries) {
+        const map = new Map(existing.map(e => [e.name, e]));
+        for (const entry of newEntries) {
+            map.set(entry.name, entry);
+        }
+        return Array.from(map.values());
+    }
+    applyModelFallback(models) {
+        if (this.config.model) {
+            this.model = this.config.model;
+            return;
+        }
+        if (models.length > 0) {
+            this.model = models[0].name;
+        }
+    }
+    async runPreflight() {
+        const model = this.model;
+        return this.llmAdapter.preflight({
+            model,
+            thinking: this.config.thinking
+        });
+    }
+    resolveBaseUrl(config) {
+        if (config.baseUrl) {
+            return config.baseUrl;
+        }
+        const host = config.host ?? "localhost";
+        const port = config.port ?? 11434;
+        return `http://${host}:${port}`;
+    }
+    getInitInfoSnapshot() {
+        return {
+            models: this.initInfo.models.map((model) => ({ ...model })),
+            preflight: this.initInfo.preflight
+                ? {
+                    ...this.initInfo.preflight,
+                    availableModels: this.initInfo.preflight.availableModels.map((model) => ({ ...model })),
+                    capabilities: { ...this.initInfo.preflight.capabilities },
+                    warnings: [...this.initInfo.preflight.warnings]
+                }
+                : undefined
+        };
+    }
+    async handleTurnComplete(messages) {
+        await this.persistMessages(messages);
+        await this.persistCheckpointSnapshot(messages);
+        await this.config.onTurnComplete?.(messages);
+    }
+    async persistCheckpointSnapshot(messages) {
+        const now = new Date().toISOString();
+        const lastMessage = messages[messages.length - 1];
+        this.checkpointStep += 1;
+        await this.checkpointStorage.create({
+            sessionId: this.sessionId,
+            threadId: this.threadId,
+            step: this.checkpointStep,
+            messagesCount: messages.length,
+            lastMessageId: lastMessage?.id,
+            createdAt: now,
+        });
+    }
+    async persistMessages(messages) {
+        for (const message of messages) {
+            await this.messageStorage.create(this.toStoredMessage(message));
+        }
+    }
+    async persistPendingInterruptSnapshot() {
+        const existing = await this.interruptStorage.search({ sessionId: this.sessionId });
+        for (const entry of existing) {
+            await this.interruptStorage.delete(entry.id);
+        }
+        const pending = this.runner.getPendingInterruptSnapshot();
+        if (!pending) {
+            return;
+        }
+        const now = new Date().toISOString();
+        await this.interruptStorage.create({
+            sessionId: this.sessionId,
+            pending,
+            createdAt: now,
+            updatedAt: now,
+        });
+    }
+    async restorePendingInterruptSnapshot(sessionId) {
+        const stored = await this.interruptStorage.search({ sessionId });
+        if (stored.length === 0) {
+            this.runner.restorePendingInterrupt(null);
+            return;
+        }
+        const latest = [...stored].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
+        this.runner.restorePendingInterrupt(latest?.pending ?? null);
+        if (this.runner.hasPendingInterrupt() && this.statusMachine.current !== contracts_1.ConversationStatus.INTERRUPTED) {
+            this.transition(contracts_1.ConversationStatus.INTERRUPTED);
+        }
+    }
+    async persistInterruptResolution(pendingInterruptId, response) {
+        if (!pendingInterruptId) {
+            return;
+        }
+        const decisions = this.resolveResumeDecisions(response, pendingInterruptId);
+        if (!decisions) {
+            return;
+        }
+        const now = new Date().toISOString();
+        await this.interruptResolutionStorage.create({
+            sessionId: this.sessionId,
+            interruptId: pendingInterruptId,
+            decisions: decisions.map((decision) => this.cloneInterruptDecision(decision)),
+            resolvedAt: now,
+            createdAt: now,
+        });
+    }
+    resolveResumeDecisions(response, pendingInterruptId) {
+        if (response &&
+            typeof response === "object" &&
+            !Array.isArray(response) &&
+            "decisions" in response &&
+            Array.isArray(response.decisions)) {
+            return response.decisions;
+        }
+        if (!response || typeof response !== "object" || Array.isArray(response)) {
+            return null;
+        }
+        const mapped = response[pendingInterruptId];
+        if (!mapped || !Array.isArray(mapped.decisions)) {
+            return null;
+        }
+        return mapped.decisions;
+    }
+    cloneInterruptDecision(decision) {
+        if (decision.type === "approve") {
+            return { type: "approve" };
+        }
+        if (decision.type === "reject") {
+            return {
+                type: "reject",
+                message: decision.message,
+            };
+        }
+        return {
+            type: "edit",
+            editedAction: {
+                name: decision.editedAction.name,
+                args: { ...(decision.editedAction.args ?? {}) },
+            },
+        };
+    }
+    toStoredMessage(message) {
+        return {
+            messageId: message.id,
+            sessionId: this.sessionId,
+            role: message.role,
+            content: message.content,
+            toolCallId: message.toolCallId,
+            metadata: message.metadata ? { ...message.metadata } : undefined,
+            toolCalls: message.toolCalls?.map((call) => ({
+                id: call.id,
+                name: call.name,
+                arguments: { ...(call.arguments ?? {}) }
+            })),
+            createdAt: message.createdAt
+        };
+    }
+    fromStoredMessage(stored) {
+        return {
+            id: stored.messageId ?? stored.id,
+            role: stored.role,
+            content: stored.content,
+            createdAt: stored.createdAt,
+            toolCallId: stored.toolCallId,
+            metadata: stored.metadata ? { ...stored.metadata } : undefined,
+            toolCalls: stored.toolCalls?.map((call) => ({
+                id: call.id,
+                name: call.name,
+                arguments: { ...(call.arguments ?? {}) }
+            }))
+        };
+    }
+    createTransientMessage(role, content) {
+        return {
+            id: `tmp_${role}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            role,
+            content,
+            createdAt: new Date().toISOString()
+        };
+    }
+    withStructuredOutputInstruction(systemPrompt, mode, toolName) {
+        if (mode === "tool" && toolName) {
+            return [
+                systemPrompt,
+                `You must produce the final result via tool call '${toolName}'.`,
+                `Call '${toolName}' exactly once with arguments matching the schema.`,
+                "Do not provide explanations outside the tool call.",
+            ].join("\n\n");
+        }
+        return `${systemPrompt}\n\nReturn ONLY valid JSON. No markdown fences, no explanations.`;
+    }
+    async resolveStructuredOutputMode(strategy) {
+        const preferred = strategy ?? "provider-native";
+        if (preferred === "tool") {
+            return "tool";
+        }
+        if (preferred === "prompt-json") {
+            return "prompt-json";
+        }
+        const nativeSupport = await this.resolveNativeStructuredOutputSupport();
+        if (nativeSupport === false) {
+            return "tool";
+        }
+        return "provider-native";
+    }
+    async resolveNativeStructuredOutputSupport() {
+        const preflightSupport = this.initInfo.preflight?.capabilities.supportsNativeStructuredOutput;
+        if (typeof preflightSupport === "boolean") {
+            return preflightSupport;
+        }
+        try {
+            const preflight = await this.runPreflight();
+            this.initInfo.preflight = preflight;
+            return preflight.capabilities.supportsNativeStructuredOutput;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    extractStructuredToolPayload(toolCalls, toolName) {
+        if (!Array.isArray(toolCalls) || toolCalls.length === 0) {
+            return { success: false, error: `No tool calls returned; expected '${toolName}'.` };
+        }
+        const matching = toolCalls.find((call) => call.name === toolName);
+        if (!matching) {
+            return { success: false, error: `Tool '${toolName}' was not called.` };
+        }
+        const args = matching.arguments ?? {};
+        if (!args || typeof args !== "object" || Array.isArray(args)) {
+            return { success: false, error: `Tool '${toolName}' returned invalid arguments.` };
+        }
+        return { success: true, data: args };
+    }
+    tryAutoRepairStructuredData(data, schema) {
+        const repairedCandidate = this.repairStructuredValue(data, schema);
+        const repairedValidation = schema.safeParse(repairedCandidate);
+        if (!repairedValidation.success) {
+            return { success: false };
+        }
+        return {
+            success: true,
+            data: repairedValidation.data,
+        };
+    }
+    repairStructuredValue(value, schema) {
+        const unwrapped = this.unwrapZodType(schema);
+        if (unwrapped instanceof zod_1.z.ZodObject) {
+            const source = value && typeof value === "object" && !Array.isArray(value)
+                ? value
+                : {};
+            const shape = unwrapped._def.shape();
+            const out = { ...source };
+            for (const [key, fieldSchema] of Object.entries(shape)) {
+                if (out[key] === undefined) {
+                    if (this.isOptionalZodField(fieldSchema)) {
+                        continue;
+                    }
+                    out[key] = this.defaultValueForStructuredField(fieldSchema);
+                    continue;
+                }
+                out[key] = this.repairStructuredValue(out[key], fieldSchema);
+            }
+            return out;
+        }
+        if (unwrapped instanceof zod_1.z.ZodArray) {
+            if (!Array.isArray(value)) {
+                return [];
+            }
+            const itemSchema = unwrapped._def.type;
+            return value.map((entry) => this.repairStructuredValue(entry, itemSchema));
+        }
+        return value;
+    }
+    defaultValueForStructuredField(schema) {
+        const unwrapped = this.unwrapZodType(schema);
+        if (unwrapped instanceof zod_1.z.ZodString)
+            return "";
+        if (unwrapped instanceof zod_1.z.ZodNumber)
+            return 0;
+        if (unwrapped instanceof zod_1.z.ZodBoolean)
+            return false;
+        if (unwrapped instanceof zod_1.z.ZodArray)
+            return [];
+        if (unwrapped instanceof zod_1.z.ZodObject)
+            return this.repairStructuredValue({}, unwrapped);
+        return null;
+    }
+    unwrapZodType(schema) {
+        let current = schema;
+        for (;;) {
+            if (current instanceof zod_1.z.ZodOptional || current instanceof zod_1.z.ZodNullable) {
+                current = current._def.innerType;
+            }
+            else if (current instanceof zod_1.z.ZodDefault) {
+                current = current._def.innerType;
+            }
+            else if (current instanceof zod_1.z.ZodEffects) {
+                current = current._def.schema;
+            }
+            else {
+                return current;
+            }
+        }
+    }
+    isOptionalZodField(schema) {
+        let current = schema;
+        for (;;) {
+            if (current instanceof zod_1.z.ZodOptional || current instanceof zod_1.z.ZodNullable) {
+                return true;
+            }
+            if (current instanceof zod_1.z.ZodDefault) {
+                return true;
+            }
+            if (current instanceof zod_1.z.ZodEffects) {
+                current = current._def.schema;
+                continue;
+            }
+            return false;
+        }
+    }
+    parseStructuredJson(raw) {
+        const candidates = this.collectJsonCandidates(raw);
+        let lastError = "No JSON payload found in LLM response";
+        for (const candidate of candidates) {
+            try {
+                return { success: true, data: JSON.parse(candidate) };
+            }
+            catch (error) {
+                const err = error instanceof Error ? error.message : String(error);
+                lastError = err;
+            }
+        }
+        return { success: false, error: lastError };
+    }
+    zodToJsonSchema(schema) {
+        let inner = schema;
+        for (;;) {
+            if (inner instanceof zod_1.z.ZodOptional || inner instanceof zod_1.z.ZodNullable) {
+                inner = inner._def.innerType;
+            }
+            else if (inner instanceof zod_1.z.ZodDefault) {
+                inner = inner._def.innerType;
+            }
+            else if (inner instanceof zod_1.z.ZodEffects) {
+                inner = inner._def.schema;
+            }
+            else {
+                break;
+            }
+        }
+        if (inner instanceof zod_1.z.ZodString)
+            return { type: "string" };
+        if (inner instanceof zod_1.z.ZodNumber)
+            return { type: "number" };
+        if (inner instanceof zod_1.z.ZodBoolean)
+            return { type: "boolean" };
+        if (inner instanceof zod_1.z.ZodEnum)
+            return { type: "string", enum: inner._def.values };
+        if (inner instanceof zod_1.z.ZodArray) {
+            return { type: "array", items: this.zodToJsonSchema(inner._def.type) ?? { type: "string" } };
+        }
+        if (inner instanceof zod_1.z.ZodObject) {
+            const shape = inner._def.shape();
+            const properties = {};
+            const required = [];
+            for (const [key, fieldSchema] of Object.entries(shape)) {
+                properties[key] = this.zodToJsonSchema(fieldSchema) ?? { type: "string" };
+                const isOptional = fieldSchema instanceof zod_1.z.ZodOptional ||
+                    fieldSchema instanceof zod_1.z.ZodNullable ||
+                    fieldSchema instanceof zod_1.z.ZodDefault;
+                if (!isOptional)
+                    required.push(key);
+            }
+            const out = { type: "object", properties };
+            if (required.length > 0)
+                out.required = required;
+            return out;
+        }
+        return undefined;
+    }
+    collectJsonCandidates(raw) {
+        const text = (raw ?? "").trim();
+        if (!text)
+            return [];
+        const candidates = [text];
+        const fenced = /```(?:json)?\s*([\s\S]*?)```/gi;
+        let match;
+        while ((match = fenced.exec(text)) !== null) {
+            const block = (match[1] ?? "").trim();
+            if (block)
+                candidates.push(block);
+        }
+        return candidates;
+    }
+    transition(status) {
+        const next = this.statusMachine.transitionTo(status);
+        this.eventsBus.setStatus(next);
+    }
+    isAbortError(error) {
+        if (error instanceof Error && /aborted/i.test(error.message))
+            return true;
+        if (error != null && typeof error === "object") {
+            const name = error.name;
+            if (name === "AbortError" || name === "TimeoutError")
+                return true;
+        }
+        return false;
+    }
+}
+exports.Conversation = Conversation;
+//# sourceMappingURL=conversation.class.js.map