@haisto/opencode-mem 2.14.3-beta.0

package/dist/services/ai/opencode-provider.js

@@ -0,0 +1,92 @@
+/**
+ * SDK-based structured output via opencode v2 session.prompt.
+ *
+ * Replaces the old auth.json/OAuth-juggling flow. Instead of forging requests
+ * to provider HTTP endpoints ourselves, we delegate to the running opencode
+ * server: it already owns the user's auth (any provider, including
+ * github-copilot personal/business), token refresh, and provider routing.
+ *
+ * Per call we create a transient session, prompt with a JSON schema, then
+ * delete the session so it does not pollute the user's TUI session list.
+ */
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
+let _connectedProviders = new Set();
+let _v2Client;
+export function setConnectedProviders(providers) {
+    _connectedProviders = new Set(providers);
+}
+export function isProviderConnected(providerName) {
+    return _connectedProviders.has(providerName);
+}
+export function setV2Client(client) {
+    _v2Client = client;
+}
+export function getV2Client() {
+    return _v2Client;
+}
+export function createV2Client(serverUrl) {
+    const baseUrl = typeof serverUrl === "string" ? serverUrl : serverUrl.toString();
+    return createOpencodeClient({ baseUrl });
+}
+/**
+ * Generate one structured-output completion via opencode's v2 API.
+ * Throws on: session.create failure, prompt failure, AssistantMessage.error
+ * (StructuredOutputError / ApiError / ...), missing `info.structured`,
+ * or final Zod validation failure.
+ */
+export async function generateStructuredOutput(opts) {
+    const { client, providerID, modelID, systemPrompt, userPrompt, schema, directory, retryCount } = opts;
+    // zod v4 exposes JSON Schema export natively (instance `.toJSONSchema()`
+    // and global `z.toJSONSchema()`); we prefer instance, fall back to global.
+    // This avoids pulling in a separate `zod-to-json-schema` dependency.
+    const jsonSchema = schema.toJSONSchema?.() ?? (await import("zod")).z.toJSONSchema(schema);
+    const created = await client.session.create({
+        title: "opencode-mem capture",
+        ...(directory ? { directory } : {}),
+    });
+    const sessionID = created?.data?.id;
+    if (!sessionID) {
+        throw new Error("opencode-mem: session.create returned no session id; cannot generate structured output");
+    }
+    try {
+        const promptResult = await client.session.prompt({
+            sessionID,
+            ...(directory ? { directory } : {}),
+            model: { providerID, modelID },
+            system: systemPrompt,
+            parts: [{ type: "text", text: userPrompt }],
+            format: {
+                type: "json_schema",
+                schema: jsonSchema,
+                ...(retryCount !== undefined ? { retryCount } : {}),
+            },
+            noReply: true,
+        });
+        const data = promptResult.data;
+        const info = data?.info;
+        if (!info) {
+            throw new Error("opencode-mem: prompt response missing `info`");
+        }
+        if (info.error) {
+            const msg = info.error.data?.message ?? info.error.name;
+            throw new Error(`opencode-mem: opencode reported ${info.error.name}: ${msg}`);
+        }
+        if (info.structured === undefined || info.structured === null) {
+            throw new Error("opencode-mem: opencode returned no structured output (info.structured was empty)");
+        }
+        return schema.parse(info.structured);
+    }
+    finally {
+        // Best-effort: leaving a transient session behind is cosmetic, not
+        // worth failing a successful capture if cleanup itself errors.
+        try {
+            await client.session.delete({
+                sessionID,
+                ...(directory ? { directory } : {}),
+            });
+        }
+        catch {
+            // intentionally swallowed
+        }
+    }
+}

package/dist/services/ai/provider-config.d.ts

@@ -0,0 +1,17 @@
+import type { ProviderConfig } from "./providers/base-provider.js";
+interface MemoryProviderRuntimeConfig {
+    memoryModel?: string;
+    memoryApiUrl?: string;
+    memoryApiKey?: string;
+    memoryTemperature?: number | false;
+    memoryExtraParams?: Record<string, unknown>;
+    autoCaptureMaxIterations?: number;
+    autoCaptureIterationTimeout?: number;
+}
+interface ProviderConfigOverrides {
+    maxIterations?: number;
+    iterationTimeout?: number;
+}
+export declare function buildMemoryProviderConfig(config: MemoryProviderRuntimeConfig, overrides?: ProviderConfigOverrides): ProviderConfig;
+export {};
+//# sourceMappingURL=provider-config.d.ts.map

