@xiaoxiamimengfb/my-opencode-mem 2.12.0

package/dist/services/ai/providers/openai-responses.js

@@ -0,0 +1,182 @@
+import { BaseAIProvider, applySafeExtraParams } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { ToolSchemaConverter } from "../tools/tool-schema.js";
+import { log } from "../../logger.js";
+export class OpenAIResponsesProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "openai-responses";
+    }
+    supportsSession() {
+        return true;
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = this.aiSessionManager.getSession(sessionId, "openai-responses");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "openai-responses",
+                sessionId,
+            });
+        }
+        let conversationId = session.conversationId;
+        let currentPrompt = userPrompt;
+        let iterations = 0;
+        const maxIterations = this.config.maxIterations ?? 5;
+        const iterationTimeout = this.config.iterationTimeout ?? 30000;
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), iterationTimeout);
+            try {
+                const tool = ToolSchemaConverter.toResponsesAPI(toolSchema);
+                const requestBody = {
+                    model: this.config.model,
+                    input: currentPrompt,
+                    tools: [tool],
+                };
+                if (conversationId) {
+                    requestBody.conversation = conversationId;
+                }
+                else {
+                    requestBody.instructions = systemPrompt;
+                }
+                if (this.config.extraParams) {
+                    applySafeExtraParams(requestBody, this.config.extraParams);
+                }
+                const response = await fetch(`${this.config.apiUrl}/responses`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${this.config.apiKey}`,
+                    },
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("OpenAI Responses API error", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    return {
+                        success: false,
+                        error: `API error: ${response.status} - ${errorText}`,
+                        iterations,
+                    };
+                }
+                const data = (await response.json());
+                conversationId = data.conversation || conversationId;
+                if (iterations === 1) {
+                    const userSeq = this.aiSessionManager.getLastSequence(session.id) + 1;
+                    this.aiSessionManager.addMessage({
+                        aiSessionId: session.id,
+                        sequence: userSeq,
+                        role: "user",
+                        content: userPrompt,
+                    });
+                }
+                const toolCall = this.extractToolCall(data, toolSchema.function.name);
+                if (toolCall) {
+                    this.aiSessionManager.updateSession(sessionId, "openai-responses", {
+                        conversationId,
+                    });
+                    return {
+                        success: true,
+                        data: this.validateResponse(toolCall),
+                        iterations,
+                    };
+                }
+                currentPrompt = this.buildRetryPrompt(data);
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                if (error instanceof Error && error.name === "AbortError") {
+                    return {
+                        success: false,
+                        error: `API request timeout (${this.config.iterationTimeout}ms)`,
+                        iterations,
+                    };
+                }
+                return {
+                    success: false,
+                    error: String(error),
+                    iterations,
+                };
+            }
+        }
+        return {
+            success: false,
+            error: `Max iterations (${this.config.maxIterations}) reached without tool call`,
+            iterations,
+        };
+    }
+    extractToolCall(data, expectedToolName) {
+        if (!data.output || !Array.isArray(data.output)) {
+            return null;
+        }
+        for (const item of data.output) {
+            if (item.type === "function_call" && item.name === expectedToolName) {
+                if (item.arguments) {
+                    try {
+                        const parsed = JSON.parse(item.arguments);
+                        return parsed;
+                    }
+                    catch (error) {
+                        log("Failed to parse function call arguments", {
+                            error: String(error),
+                            toolName: item.name,
+                            arguments: item.arguments,
+                        });
+                        return null;
+                    }
+                }
+                else {
+                    log("Function call found but no arguments", {
+                        toolName: item.name,
+                        callId: item.call_id,
+                    });
+                }
+            }
+        }
+        return null;
+    }
+    buildRetryPrompt(data) {
+        let assistantResponse = "";
+        if (data.output && Array.isArray(data.output)) {
+            for (const item of data.output) {
+                if (item.type === "message" && item.content) {
+                    assistantResponse =
+                        typeof item.content === "string" ? item.content : JSON.stringify(item.content);
+                    break;
+                }
+            }
+        }
+        return `Previous response: ${assistantResponse}\n\nPlease use the save_memories tool to extract and save the memories from the conversation as instructed.`;
+    }
+    validateResponse(data) {
+        if (!data || typeof data !== "object") {
+            throw new Error("Response is not an object");
+        }
+        if (Array.isArray(data)) {
+            throw new Error("Response cannot be an array");
+        }
+        const keys = Object.keys(data);
+        if (keys.length === 0) {
+            throw new Error("Response object is empty");
+        }
+        for (const key of keys) {
+            if (data[key] === undefined || data[key] === null) {
+                throw new Error(`Response field '${key}' is null or undefined`);
+            }
+        }
+        return data;
+    }
+}

package/dist/services/ai/session/ai-session-manager.d.ts

@@ -0,0 +1,21 @@
+import type { AISession, SessionCreateParams, SessionUpdateParams, AIProviderType, AIMessage } from "./session-types.js";
+export declare class AISessionManager {
+    private db;
+    private readonly dbPath;
+    private readonly sessionRetentionMs;
+    constructor();
+    private initDatabase;
+    getSession(sessionId: string, provider: AIProviderType): AISession | null;
+    createSession(params: SessionCreateParams): AISession;
+    updateSession(sessionId: string, provider: AIProviderType, updates: SessionUpdateParams): void;
+    cleanupExpiredSessions(): number;
+    deleteSession(sessionId: string, provider: AIProviderType): void;
+    addMessage(message: Omit<AIMessage, "id" | "createdAt">): void;
+    getMessages(aiSessionId: string): AIMessage[];
+    getLastSequence(aiSessionId: string): number;
+    clearMessages(aiSessionId: string): void;
+    private rowToSession;
+    private rowToMessage;
+}
+export declare const aiSessionManager: AISessionManager;
+//# sourceMappingURL=ai-session-manager.d.ts.map

package/dist/services/ai/session/ai-session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-session-manager.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/session/ai-session-manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,SAAS,EACT,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,SAAS,EACV,MAAM,oBAAoB,CAAC;AAS5B,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,EAAE,CAAe;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAS;;IAS5C,OAAO,CAAC,YAAY;IAyCpB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,SAAS,GAAG,IAAI;IAYzE,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,SAAS;IA2BrD,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IA8B9F,sBAAsB,IAAI,MAAM;IAKhC,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI;IAOhE,UAAU,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,GAAG,WAAW,CAAC,GAAG,IAAI;IAmB9D,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE;IAS7C,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM;IAS5C,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIxC,OAAO,CAAC,YAAY;IAapB,OAAO,CAAC,YAAY;CAarB;AAED,eAAO,MAAM,gBAAgB,kBAAyB,CAAC"}

package/dist/services/ai/session/ai-session-manager.js

@@ -0,0 +1,166 @@
+import { getDatabase } from "../../sqlite/sqlite-bootstrap.js";
+import { join } from "node:path";
+import { connectionManager } from "../../sqlite/connection-manager.js";
+import { CONFIG } from "../../../config.js";
+const Database = getDatabase();
+const AI_SESSIONS_DB_NAME = "ai-sessions.db";
+export class AISessionManager {
+    db;
+    dbPath;
+    sessionRetentionMs;
+    constructor() {
+        this.dbPath = join(CONFIG.storagePath, AI_SESSIONS_DB_NAME);
+        this.db = connectionManager.getConnection(this.dbPath);
+        this.sessionRetentionMs = CONFIG.aiSessionRetentionDays * 24 * 60 * 60 * 1000;
+        this.initDatabase();
+    }
+    initDatabase() {
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS ai_sessions (
+        id TEXT PRIMARY KEY,
+        provider TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        conversation_id TEXT,
+        metadata TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL
+      )
+    `);
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_ai_sessions_session_id ON ai_sessions(session_id)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_ai_sessions_expires_at ON ai_sessions(expires_at)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_ai_sessions_provider ON ai_sessions(provider)");
+        this.db.run(`
+      CREATE TABLE IF NOT EXISTS ai_messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        ai_session_id TEXT NOT NULL,
+        sequence INTEGER NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        tool_calls TEXT,
+        tool_call_id TEXT,
+        content_blocks TEXT,
+        created_at INTEGER NOT NULL,
+        FOREIGN KEY (ai_session_id) REFERENCES ai_sessions(id) ON DELETE CASCADE
+      )
+    `);
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_ai_messages_session ON ai_messages(ai_session_id, sequence)");
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_ai_messages_role ON ai_messages(ai_session_id, role)");
+    }
+    getSession(sessionId, provider) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM ai_sessions 
+      WHERE session_id = ? AND provider = ? AND expires_at > ?
+    `);
+        const row = stmt.get(sessionId, provider, Date.now());
+        if (!row)
+            return null;
+        return this.rowToSession(row);
+    }
+    createSession(params) {
+        const id = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+        const now = Date.now();
+        const expiresAt = now + this.sessionRetentionMs;
+        this.db.run(`
+      INSERT INTO ai_sessions (
+        id, provider, session_id, conversation_id, 
+        metadata, created_at, updated_at, expires_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `, [
+            id,
+            params.provider,
+            params.sessionId,
+            params.conversationId || null,
+            JSON.stringify(params.metadata || {}),
+            now,
+            now,
+            expiresAt,
+        ]);
+        return this.getSession(params.sessionId, params.provider);
+    }
+    updateSession(sessionId, provider, updates) {
+        const fields = [];
+        const values = [];
+        if (updates.conversationId !== undefined) {
+            fields.push("conversation_id = ?");
+            values.push(updates.conversationId);
+        }
+        if (updates.metadata !== undefined) {
+            fields.push("metadata = ?");
+            values.push(JSON.stringify(updates.metadata));
+        }
+        fields.push("updated_at = ?");
+        values.push(Date.now());
+        values.push(sessionId);
+        values.push(provider);
+        this.db.run(`
+      UPDATE ai_sessions 
+      SET ${fields.join(", ")}
+      WHERE session_id = ? AND provider = ?
+    `, values);
+    }
+    cleanupExpiredSessions() {
+        const result = this.db.run(`DELETE FROM ai_sessions WHERE expires_at < ?`, [Date.now()]);
+        return result.changes;
+    }
+    deleteSession(sessionId, provider) {
+        this.db.run(`DELETE FROM ai_sessions WHERE session_id = ? AND provider = ?`, [
+            sessionId,
+            provider,
+        ]);
+    }
+    addMessage(message) {
+        this.db.run(`INSERT INTO ai_messages (
+        ai_session_id, sequence, role, content, 
+        tool_calls, tool_call_id, content_blocks, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+            message.aiSessionId,
+            message.sequence,
+            message.role,
+            message.content,
+            message.toolCalls ? JSON.stringify(message.toolCalls) : null,
+            message.toolCallId || null,
+            message.contentBlocks ? JSON.stringify(message.contentBlocks) : null,
+            Date.now(),
+        ]);
+    }
+    getMessages(aiSessionId) {
+        const stmt = this.db.prepare("SELECT * FROM ai_messages WHERE ai_session_id = ? ORDER BY sequence ASC");
+        const rows = stmt.all(aiSessionId);
+        return rows.map(this.rowToMessage);
+    }
+    getLastSequence(aiSessionId) {
+        const stmt = this.db.prepare("SELECT MAX(sequence) as max_seq FROM ai_messages WHERE ai_session_id = ?");
+        const row = stmt.get(aiSessionId);
+        return row?.max_seq ?? -1;
+    }
+    clearMessages(aiSessionId) {
+        this.db.run("DELETE FROM ai_messages WHERE ai_session_id = ?", [aiSessionId]);
+    }
+    rowToSession(row) {
+        return {
+            id: row.id,
+            provider: row.provider,
+            sessionId: row.session_id,
+            conversationId: row.conversation_id,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            expiresAt: row.expires_at,
+        };
+    }
+    rowToMessage(row) {
+        return {
+            id: row.id,
+            aiSessionId: row.ai_session_id,
+            sequence: row.sequence,
+            role: row.role,
+            content: row.content,
+            toolCalls: row.tool_calls ? JSON.parse(row.tool_calls) : undefined,
+            toolCallId: row.tool_call_id,
+            contentBlocks: row.content_blocks ? JSON.parse(row.content_blocks) : undefined,
+            createdAt: row.created_at,
+        };
+    }
+}
+export const aiSessionManager = new AISessionManager();

