@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.74

package/dist/boxing/box.types.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Boxing domain types — Box/Thread/Context types for SDK boxing module.
+ */
 export interface BoxRow {
     id: string;
     thread_id: string;
@@ -84,3 +87,4 @@ export interface CreateBoxParams {
     sourceTokens: number;
     summaryTokens?: number | null;
 }
+//# sourceMappingURL=box.types.d.ts.map

package/dist/boxing/box.types.js

@@ -1,3 +1,6 @@
 "use strict";
+/**
+ * Boxing domain types — Box/Thread/Context types for SDK boxing module.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=box.types.js.map

package/dist/boxing/context-builder.d.ts

@@ -1,8 +1,7 @@
-import type { ITaskReader, ITokenizer } from './box-storage.interface';
-import type { BoxResponse, ContextBuildParams, ContextBuildResponse } from './box.types';
-export interface IBoxServiceReader {
-    listBoxes(threadId: string): {
-        boxes: BoxResponse[];
-    };
-}
+/**
+ * buildContext() — builds hot/warm context windows from thread messages and box summaries.
+ */
+import type { IBoxServiceReader, ITaskReader, ITokenizer } from './box-storage.interface';
+import type { ContextBuildParams, ContextBuildResponse } from './box.types';
 export declare function buildContext(threadId: string, taskReader: ITaskReader, boxService: IBoxServiceReader, params: ContextBuildParams, tokenizer: ITokenizer): ContextBuildResponse;
+//# sourceMappingURL=context-builder.d.ts.map

package/dist/boxing/context-builder.js

@@ -1,4 +1,7 @@
 "use strict";
+/**
+ * buildContext() — builds hot/warm context windows from thread messages and box summaries.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildContext = buildContext;
 function buildContext(threadId, taskReader, boxService, params, tokenizer) {

package/dist/client/CrewxClient.d.ts

@@ -0,0 +1,65 @@
+/**
+ * CrewxClient — Browser client for CrewX SDK.
+ *
+ * Communicates with a server running CrewX SDK via HTTP.
+ * Handles the Client-Intercept pattern automatically:
+ *   registerTool() + query() — that's it.
+ *
+ * @example
+ * ```ts
+ * import { CrewxClient } from '@crewx/sdk/client';
+ *
+ * const crewx = new CrewxClient('http://localhost:3000');
+ * crewx.registerTool('browser_storage_read', {
+ *   execute: async ({ key }) => localStorage.getItem(key),
+ * });
+ *
+ * const result = await crewx.query('assistant', 'read my settings');
+ * console.log(result.data);
+ * ```
+ */
+export interface ClientToolDefinition {
+    description?: string;
+    parameters?: Record<string, unknown>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
+}
+export interface QueryCallbacks {
+    /** Called when the agent invokes a client tool. */
+    onToolCall?: (call: {
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+    }) => void;
+}
+export interface QueryResponse {
+    status: string;
+    data?: string;
+    toolCall?: {
+        toolCallId: string;
+        toolName: string;
+        args: Record<string, unknown>;
+    };
+    threadId?: string;
+    error?: {
+        message: string;
+    };
+}
+export declare class CrewxClient {
+    private readonly baseUrl;
+    private readonly tools;
+    constructor(baseUrl: string);
+    /**
+     * Register a browser-side tool.
+     * When the server agent calls a tool with this name (and no server-side execute),
+     * CrewxClient automatically runs it locally and sends the result back.
+     */
+    registerTool(name: string, definition: ClientToolDefinition): void;
+    /**
+     * Send a message to an agent.
+     * The requires_action loop is handled automatically — if the agent calls a
+     * client tool, CrewxClient executes it locally and continues the conversation.
+     */
+    query(agent: string, message: string, callbacks?: QueryCallbacks): Promise<QueryResponse>;
+    private _post;
+}
+//# sourceMappingURL=CrewxClient.d.ts.map

package/dist/client/CrewxClient.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * CrewxClient — Browser client for CrewX SDK.
+ *
+ * Communicates with a server running CrewX SDK via HTTP.
+ * Handles the Client-Intercept pattern automatically:
+ *   registerTool() + query() — that's it.
+ *
+ * @example
+ * ```ts
+ * import { CrewxClient } from '@crewx/sdk/client';
+ *
+ * const crewx = new CrewxClient('http://localhost:3000');
+ * crewx.registerTool('browser_storage_read', {
+ *   execute: async ({ key }) => localStorage.getItem(key),
+ * });
+ *
+ * const result = await crewx.query('assistant', 'read my settings');
+ * console.log(result.data);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewxClient = void 0;
+class CrewxClient {
+    baseUrl;
+    tools = new Map();
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    /**
+     * Register a browser-side tool.
+     * When the server agent calls a tool with this name (and no server-side execute),
+     * CrewxClient automatically runs it locally and sends the result back.
+     */
+    registerTool(name, definition) {
+        this.tools.set(name, definition);
+    }
+    /**
+     * Send a message to an agent.
+     * The requires_action loop is handled automatically — if the agent calls a
+     * client tool, CrewxClient executes it locally and continues the conversation.
+     */
+    async query(agent, message, callbacks) {
+        let response = await this._post('/api/chat', { agent, message });
+        while (response.status === 'requires_action') {
+            const { toolCall, threadId } = response;
+            if (!toolCall)
+                break;
+            const tool = this.tools.get(toolCall.toolName);
+            if (callbacks?.onToolCall) {
+                callbacks.onToolCall(toolCall);
+            }
+            let toolResult;
+            if (tool?.execute) {
+                try {
+                    const raw = await tool.execute(toolCall.args);
+                    toolResult = typeof raw === 'string' ? raw : JSON.stringify(raw);
+                }
+                catch (err) {
+                    toolResult = `Error: ${err.message}`;
+                }
+            }
+            else {
+                toolResult = `Error: No client handler for tool "${toolCall.toolName}"`;
+            }
+            response = await this._post('/api/chat/continue', {
+                threadId,
+                toolCallId: toolCall.toolCallId,
+                result: toolResult,
+            });
+        }
+        return response;
+    }
+    async _post(path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        return res.json();
+    }
+}
+exports.CrewxClient = CrewxClient;
+//# sourceMappingURL=CrewxClient.js.map

package/dist/client/index.d.ts

@@ -0,0 +1,3 @@
+export { CrewxClient } from './CrewxClient.js';
+export type { ClientToolDefinition, QueryCallbacks, QueryResponse } from './CrewxClient.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewxClient = void 0;
+var CrewxClient_js_1 = require("./CrewxClient.js");
+Object.defineProperty(exports, "CrewxClient", { enumerable: true, get: function () { return CrewxClient_js_1.CrewxClient; } });
+//# sourceMappingURL=index.js.map

package/dist/config/loader.browser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Browser-safe YAML config loader.
+ * Only parseYamlContent — no file I/O.
+ */
+import type { CrewxProjectConfig } from '../types/index.js';
+export declare class ConfigLoadError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Parse YAML string into a validated CrewxProjectConfig.
+ */
+export declare function parseYamlContent(yamlString: string): CrewxProjectConfig;
+//# sourceMappingURL=loader.browser.d.ts.map

package/dist/config/loader.browser.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Browser-safe YAML config loader.
+ * Only parseYamlContent — no file I/O.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoadError = void 0;
+exports.parseYamlContent = parseYamlContent;
+const js_yaml_1 = require("js-yaml");
+const index_js_1 = require("../types/index.js");
+class ConfigLoadError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'ConfigLoadError';
+    }
+}
+exports.ConfigLoadError = ConfigLoadError;
+/**
+ * Parse YAML string into a validated CrewxProjectConfig.
+ */
+function parseYamlContent(yamlString) {
+    if (!yamlString || typeof yamlString !== 'string' || !yamlString.trim()) {
+        throw new ConfigLoadError('YAML content must be a non-empty string');
+    }
+    let raw;
+    try {
+        raw = (0, js_yaml_1.load)(yamlString);
+    }
+    catch (err) {
+        throw new ConfigLoadError(`YAML parse error: ${err.message}`, err);
+    }
+    const normalized = normalizeRaw(raw);
+    const result = index_js_1.CrewxProjectConfigSchema.safeParse(normalized);
+    if (!result.success) {
+        throw new ConfigLoadError(`Config validation error: ${result.error.message}`);
+    }
+    return result.data;
+}
+function normalizeRaw(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return { agents: [] };
+    }
+    const obj = raw;
+    if (obj.agents && typeof obj.agents === 'object' && !Array.isArray(obj.agents)) {
+        const agentsMap = obj.agents;
+        const agentsArray = Object.entries(agentsMap).map(([id, cfg]) => {
+            const agentCfg = (cfg && typeof cfg === 'object' ? cfg : {});
+            return { id, ...agentCfg };
+        });
+        return { ...obj, agents: agentsArray };
+    }
+    if (!obj.agents) {
+        return { ...obj, agents: [] };
+    }
+    return obj;
+}
+//# sourceMappingURL=loader.browser.js.map

package/dist/config/loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * YAML configuration loader for CrewX projects.
+ * Reads crewx.yaml and validates it with Zod schema.
+ */
+import type { CrewxProjectConfig } from '../types';
+export declare class ConfigLoadError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Parse YAML string into a validated CrewxProjectConfig.
+ * Converts the agents record (keyed by id) into an array.
+ */
+export declare function parseYamlContent(yamlString: string): CrewxProjectConfig;
+/**
+ * Load and parse crewx.yaml from a file path.
+ */
+export declare function loadYamlFile(filePath: string): CrewxProjectConfig;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * YAML configuration loader for CrewX projects.
+ * Reads crewx.yaml and validates it with Zod schema.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoadError = void 0;
+exports.parseYamlContent = parseYamlContent;
+exports.loadYamlFile = loadYamlFile;
+const js_yaml_1 = require("js-yaml");
+const fs_1 = require("fs");
+const types_1 = require("../types");
+class ConfigLoadError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = 'ConfigLoadError';
+    }
+}
+exports.ConfigLoadError = ConfigLoadError;
+/**
+ * Parse YAML string into a validated CrewxProjectConfig.
+ * Converts the agents record (keyed by id) into an array.
+ */
+function parseYamlContent(yamlString) {
+    if (!yamlString || typeof yamlString !== 'string' || !yamlString.trim()) {
+        throw new ConfigLoadError('YAML content must be a non-empty string');
+    }
+    let raw;
+    try {
+        raw = (0, js_yaml_1.load)(yamlString);
+    }
+    catch (err) {
+        throw new ConfigLoadError(`YAML parse error: ${err.message}`, err);
+    }
+    // Normalize agents: YAML has agents as a map (Record<id, config>),
+    // but our type uses an array with 'id' field.
+    const normalized = normalizeRaw(raw);
+    const result = types_1.CrewxProjectConfigSchema.safeParse(normalized);
+    if (!result.success) {
+        throw new ConfigLoadError(`Config validation error: ${result.error.message}`);
+    }
+    return result.data;
+}
+/**
+ * Load and parse crewx.yaml from a file path.
+ */
+function loadYamlFile(filePath) {
+    let content;
+    try {
+        content = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch (err) {
+        throw new ConfigLoadError(`Cannot read file: ${filePath}`, err);
+    }
+    return parseYamlContent(content);
+}
+/**
+ * Normalize raw YAML output:
+ * - agents map (Record<id, agentConfig>) → agents array ([{ id, ...agentConfig }])
+ */
+function normalizeRaw(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return { agents: [] };
+    }
+    const obj = raw;
+    // Gather agents as array (support map form and array form)
+    let agentsArray;
+    if (obj.agents && typeof obj.agents === 'object' && !Array.isArray(obj.agents)) {
+        const agentsMap = obj.agents;
+        agentsArray = Object.entries(agentsMap).map(([id, cfg]) => {
+            const agentCfg = (cfg && typeof cfg === 'object' ? cfg : {});
+            return { id, ...agentCfg };
+        });
+    }
+    else if (Array.isArray(obj.agents)) {
+        agentsArray = obj.agents;
+    }
+    else {
+        return { ...obj, agents: [] };
+    }
+    // Normalize inline.provider → top-level provider (fallback for cross-repo yaml compat)
+    const normalizedAgents = agentsArray.map(agent => {
+        if (agent.provider === undefined && agent.inline && typeof agent.inline === 'object') {
+            const inline = agent.inline;
+            if (inline.provider !== undefined) {
+                return { ...agent, provider: inline.provider };
+            }
+        }
+        return agent;
+    });
+    return { ...obj, agents: normalizedAgents };
+}
+//# sourceMappingURL=loader.js.map

package/dist/conversation/index.d.ts

@@ -1,3 +1,5 @@
-export * from './conversation-history.interface';
-export * from './conversation-config';
-export * from './conversation-storage.service';
+export * from './types.js';
+export { SqliteConversationProvider } from './sqlite-provider.js';
+export { toTaskReader } from './to-task-reader.js';
+export { toTemplateMessages } from './to-template-messages.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/conversation/index.js

@@ -14,7 +14,12 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./conversation-history.interface"), exports);
-__exportStar(require("./conversation-config"), exports);
-__exportStar(require("./conversation-storage.service"), exports);
+exports.toTemplateMessages = exports.toTaskReader = exports.SqliteConversationProvider = void 0;
+__exportStar(require("./types.js"), exports);
+var sqlite_provider_js_1 = require("./sqlite-provider.js");
+Object.defineProperty(exports, "SqliteConversationProvider", { enumerable: true, get: function () { return sqlite_provider_js_1.SqliteConversationProvider; } });
+var to_task_reader_js_1 = require("./to-task-reader.js");
+Object.defineProperty(exports, "toTaskReader", { enumerable: true, get: function () { return to_task_reader_js_1.toTaskReader; } });
+var to_template_messages_js_1 = require("./to-template-messages.js");
+Object.defineProperty(exports, "toTemplateMessages", { enumerable: true, get: function () { return to_template_messages_js_1.toTemplateMessages; } });
 //# sourceMappingURL=index.js.map

package/dist/conversation/sqlite-provider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SqliteConversationProvider — reads/writes conversation history from ~/.crewx/crewx.db.
+ *
+ * Security:
+ * - SEC-1: SELECT columns are explicitly whitelisted (no rendered_prompt, command, logs, metadata).
+ * - SEC-2: All queries use parameterized bindings (? placeholders).
+ * - Writes target `threads` table ONLY — `tasks` table writes are owned by SqliteTracingPlugin.
+ */
+import type { ConversationThread, FetchHistoryOptions, IConversationHistoryProvider, Platform } from './types';
+export declare class SqliteConversationProvider implements IConversationHistoryProvider {
+    private db;
+    constructor(dbPath?: string);
+    private init;
+    ensureThread(threadId: string, platform: Platform, workspaceId?: string): Promise<void>;
+    fetchHistory(threadId: string, options?: FetchHistoryOptions): Promise<ConversationThread>;
+    saveUserMessage(threadId: string, text: string, _userId?: string, _metadata?: Record<string, unknown>): Promise<void>;
+    saveAssistantMessage(threadId: string, text: string, _agentId: string, _metadata?: Record<string, unknown>): Promise<void>;
+    close(): void;
+    private rowsToMessages;
+}
+//# sourceMappingURL=sqlite-provider.d.ts.map

package/dist/conversation/sqlite-provider.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * SqliteConversationProvider — reads/writes conversation history from ~/.crewx/crewx.db.
+ *
+ * Security:
+ * - SEC-1: SELECT columns are explicitly whitelisted (no rendered_prompt, command, logs, metadata).
+ * - SEC-2: All queries use parameterized bindings (? placeholders).
+ * - Writes target `threads` table ONLY — `tasks` table writes are owned by SqliteTracingPlugin.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteConversationProvider = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = require("path");
+const os_1 = require("os");
+const THREADS_DDL = `
+  CREATE TABLE IF NOT EXISTS threads (
+    id TEXT PRIMARY KEY,
+    workspace_id TEXT,
+    platform TEXT NOT NULL DEFAULT 'cli',
+    title TEXT,
+    first_message TEXT,
+    last_message TEXT,
+    message_count INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    metadata TEXT
+  )
+`;
+const COLUMNS = [
+    'id', 'thread_id', 'prompt', 'result', 'started_at',
+    'trace_id', 'status', 'parent_task_id', 'agent_id',
+];
+function stripCliNoise(content) {
+    let cleaned = content.replace(/<conversation_history[^>]*>[\s\S]*?<\/conversation_history>/g, '');
+    const lines = cleaned.split('\n');
+    const cleanLines = lines.filter(line => {
+        if (line.startsWith('Loaded ') && line.includes('layouts from'))
+            return false;
+        if (line.includes('[dotenv@'))
+            return false;
+        if (line.includes('[Nest]') && line.includes('DEBUG'))
+            return false;
+        if (line.startsWith('Registered custom layout:'))
+            return false;
+        if (line.startsWith('Updated custom layout:'))
+            return false;
+        return true;
+    });
+    return cleanLines.join('\n').trim();
+}
+function cleanResult(raw) {
+    if (!raw)
+        return '';
+    let content = raw;
+    try {
+        const parsed = JSON.parse(content);
+        if (Array.isArray(parsed)) {
+            content = parsed
+                .filter((c) => c?.type === 'text' && c?.text)
+                .map((c) => c.text)
+                .join('\n');
+        }
+        else if (parsed && typeof parsed === 'object' && parsed.result !== undefined) {
+            content = parsed.result || '';
+        }
+    }
+    catch {
+        content = stripCliNoise(content);
+    }
+    return content;
+}
+class SqliteConversationProvider {
+    db;
+    constructor(dbPath) {
+        const resolved = dbPath ?? (0, path_1.join)((0, os_1.homedir)(), '.crewx', 'crewx.db');
+        this.db = new better_sqlite3_1.default(resolved);
+        this.init();
+    }
+    init() {
+        this.db.pragma('journal_mode = WAL');
+        this.db.exec(THREADS_DDL);
+    }
+    async ensureThread(threadId, platform, workspaceId) {
+        const row = this.db.prepare('SELECT platform FROM threads WHERE id = ?').get(threadId);
+        if (row) {
+            if (row.platform !== platform) {
+                throw new Error(`Thread '${threadId}' already exists with platform '${row.platform}' — cannot change to '${platform}' (platform is immutable)`);
+            }
+            // Backfill workspace_id if missing on existing thread (WI-CONV-003)
+            if (workspaceId) {
+                this.db.prepare('UPDATE threads SET workspace_id = COALESCE(workspace_id, ?) WHERE id = ?').run(workspaceId, threadId);
+            }
+            return;
+        }
+        const now = new Date().toISOString();
+        this.db.prepare('INSERT INTO threads (id, platform, workspace_id, message_count, created_at, updated_at) VALUES (?, ?, ?, 0, ?, ?)').run(threadId, platform, workspaceId ?? null, now, now);
+    }
+    async fetchHistory(threadId, options) {
+        const limit = options?.limit ?? 100;
+        const conditions = [
+            'thread_id = ?',
+            '(parent_task_id IS NULL OR parent_task_id = \'\')',
+            '(status IN (\'done\', \'completed\', \'success\') OR status IS NULL)',
+        ];
+        const params = [threadId];
+        if (options?.currentTraceId) {
+            conditions.push('trace_id != ?');
+            params.push(options.currentTraceId);
+        }
+        const where = conditions.join(' AND ');
+        const selectCols = COLUMNS.join(', ');
+        const sql = `SELECT ${selectCols} FROM tasks WHERE ${where} ORDER BY started_at ASC LIMIT ?`;
+        params.push(limit);
+        const rows = this.db.prepare(sql).all(...params);
+        const threadRow = this.db.prepare('SELECT platform, title, first_message, last_message, message_count, updated_at FROM threads WHERE id = ?').get(threadId);
+        const platform = threadRow?.platform ?? 'cli';
+        const messages = this.rowsToMessages(rows);
+        return {
+            threadId,
+            platform: platform,
+            messages,
+            metadata: {
+                title: threadRow?.title ?? undefined,
+                firstMessage: threadRow?.first_message ?? undefined,
+                lastMessage: threadRow?.last_message ?? undefined,
+                messageCount: threadRow?.message_count ?? 0,
+                updatedAt: threadRow?.updated_at ? new Date(threadRow.updated_at).getTime() : undefined,
+            },
+        };
+    }
+    async saveUserMessage(threadId, text, _userId, _metadata) {
+        const now = new Date().toISOString();
+        this.db.prepare(`UPDATE threads
+       SET first_message = COALESCE(first_message, ?),
+           last_message = ?,
+           message_count = message_count + 1,
+           updated_at = ?
+       WHERE id = ?`).run(text, text, now, threadId);
+    }
+    async saveAssistantMessage(threadId, text, _agentId, _metadata) {
+        const now = new Date().toISOString();
+        this.db.prepare(`UPDATE threads
+       SET last_message = ?,
+           updated_at = ?
+       WHERE id = ?`).run(text, now, threadId);
+    }
+    close() {
+        this.db.close();
+    }
+    rowsToMessages(rows) {
+        const messages = [];
+        for (const row of rows) {
+            if (row.prompt) {
+                messages.push({
+                    id: `${row.id}-user`,
+                    text: row.prompt,
+                    isAssistant: false,
+                    timestamp: new Date(row.started_at).getTime(),
+                });
+            }
+            const cleaned = cleanResult(row.result);
+            if (cleaned) {
+                messages.push({
+                    id: `${row.id}-assistant`,
+                    text: cleaned,
+                    isAssistant: true,
+                    timestamp: new Date(row.started_at).getTime(),
+                });
+            }
+        }
+        return messages;
+    }
+}
+exports.SqliteConversationProvider = SqliteConversationProvider;
+//# sourceMappingURL=sqlite-provider.js.map

package/dist/conversation/to-task-reader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * toTaskReader — adapter from ConversationThread to boxing ITaskReader.
+ *
+ * SQ3 invariant:
+ *   The returned ThreadMessage[] is structured as [user, assistant, user, assistant, ...]
+ *   where each task produces exactly 2 consecutive elements (user first, then assistant).
+ *   context-builder.ts:31~42 pairs messages as [i, i+1], so violating this invariant
+ *   would corrupt context. Tasks without assistants (failed/running) are already
+ *   filtered by fetchHistory — this adapter performs no additional filtering.
+ */
+import type { ConversationThread } from './types';
+import type { ITaskReader } from '../boxing/box-storage.interface';
+export declare function toTaskReader(thread: ConversationThread): ITaskReader;
+//# sourceMappingURL=to-task-reader.d.ts.map

package/dist/conversation/to-task-reader.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * toTaskReader — adapter from ConversationThread to boxing ITaskReader.
+ *
+ * SQ3 invariant:
+ *   The returned ThreadMessage[] is structured as [user, assistant, user, assistant, ...]
+ *   where each task produces exactly 2 consecutive elements (user first, then assistant).
+ *   context-builder.ts:31~42 pairs messages as [i, i+1], so violating this invariant
+ *   would corrupt context. Tasks without assistants (failed/running) are already
+ *   filtered by fetchHistory — this adapter performs no additional filtering.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTaskReader = toTaskReader;
+function toTaskReader(thread) {
+    const messages = thread.messages.map((msg) => ({
+        id: msg.id,
+        role: msg.isAssistant ? 'assistant' : 'user',
+        content: msg.text,
+        timestamp: new Date(msg.timestamp).toISOString(),
+        metadata: msg.metadata ?? null,
+    }));
+    return {
+        getThreadMessages(_threadId) {
+            return messages;
+        },
+    };
+}
+//# sourceMappingURL=to-task-reader.js.map