package/dist/services/ai/provider-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-config.d.ts","sourceRoot":"","sources":["../../../src/services/ai/provider-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,UAAU,2BAA2B;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACnC,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,2BAA2B,CAAC,EAAE,MAAM,CAAC;CACtC;AAED,UAAU,uBAAuB;IAC/B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,2BAA2B,EACnC,SAAS,GAAE,uBAA4B,GACtC,cAAc,CAchB"}

package/dist/services/ai/provider-config.js

@@ -0,0 +1,14 @@
+export function buildMemoryProviderConfig(config, overrides = {}) {
+    if (!config.memoryModel || !config.memoryApiUrl) {
+        throw new Error("External API not configured for memory provider");
+    }
+    return {
+        model: config.memoryModel,
+        apiUrl: config.memoryApiUrl,
+        apiKey: config.memoryApiKey,
+        memoryTemperature: config.memoryTemperature,
+        extraParams: config.memoryExtraParams,
+        maxIterations: overrides.maxIterations ?? config.autoCaptureMaxIterations,
+        iterationTimeout: overrides.iterationTimeout ?? config.autoCaptureIterationTimeout,
+    };
+}

package/dist/services/ai/providers/anthropic-messages.d.ts

@@ -0,0 +1,12 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { type ChatCompletionTool } from "../tools/tool-schema.js";
+export declare class AnthropicMessagesProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+    private extractToolUse;
+}
+//# sourceMappingURL=anthropic-messages.d.ts.map

package/dist/services/ai/providers/anthropic-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anthropic-messages.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/anthropic-messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAuB,KAAK,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AA4BvF,qBAAa,yBAA0B,SAAQ,cAAc;IAC3D,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,gBAAgB;IAK3D,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAIpB,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IAoL1B,OAAO,CAAC,cAAc;CAavB"}

package/dist/services/ai/providers/anthropic-messages.js