package/dist/services/ai/session/session-types.d.ts

@@ -0,0 +1,43 @@
+export type AIProviderType = "openai-chat" | "openai-responses" | "anthropic" | "google-gemini";
+export interface AIMessage {
+    id?: number;
+    aiSessionId: string;
+    sequence: number;
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    toolCallId?: string;
+    contentBlocks?: Array<{
+        type: string;
+        [key: string]: any;
+    }>;
+    createdAt: number;
+}
+export interface AISession {
+    id: string;
+    provider: AIProviderType;
+    sessionId: string;
+    conversationId?: string;
+    metadata?: Record<string, any>;
+    createdAt: number;
+    updatedAt: number;
+    expiresAt: number;
+}
+export interface SessionCreateParams {
+    provider: AIProviderType;
+    sessionId: string;
+    conversationId?: string;
+    metadata?: Record<string, any>;
+}
+export interface SessionUpdateParams {
+    conversationId?: string;
+    metadata?: Record<string, any>;
+}
+//# sourceMappingURL=session-types.d.ts.map

package/dist/services/ai/session/session-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-types.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/session/session-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG,aAAa,GAAG,kBAAkB,GAAG,WAAW,GAAG,eAAe,CAAC;AAEhG,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,KAAK,CAAC;QAChB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,UAAU,CAAC;QACjB,QAAQ,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAE,CAAC;KAC/C,CAAC,CAAC;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,KAAK,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,CAAC,CAAC;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,cAAc,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC"}

package/dist/services/ai/session/session-types.js

@@ -0,0 +1 @@
+export {};

package/dist/services/ai/tools/tool-schema.d.ts

@@ -0,0 +1,41 @@
+export interface ChatCompletionTool {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: string;
+            properties: Record<string, any>;
+            required: string[];
+        };
+    };
+}
+export interface ResponsesAPITool {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: {
+        type: string;
+        properties: Record<string, any>;
+        required: string[];
+    };
+}
+export declare class ToolSchemaConverter {
+    static toResponsesAPI(chatCompletionTool: ChatCompletionTool): ResponsesAPITool;
+    static toAnthropic(chatCompletionTool: ChatCompletionTool): AnthropicTool;
+    static fromChatCompletion(tool: ChatCompletionTool): {
+        chatCompletion: ChatCompletionTool;
+        responsesAPI: ResponsesAPITool;
+        anthropic: AnthropicTool;
+    };
+}
+//# sourceMappingURL=tool-schema.d.ts.map

package/dist/services/ai/tools/tool-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-schema.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/tools/tool-schema.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE;YACV,IAAI,EAAE,MAAM,CAAC;YACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;YAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;SACpB,CAAC;KACH,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChC,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;CACH;AAED,qBAAa,mBAAmB;IAC9B,MAAM,CAAC,cAAc,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,gBAAgB;IAS/E,MAAM,CAAC,WAAW,CAAC,kBAAkB,EAAE,kBAAkB,GAAG,aAAa;IAQzE,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,kBAAkB,GAAG;QACnD,cAAc,EAAE,kBAAkB,CAAC;QACnC,YAAY,EAAE,gBAAgB,CAAC;QAC/B,SAAS,EAAE,aAAa,CAAC;KAC1B;CAOF"}