@@ -0,0 +1,184 @@
+import { BaseAIProvider } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { ToolSchemaConverter } from "../tools/tool-schema.js";
+import { log } from "../../logger.js";
+import { UserProfileValidator } from "../validators/user-profile-validator.js";
+export class AnthropicMessagesProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "anthropic";
+    }
+    supportsSession() {
+        return true;
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = this.aiSessionManager.getSession(sessionId, "anthropic");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "anthropic",
+                sessionId,
+                metadata: { systemPrompt },
+            });
+        }
+        const storedMessages = this.aiSessionManager.getMessages(session.id);
+        const messages = [];
+        for (const msg of storedMessages) {
+            if (msg.role === "system")
+                continue;
+            const anthropicMsg = {
+                role: msg.role,
+                content: msg.contentBlocks || msg.content,
+            };
+            messages.push(anthropicMsg);
+        }
+        const userSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+        this.aiSessionManager.addMessage({
+            aiSessionId: session.id,
+            sequence: userSequence,
+            role: "user",
+            content: userPrompt,
+        });
+        messages.push({ role: "user", content: 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.toAnthropic(toolSchema);
+                const requestBody = {
+                    model: this.config.model,
+                    max_tokens: this.config.maxTokens ?? 4096,
+                    system: systemPrompt,
+                    messages,
+                    tools: [tool],
+                };
+                const headers = {
+                    "Content-Type": "application/json",
+                    "anthropic-version": "2023-06-01",
+                };
+                if (this.config.apiKey) {
+                    headers["x-api-key"] = this.config.apiKey;
+                }
+                const response = await fetch(`${this.config.apiUrl}/messages`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("Anthropic Messages 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());
+                const assistantSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                this.aiSessionManager.addMessage({
+                    aiSessionId: session.id,
+                    sequence: assistantSequence,
+                    role: "assistant",
+                    content: JSON.stringify(data.content),
+                    contentBlocks: data.content,
+                });
+                messages.push({
+                    role: "assistant",
+                    content: data.content,
+                });
+                const toolUse = this.extractToolUse(data, toolSchema.function.name);
+                if (toolUse) {
+                    try {
+                        const result = UserProfileValidator.validate(toolUse);
+                        if (!result.valid) {
+                            throw new Error(result.errors.join(", "));
+                        }
+                        return {
+                            success: true,
+                            data: result.data,
+                            iterations,
+                        };
+                    }
+                    catch (validationError) {
+                        const errorStack = validationError instanceof Error ? validationError.stack : undefined;
+                        log("Anthropic tool response validation failed", {
+                            error: String(validationError),
+                            stack: errorStack,
+                            errorType: validationError instanceof Error
+                                ? validationError.constructor.name
+                                : typeof validationError,
+                            toolName: toolSchema.function.name,
+                            iteration: iterations,
+                            rawData: JSON.stringify(toolUse).slice(0, 500),
+                        });
+                        return {
+                            success: false,
+                            error: `Validation failed: ${String(validationError)}`,
+                            iterations,
+                        };
+                    }
+                }
+                if (data.stop_reason === "end_turn") {
+                    const retrySequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                    const retryPrompt = "Please use the save_memories tool to extract and save the memories from the conversation as instructed.";
+                    this.aiSessionManager.addMessage({
+                        aiSessionId: session.id,
+                        sequence: retrySequence,
+                        role: "user",
+                        content: retryPrompt,
+                    });
+                    messages.push({ role: "user", content: retryPrompt });
+                }
+                else {
+                    break;
+                }
+            }
+            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 (${maxIterations}) reached without tool use`,
+            iterations,
+        };
+    }
+    extractToolUse(data, expectedToolName) {
+        if (!data.content || !Array.isArray(data.content)) {
+            return null;
+        }
+        for (const block of data.content) {
+            if (block.type === "tool_use" && block.name === expectedToolName && block.input) {
+                return block.input;
+            }
+        }
+        return null;
+    }
+}

package/dist/services/ai/providers/base-provider.d.ts

@@ -0,0 +1,25 @@
+export interface ToolCallResult {
+    success: boolean;
+    data?: any;
+    error?: string;
+    iterations?: number;
+}
+export interface ProviderConfig {
+    model: string;
+    apiUrl: string;
+    apiKey?: string;
+    maxIterations?: number;
+    iterationTimeout?: number;
+    maxTokens?: number;
+    memoryTemperature?: number | false;
+    extraParams?: Record<string, unknown>;
+}
+export declare function applySafeExtraParams(requestBody: Record<string, any>, extraParams: Record<string, unknown>): void;
+export declare abstract class BaseAIProvider {
+    protected config: ProviderConfig;
+    constructor(config: ProviderConfig);
+    abstract executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: any, sessionId: string): Promise<ToolCallResult>;
+    abstract getProviderName(): string;
+    abstract supportsSession(): boolean;
+}
+//# sourceMappingURL=base-provider.d.ts.map

package/dist/services/ai/providers/base-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-provider.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/base-provider.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACvC;AAaD,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,IAAI,CAMN;AAED,8BAAsB,cAAc;IAClC,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;gBAErB,MAAM,EAAE,cAAc;IAIlC,QAAQ,CAAC,eAAe,CACtB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,GAAG,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;IAE1B,QAAQ,CAAC,eAAe,IAAI,MAAM;IAElC,QAAQ,CAAC,eAAe,IAAI,OAAO;CACpC"}

package/dist/services/ai/providers/base-provider.js

@@ -0,0 +1,23 @@
+const PROTECTED_KEYS = new Set([
+    "model",
+    "messages",
+    "tools",
+    "tool_choice",
+    "temperature",
+    "input",
+    "instructions",
+    "conversation",
+]);
+export function applySafeExtraParams(requestBody, extraParams) {
+    for (const [key, value] of Object.entries(extraParams)) {
+        if (!PROTECTED_KEYS.has(key)) {
+            requestBody[key] = value;
+        }
+    }
+}
+export class BaseAIProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+}

package/dist/services/ai/providers/google-gemini.d.ts

@@ -0,0 +1,16 @@
+import { BaseAIProvider, type ToolCallResult } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import type { ChatCompletionTool } from "../tools/tool-schema.js";
+/**
+ * Google Gemini Provider
+ * Supports Google's Gemini models (e.g. gemini-1.5-flash) via Google AI Studio API.
+ */
+export declare class GoogleGeminiProvider extends BaseAIProvider {
+    private aiSessionManager;
+    constructor(config: any, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    private addToolResponse;
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+}
+//# sourceMappingURL=google-gemini.d.ts.map

package/dist/services/ai/providers/google-gemini.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-gemini.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/google-gemini.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAIlE;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,cAAc;IACtD,OAAO,CAAC,gBAAgB,CAAmB;gBAE/B,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,gBAAgB;IAK3D,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAI1B,OAAO,CAAC,eAAe;IA4BjB,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;CA2N3B"}

package/dist/services/ai/providers/google-gemini.js

@@ -0,0 +1,228 @@
+import { BaseAIProvider } from "./base-provider.js";
+import { AISessionManager } from "../session/ai-session-manager.js";
+import { log } from "../../logger.js";
+import { UserProfileValidator } from "../validators/user-profile-validator.js";
+/**
+ * Google Gemini Provider
+ * Supports Google's Gemini models (e.g. gemini-1.5-flash) via Google AI Studio API.
+ */
+export class GoogleGeminiProvider extends BaseAIProvider {
+    aiSessionManager;
+    constructor(config, aiSessionManager) {
+        super(config);
+        this.aiSessionManager = aiSessionManager;
+    }
+    getProviderName() {
+        return "google-gemini";
+    }
+    supportsSession() {
+        return true;
+    }
+    addToolResponse(sessionId, messages, toolCallId, content) {
+        const sequence = this.aiSessionManager.getLastSequence(sessionId) + 1;
+        this.aiSessionManager.addMessage({
+            aiSessionId: sessionId,
+            sequence,
+            role: "tool",
+            content,
+            toolCallId,
+        });
+        // Gemini tool response format
+        messages.push({
+            role: "function",
+            parts: [
+                {
+                    functionResponse: {
+                        name: toolCallId.split(":")[0], // Gemini expects the name of the function
+                        response: JSON.parse(content),
+                    },
+                },
+            ],
+        });
+    }
+    async executeToolCall(systemPrompt, userPrompt, toolSchema, sessionId) {
+        let session = this.aiSessionManager.getSession(sessionId, "google-gemini");
+        if (!session) {
+            session = this.aiSessionManager.createSession({
+                provider: "google-gemini",
+                sessionId,
+            });
+        }
+        const existingMessages = this.aiSessionManager.getMessages(session.id);
+        const contents = [];
+        // System instruction is separate in Gemini API
+        const geminiSystemInstruction = {
+            parts: [{ text: systemPrompt }],
+        };
+        // Convert existing messages to Gemini format
+        for (const msg of existingMessages) {
+            if (msg.role === "system")
+                continue; // Skip system as it's passed separately
+            const role = msg.role === "assistant" ? "model" : "user";
+            const parts = [];
+            if (msg.content) {
+                parts.push({ text: msg.content });
+            }
+            if (msg.toolCalls) {
+                for (const tc of msg.toolCalls) {
+                    parts.push({
+                        functionCall: {
+                            name: tc.function.name,
+                            args: JSON.parse(tc.function.arguments),
+                        },
+                    });
+                }
+            }
+            if (msg.role === "tool") {
+                contents.push({
+                    role: "function",
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: (msg.toolCallId || "").split(":")[0],
+                                response: JSON.parse(msg.content),
+                            },
+                        },
+                    ],
+                });
+                continue;
+            }
+            contents.push({ role, parts });
+        }
+        if (contents.length === 0 || contents[contents.length - 1].role !== "user") {
+            const userSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+            this.aiSessionManager.addMessage({
+                aiSessionId: session.id,
+                sequence: userSequence,
+                role: "user",
+                content: userPrompt,
+            });
+            contents.push({ role: "user", parts: [{ text: userPrompt }] });
+        }
+        let iterations = 0;
+        const maxIterations = this.config.maxIterations ?? 5;
+        const iterationTimeout = this.config.iterationTimeout ?? 30000;
+        // Gemini API expects the tool name as a function declaration
+        const tools = [
+            {
+                functionDeclarations: [
+                    {
+                        name: toolSchema.function.name,
+                        description: toolSchema.function.description,
+                        parameters: toolSchema.function.parameters,
+                    },
+                ],
+            },
+        ];
+        while (iterations < maxIterations) {
+            iterations++;
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), iterationTimeout);
+            try {
+                const baseUrl = this.config.apiUrl || "https://generativelanguage.googleapis.com/v1beta";
+                const url = `${baseUrl}/models/${this.config.model}:generateContent?key=${this.config.apiKey}`;
+                const requestBody = {
+                    contents,
+                    systemInstruction: geminiSystemInstruction,
+                    tools,
+                    toolConfig: {
+                        functionCallingConfig: {
+                            mode: "ANY", // Force function calling
+                            allowedFunctionNames: [toolSchema.function.name],
+                        },
+                    },
+                    generationConfig: {
+                        temperature: this.config.memoryTemperature ?? 0.3,
+                    },
+                };
+                const response = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(requestBody),
+                    signal: controller.signal,
+                });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => response.statusText);
+                    log("Gemini API error", {
+                        provider: this.getProviderName(),
+                        model: this.config.model,
+                        status: response.status,
+                        error: errorText,
+                        iteration: iterations,
+                    });
+                    return {
+                        success: false,
+                        error: `Gemini API error: ${response.status} - ${errorText}`,
+                        iterations,
+                    };
+                }
+                const data = (await response.json());
+                const candidate = data.candidates?.[0];
+                if (!candidate || !candidate.content) {
+                    return { success: false, error: "Invalid Gemini API response format", iterations };
+                }
+                const modelMsg = candidate.content;
+                const assistantSequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                // Map Gemini response back to our internal message format
+                const assistantMsg = {
+                    aiSessionId: session.id,
+                    sequence: assistantSequence,
+                    role: "assistant",
+                    content: "",
+                    toolCalls: [],
+                };
+                for (const part of modelMsg.parts) {
+                    if (part.text)
+                        assistantMsg.content += part.text;
+                    if (part.functionCall) {
+                        assistantMsg.toolCalls.push({
+                            id: `${part.functionCall.name}:${Date.now()}`,
+                            type: "function",
+                            function: {
+                                name: part.functionCall.name,
+                                arguments: JSON.stringify(part.functionCall.args),
+                            },
+                        });
+                    }
+                }
+                this.aiSessionManager.addMessage(assistantMsg);
+                contents.push(modelMsg);
+                if (assistantMsg.toolCalls.length > 0) {
+                    for (const toolCall of assistantMsg.toolCalls) {
+                        if (toolCall.function.name === toolSchema.function.name) {
+                            try {
+                                const parsed = JSON.parse(toolCall.function.arguments);
+                                const result = UserProfileValidator.validate(parsed);
+                                if (!result.valid)
+                                    throw new Error(result.errors.join(", "));
+                                this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: true }));
+                                return { success: true, data: result.data, iterations };
+                            }
+                            catch (validationError) {
+                                const errorMessage = `Validation failed: ${String(validationError)}`;
+                                this.addToolResponse(session.id, contents, toolCall.id, JSON.stringify({ success: false, error: errorMessage }));
+                                return { success: false, error: errorMessage, iterations };
+                            }
+                        }
+                    }
+                }
+                // Retry if no tool call was made
+                const retryPrompt = "Please use the save_memories tool as instructed.";
+                const retrySequence = this.aiSessionManager.getLastSequence(session.id) + 1;
+                this.aiSessionManager.addMessage({
+                    aiSessionId: session.id,
+                    sequence: retrySequence,
+                    role: "user",
+                    content: retryPrompt,
+                });
+                contents.push({ role: "user", parts: [{ text: retryPrompt }] });
+            }
+            catch (error) {
+                clearTimeout(timeout);
+                return { success: false, error: String(error), iterations };
+            }
+        }
+        return { success: false, error: `Max iterations (${maxIterations}) reached`, iterations };
+    }
+}

package/dist/services/ai/providers/openai-chat-completion.d.ts

@@ -0,0 +1,14 @@
+import { BaseAIProvider, type ProviderConfig, type ToolCallResult } from "./base-provider.js";
+import type { AISessionManager } from "../session/ai-session-manager.js";
+import type { AIMessage } from "../session/session-types.js";
+import type { ChatCompletionTool } from "../tools/tool-schema.js";
+export declare class OpenAIChatCompletionProvider extends BaseAIProvider {
+    private readonly aiSessionManager;
+    constructor(config: ProviderConfig, aiSessionManager: AISessionManager);
+    getProviderName(): string;
+    supportsSession(): boolean;
+    private addToolResponse;
+    protected filterIncompleteToolCallSequences(messages: AIMessage[]): AIMessage[];
+    executeToolCall(systemPrompt: string, userPrompt: string, toolSchema: ChatCompletionTool, sessionId: string): Promise<ToolCallResult>;
+}
+//# sourceMappingURL=openai-chat-completion.d.ts.map

package/dist/services/ai/providers/openai-chat-completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-chat-completion.d.ts","sourceRoot":"","sources":["../../../../src/services/ai/providers/openai-chat-completion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,KAAK,cAAc,EACnB,KAAK,cAAc,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAgElE,qBAAa,4BAA6B,SAAQ,cAAc;IAC9D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;gBAExC,MAAM,EAAE,cAAc,EAAE,gBAAgB,EAAE,gBAAgB;IAKtE,eAAe,IAAI,MAAM;IAIzB,eAAe,IAAI,OAAO;IAI1B,OAAO,CAAC,eAAe;IAqBvB,SAAS,CAAC,iCAAiC,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE;IAwCzE,eAAe,CACnB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,kBAAkB,EAC9B,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,cAAc,CAAC;CAmS3B"}