package/dist/services/ai/tools/tool-schema.js

@@ -0,0 +1,24 @@
+export class ToolSchemaConverter {
+    static toResponsesAPI(chatCompletionTool) {
+        return {
+            type: "function",
+            name: chatCompletionTool.function.name,
+            description: chatCompletionTool.function.description,
+            parameters: chatCompletionTool.function.parameters,
+        };
+    }
+    static toAnthropic(chatCompletionTool) {
+        return {
+            name: chatCompletionTool.function.name,
+            description: chatCompletionTool.function.description,
+            input_schema: chatCompletionTool.function.parameters,
+        };
+    }
+    static fromChatCompletion(tool) {
+        return {
+            chatCompletion: tool,
+            responsesAPI: this.toResponsesAPI(tool),
+            anthropic: this.toAnthropic(tool),
+        };
+    }
+}

package/dist/services/ai/validators/user-profile-validator.d.ts

@@ -0,0 +1,13 @@
+import type { UserProfileData } from "../../user-profile/types.js";
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    data?: UserProfileData;
+}
+export declare class UserProfileValidator {
+    static validate(data: any): ValidationResult;
+    private static validatePreferences;
+    private static validatePatterns;
+    private static validateWorkflows;
+}
+//# sourceMappingURL=user-profile-validator.d.ts.map

package/dist/services/ai/validators/user-profile-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-profile-validator.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/validators/user-profile-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,eAAe,CAAC;CACxB;AAED,qBAAa,oBAAoB;IAC/B,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,GAAG,gBAAgB;IAsC5C,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA6BlC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAqB/B,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAsBjC"}

package/dist/services/ai/validators/user-profile-validator.js

@@ -0,0 +1,111 @@
+export class UserProfileValidator {
+    static validate(data) {
+        const errors = [];
+        if (!data || typeof data !== "object") {
+            return { valid: false, errors: ["Response is not an object"] };
+        }
+        if (Array.isArray(data)) {
+            return { valid: false, errors: ["Response cannot be an array"] };
+        }
+        const keys = Object.keys(data);
+        if (keys.length === 0) {
+            return { valid: false, errors: ["Response object is empty"] };
+        }
+        for (const key of keys) {
+            if (data[key] === undefined || data[key] === null) {
+                errors.push(`Field '${key}' is null or undefined`);
+            }
+        }
+        if (errors.length > 0) {
+            return { valid: false, errors };
+        }
+        if (data.preferences) {
+            const prefErrors = this.validatePreferences(data.preferences);
+            errors.push(...prefErrors);
+        }
+        if (data.patterns) {
+            const patternErrors = this.validatePatterns(data.patterns);
+            errors.push(...patternErrors);
+        }
+        if (data.workflows) {
+            const workflowErrors = this.validateWorkflows(data.workflows);
+            errors.push(...workflowErrors);
+        }
+        if (errors.length > 0) {
+            return { valid: false, errors };
+        }
+        return { valid: true, errors: [], data: data };
+    }
+    static validatePreferences(preferences) {
+        const errors = [];
+        if (!Array.isArray(preferences)) {
+            return ["preferences must be an array"];
+        }
+        for (let i = 0; i < preferences.length; i++) {
+            const pref = preferences[i];
+            if (!pref || typeof pref !== "object") {
+                errors.push(`preferences[${i}] is not an object`);
+                continue;
+            }
+            if (!pref.category || typeof pref.category !== "string") {
+                errors.push(`preferences[${i}].category is missing or invalid`);
+            }
+            if (!pref.description || typeof pref.description !== "string") {
+                errors.push(`preferences[${i}].description is missing or invalid`);
+            }
+            if (typeof pref.confidence !== "number") {
+                errors.push(`preferences[${i}].confidence is missing or invalid`);
+            }
+            if (!Array.isArray(pref.evidence)) {
+                errors.push(`preferences[${i}].evidence must be an array`);
+            }
+            else if (pref.evidence.length === 0) {
+                errors.push(`preferences[${i}].evidence cannot be empty`);
+            }
+        }
+        return errors;
+    }
+    static validatePatterns(patterns) {
+        const errors = [];
+        if (!Array.isArray(patterns)) {
+            return ["patterns must be an array"];
+        }
+        for (let i = 0; i < patterns.length; i++) {
+            const pattern = patterns[i];
+            if (!pattern || typeof pattern !== "object") {
+                errors.push(`patterns[${i}] is not an object`);
+                continue;
+            }
+            if (!pattern.category || typeof pattern.category !== "string") {
+                errors.push(`patterns[${i}].category is missing or invalid`);
+            }
+            if (!pattern.description || typeof pattern.description !== "string") {
+                errors.push(`patterns[${i}].description is missing or invalid`);
+            }
+        }
+        return errors;
+    }
+    static validateWorkflows(workflows) {
+        const errors = [];
+        if (!Array.isArray(workflows)) {
+            return ["workflows must be an array"];
+        }
+        for (let i = 0; i < workflows.length; i++) {
+            const workflow = workflows[i];
+            if (!workflow || typeof workflow !== "object") {
+                errors.push(`workflows[${i}] is not an object`);
+                continue;
+            }
+            if (!workflow.description || typeof workflow.description !== "string") {
+                errors.push(`workflows[${i}].description is missing or invalid`);
+            }
+            if (!Array.isArray(workflow.steps)) {
+                errors.push(`workflows[${i}].steps must be an array`);
+            }
+            else if (workflow.steps.length === 0) {
+                errors.push(`workflows[${i}].steps cannot be empty`);
+            }
+        }
+        return errors;
+    }
+}