opencode-mem 2.11.12 → 2.12.0

package/dist/config.d.ts

@@ -21,6 +21,8 @@ export declare const CONFIG: {
     memoryApiKey: string | undefined;
     memoryTemperature: number | false | undefined;
     memoryExtraParams: Record<string, unknown> | undefined;
+    opencodeProvider: string | undefined;
+    opencodeModel: string | undefined;
     vectorBackend: "usearch-first" | "usearch" | "exact-scan";
     aiSessionRetentionDays: number;
     webServerEnabled: boolean;

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AA6aA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;oBAwBb,aAAa,GACb,kBAAkB,GAClB,WAAW;;;;;;mBAOX,eAAe,GACf,SAAS,GACT,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoCV,OAAO,GACP,QAAQ;;CAEf,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAqcA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;oBAwBb,aAAa,GACb,kBAAkB,GAClB,WAAW;;;;;;;;mBASX,eAAe,GACf,SAAS,GACT,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoCV,OAAO,GACP,QAAQ;;CAEf,CAAC;AAEF,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}

package/dist/config.js

@@ -142,12 +142,30 @@ const CONFIG_TEMPLATE = `{
   // Automatically detect and remove duplicate memories
   "deduplicationEnabled": true,
   
-  // Similarity threshold (0-1) for detecting duplicates (higher = stricter)
-  "deduplicationSimilarityThreshold": 0.90,
-  
-  // ============================================
-  // Auto-Capture Settings (REQUIRES EXTERNAL API)
-  // ============================================
+   // Similarity threshold (0-1) for detecting duplicates (higher = stricter)
+   "deduplicationSimilarityThreshold": 0.90,
+   
+   // ============================================
+   // OpenCode Provider Settings (RECOMMENDED)
+   // ============================================
+
+   // Use opencode's already-configured providers for auto-capture and user profile learning.
+   // When set, no separate API key is needed — uses your existing opencode authentication
+   // (including Claude Pro/Max plans via OAuth, or any API key configured in opencode).
+   //
+   // If NOT set, falls back to the manual config (memoryApiKey/memoryApiUrl/memoryModel below).
+   //
+   // Examples:
+   //   Anthropic (OAuth/API key): "opencodeProvider": "anthropic", "opencodeModel": "claude-haiku-4-5-20251001"
+   //   OpenAI (API key):          "opencodeProvider": "openai",     "opencodeModel": "gpt-4o-mini"
+   //
+   // The provider name must match a connected provider in opencode (check with: opencode providers list)
+   // "opencodeProvider": "anthropic",
+   // "opencodeModel": "claude-haiku-4-5-20251001",
+
+   // ============================================
+   // Auto-Capture Settings (REQUIRES EXTERNAL API)
+   // ============================================
   
   // IMPORTANT: Auto-capture ONLY works with external API
   // It runs in background without blocking your main session
@@ -355,6 +373,8 @@ export const CONFIG = {
     memoryApiKey: resolveSecretValue(fileConfig.memoryApiKey),
     memoryTemperature: fileConfig.memoryTemperature,
     memoryExtraParams: fileConfig.memoryExtraParams,
+    opencodeProvider: fileConfig.opencodeProvider,
+    opencodeModel: fileConfig.opencodeModel,
     vectorBackend: (fileConfig.vectorBackend ?? "usearch-first"),
     aiSessionRetentionDays: fileConfig.aiSessionRetentionDays ?? DEFAULTS.aiSessionRetentionDays,
     webServerEnabled: fileConfig.webServerEnabled ?? DEFAULTS.webServerEnabled,

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAkB/D,eAAO,MAAM,iBAAiB,EAAE,MA8a/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAmB/D,eAAO,MAAM,iBAAiB,EAAE,MA+b/B,CAAC"}

package/dist/index.js

@@ -10,6 +10,7 @@ import { startWebServer, WebServer } from "./services/web-server.js";
 import { isConfigured, CONFIG } from "./config.js";
 import { log } from "./services/logger.js";
 import { getLanguageName } from "./services/language-detector.js";
+import { setStatePath, setConnectedProviders } from "./services/ai/opencode-provider.js";
 export const OpenCodeMemPlugin = async (ctx) => {
     const { directory } = ctx;
     const tags = getTags(directory);
@@ -27,6 +28,23 @@ export const OpenCodeMemPlugin = async (ctx) => {
             log("Plugin warmup failed", { error: String(error) });
         }
     }
+    // Wire opencode state path and provider list — fire-and-forget to avoid blocking init
+    // These calls can hang if opencode isn't fully bootstrapped yet
+    (async () => {
+        try {
+            const pathResult = await ctx.client.path.get();
+            if (pathResult.data?.state) {
+                setStatePath(pathResult.data.state);
+            }
+            const providerResult = await ctx.client.provider.list();
+            if (providerResult.data?.connected) {
+                setConnectedProviders(providerResult.data.connected);
+            }
+        }
+        catch (error) {
+            log("Failed to initialize opencode provider state", { error: String(error) });
+        }
+    })();
     if (CONFIG.webServerEnabled) {
         startWebServer({
             port: CONFIG.webServerPort,

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

@@ -0,0 +1,30 @@
+import type { ZodType } from "zod";
+type OAuthAuth = {
+    type: "oauth";
+    refresh: string;
+    access: string;
+    expires: number;
+};
+type ApiAuth = {
+    type: "api";
+    key: string;
+};
+type Auth = OAuthAuth | ApiAuth;
+export declare function setStatePath(path: string): void;
+export declare function getStatePath(): string;
+export declare function setConnectedProviders(providers: string[]): void;
+export declare function isProviderConnected(providerName: string): boolean;
+export declare function readOpencodeAuth(statePath: string, providerName: string): Auth;
+export declare function createOAuthFetch(statePath: string, providerName: string): (input: string | Request | URL, init?: RequestInit) => Promise<Response>;
+export declare function createOpencodeAIProvider(providerName: string, auth: Auth, statePath?: string): import("@ai-sdk/anthropic").AnthropicProvider | import("@ai-sdk/openai").OpenAIProvider;
+export declare function generateStructuredOutput<T>(options: {
+    providerName: string;
+    modelId: string;
+    statePath: string;
+    systemPrompt: string;
+    userPrompt: string;
+    schema: ZodType<T>;
+    temperature?: number;
+}): Promise<T>;
+export {};
+//# sourceMappingURL=opencode-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-provider.d.ts","sourceRoot":"","sources":["../../../src/services/ai/opencode-provider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,CAAC;AAEnC,KAAK,SAAS,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AACrF,KAAK,OAAO,GAAG;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAC5C,KAAK,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;AAMhC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,YAAY,IAAI,MAAM,CAKrC;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI,CAE/D;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAEjE;AAYD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CA2B9E;AAQD,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,GACnB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAkJ1E;AAGD,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,2FAoB5F;AAGD,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,OAAO,EAAE;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GAAG,OAAO,CAAC,CAAC,CAAC,CAWb"}

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

@@ -0,0 +1,238 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { generateText, Output } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createOpenAI } from "@ai-sdk/openai";
+// --- State (set from plugin init in index.ts, Task 4) ---
+let _statePath = null;
+let _connectedProviders = [];
+export function setStatePath(path) {
+    _statePath = path;
+}
+export function getStatePath() {
+    if (!_statePath) {
+        throw new Error("opencode state path not initialized. Plugin may not be fully started.");
+    }
+    return _statePath;
+}
+export function setConnectedProviders(providers) {
+    _connectedProviders = providers;
+}
+export function isProviderConnected(providerName) {
+    return _connectedProviders.includes(providerName);
+}
+// --- Auth ---
+function findAuthJsonPath(statePath) {
+    const candidates = [
+        join(statePath, "auth.json"),
+        join(dirname(statePath), "share", "opencode", "auth.json"),
+        join(statePath.replace("/state/", "/share/"), "auth.json"),
+    ];
+    return candidates.find(existsSync);
+}
+export function readOpencodeAuth(statePath, providerName) {
+    const authPath = findAuthJsonPath(statePath);
+    let raw;
+    if (authPath) {
+        try {
+            raw = readFileSync(authPath, "utf-8");
+        }
+        catch { }
+    }
+    if (!raw || !authPath) {
+        throw new Error(`opencode auth.json not found at ${authPath ?? statePath}. Is opencode authenticated?`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Failed to read opencode auth.json: invalid JSON`);
+    }
+    const auth = parsed[providerName];
+    if (!auth) {
+        const connected = Object.keys(parsed).join(", ") || "none";
+        throw new Error(`Provider '${providerName}' not found in opencode auth.json. Connected providers: ${connected}`);
+    }
+    return auth;
+}
+// --- OAuth Fetch ---
+const OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const OAUTH_TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const OAUTH_REQUIRED_BETAS = ["oauth-2025-04-20", "interleaved-thinking-2025-05-14"];
+const MCP_TOOL_PREFIX = "mcp_";
+export function createOAuthFetch(statePath, providerName) {
+    return async (input, init) => {
+        let auth = readOpencodeAuth(statePath, providerName);
+        // Refresh token if expired
+        if (!auth.access || auth.expires < Date.now()) {
+            const refreshResponse = await fetch(OAUTH_TOKEN_URL, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    grant_type: "refresh_token",
+                    refresh_token: auth.refresh,
+                    client_id: OAUTH_CLIENT_ID,
+                }),
+            });
+            if (!refreshResponse.ok) {
+                throw new Error(`OAuth token refresh failed: ${refreshResponse.status}`);
+            }
+            const json = (await refreshResponse.json());
+            auth = {
+                type: "oauth",
+                refresh: json.refresh_token,
+                access: json.access_token,
+                expires: Date.now() + json.expires_in * 1000,
+            };
+            const authPath = findAuthJsonPath(statePath);
+            if (authPath) {
+                try {
+                    const allAuth = JSON.parse(readFileSync(authPath, "utf-8"));
+                    allAuth[providerName] = auth;
+                    writeFileSync(authPath, JSON.stringify(allAuth));
+                }
+                catch { }
+            }
+        }
+        // Build headers
+        const requestInit = init ?? {};
+        const requestHeaders = new Headers();
+        if (input instanceof Request) {
+            input.headers.forEach((value, key) => requestHeaders.set(key, value));
+        }
+        if (requestInit.headers) {
+            if (requestInit.headers instanceof Headers) {
+                requestInit.headers.forEach((value, key) => requestHeaders.set(key, value));
+            }
+            else if (Array.isArray(requestInit.headers)) {
+                for (const pair of requestInit.headers) {
+                    const [key, value] = pair;
+                    if (typeof value !== "undefined")
+                        requestHeaders.set(key, value);
+                }
+            }
+            else {
+                for (const [key, value] of Object.entries(requestInit.headers)) {
+                    if (typeof value !== "undefined")
+                        requestHeaders.set(key, String(value));
+                }
+            }
+        }
+        // Merge beta headers
+        const incomingBeta = requestHeaders.get("anthropic-beta") ?? "";
+        const incomingBetas = incomingBeta
+            .split(",")
+            .map((b) => b.trim())
+            .filter(Boolean);
+        const mergedBetas = [...new Set([...OAUTH_REQUIRED_BETAS, ...incomingBetas])].join(",");
+        requestHeaders.set("authorization", `Bearer ${auth.access}`);
+        requestHeaders.set("anthropic-beta", mergedBetas);
+        requestHeaders.set("user-agent", "claude-cli/2.1.2 (external, cli)");
+        requestHeaders.delete("x-api-key");
+        // Prefix tool names in request body
+        let body = requestInit.body;
+        if (body && typeof body === "string") {
+            try {
+                const parsed = JSON.parse(body);
+                if (parsed.tools && Array.isArray(parsed.tools)) {
+                    parsed.tools = parsed.tools.map((tool) => ({
+                        ...tool,
+                        name: tool.name ? `${MCP_TOOL_PREFIX}${tool.name}` : tool.name,
+                    }));
+                }
+                if (parsed.messages && Array.isArray(parsed.messages)) {
+                    parsed.messages = parsed.messages.map((msg) => {
+                        if (msg.content && Array.isArray(msg.content)) {
+                            msg.content = msg.content.map((block) => {
+                                if (block.type === "tool_use" && block.name) {
+                                    return { ...block, name: `${MCP_TOOL_PREFIX}${block.name}` };
+                                }
+                                return block;
+                            });
+                        }
+                        return msg;
+                    });
+                }
+                body = JSON.stringify(parsed);
+            }
+            catch { }
+        }
+        // Modify URL: add ?beta=true to /v1/messages
+        let requestInput = input;
+        try {
+            let requestUrl = null;
+            if (typeof input === "string" || input instanceof URL) {
+                requestUrl = new URL(input.toString());
+            }
+            else if (input instanceof Request) {
+                requestUrl = new URL(input.url);
+            }
+            if (requestUrl?.pathname === "/v1/messages" && !requestUrl.searchParams.has("beta")) {
+                requestUrl.searchParams.set("beta", "true");
+                requestInput =
+                    input instanceof Request ? new Request(requestUrl.toString(), input) : requestUrl;
+            }
+        }
+        catch { }
+        const response = await fetch(requestInput, { ...requestInit, body, headers: requestHeaders });
+        // Strip mcp_ prefix from tool names in streaming response
+        if (response.body) {
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                async pull(controller) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                        controller.close();
+                        return;
+                    }
+                    let text = decoder.decode(value, { stream: true });
+                    text = text.replace(/"name"\s*:\s*"mcp_([^"]+)"/g, '"name": "$1"');
+                    controller.enqueue(encoder.encode(text));
+                },
+            });
+            return new Response(stream, {
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+            });
+        }
+        return response;
+    };
+}
+// --- Provider ---
+export function createOpencodeAIProvider(providerName, auth, statePath) {
+    if (providerName === "anthropic") {
+        if (auth.type === "oauth") {
+            if (!statePath)
+                throw new Error("statePath is required for OAuth authentication");
+            return createAnthropic({
+                apiKey: "",
+                fetch: createOAuthFetch(statePath, providerName),
+            });
+        }
+        return createAnthropic({ apiKey: auth.key });
+    }
+    if (providerName === "openai") {
+        if (auth.type === "oauth") {
+            throw new Error("OpenAI does not support OAuth authentication. Use an API key instead.");
+        }
+        return createOpenAI({ apiKey: auth.key });
+    }
+    throw new Error(`Unsupported opencode provider: '${providerName}'. Supported providers: anthropic, openai`);
+}
+// --- Structured Output ---
+export async function generateStructuredOutput(options) {
+    const auth = readOpencodeAuth(options.statePath, options.providerName);
+    const provider = createOpencodeAIProvider(options.providerName, auth, options.statePath);
+    const result = await generateText({
+        model: provider(options.modelId),
+        system: options.systemPrompt,
+        prompt: options.userPrompt,
+        output: Output.object({ schema: options.schema }),
+        temperature: options.temperature ?? 0.3,
+    });
+    return result.output;
+}

package/dist/services/auto-capture.js

@@ -176,6 +176,64 @@ function buildMarkdownContext(userPrompt, textResponses, toolCalls, latestMemory
     return sections.join("\n");
 }
 async function generateSummary(context, sessionID, userPrompt) {
+    // Opencode provider path (when opencodeProvider + opencodeModel configured)
+    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        if (CONFIG.memoryModel) {
+            log("opencodeProvider takes precedence over memoryModel for auto-capture");
+        }
+        const { isProviderConnected, getStatePath, generateStructuredOutput } = await import("./ai/opencode-provider.js");
+        if (!isProviderConnected(CONFIG.opencodeProvider)) {
+            throw new Error(`opencode provider '${CONFIG.opencodeProvider}' is not connected. Check your opencode provider configuration.`);
+        }
+        const { detectLanguage, getLanguageName } = await import("./language-detector.js");
+        const targetLang = CONFIG.autoCaptureLanguage === "auto" || !CONFIG.autoCaptureLanguage
+            ? detectLanguage(userPrompt)
+            : CONFIG.autoCaptureLanguage;
+        const langName = getLanguageName(targetLang);
+        const systemPrompt = `You are a technical memory recorder for a software development project.
+
+RULES:
+1. ONLY capture technical work (code, bugs, features, architecture, config)
+2. SKIP non-technical by returning type="skip"
+3. NO meta-commentary or behavior analysis
+4. Include specific file names, functions, technical details
+5. Generate 2-4 technical tags (e.g., "react", "auth", "bug-fix")
+6. You MUST write the summary in ${langName}.
+
+FORMAT:
+## Request
+[1-2 sentences: what was requested, in ${langName}]
+
+## Outcome
+[1-2 sentences: what was done, include files/functions, in ${langName}]
+
+SKIP if: greetings, casual chat, no code/decisions made
+CAPTURE if: code changed, bug fixed, feature added, decision made`;
+        const aiPrompt = `${context}
+
+Analyze this conversation. If it contains technical work (code, bugs, features, decisions), create a concise summary and relevant tags. If it's non-technical (greetings, casual chat, incomplete requests), return type="skip" with empty summary.`;
+        const { z } = await import("zod");
+        const schema = z.object({
+            summary: z.string(),
+            type: z.string(),
+            tags: z.array(z.string()),
+        });
+        const result = await generateStructuredOutput({
+            providerName: CONFIG.opencodeProvider,
+            modelId: CONFIG.opencodeModel,
+            statePath: getStatePath(),
+            systemPrompt,
+            userPrompt: aiPrompt,
+            schema,
+            temperature: CONFIG.memoryTemperature === false ? undefined : (CONFIG.memoryTemperature ?? 0.3),
+        });
+        return {
+            summary: result.summary,
+            type: result.type,
+            tags: (result.tags || []).map((t) => t.toLowerCase().trim()),
+        };
+    }
+    // Existing manual config path
     if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl) {
         throw new Error("External API not configured for auto-capture");
     }

package/dist/services/user-memory-learning.js

@@ -105,6 +105,50 @@ Identify and ${existingProfile ? "update" : "create"}:
 ${existingProfile ? "Merge with existing profile, incrementing frequencies and updating confidence scores." : "Create initial profile with conservative confidence scores."}`;
 }
 async function analyzeUserProfile(context, existingProfile) {
+    if (CONFIG.opencodeProvider && CONFIG.opencodeModel) {
+        const { isProviderConnected, getStatePath, generateStructuredOutput } = await import("./ai/opencode-provider.js");
+        if (!isProviderConnected(CONFIG.opencodeProvider)) {
+            throw new Error(`opencode provider '${CONFIG.opencodeProvider}' is not connected. Check your opencode provider configuration.`);
+        }
+        const systemPrompt = `You are a user behavior analyst for a coding assistant.
+
+Your task is to analyze user prompts and ${existingProfile ? "update" : "create"} a comprehensive user profile.
+
+CRITICAL: Detect the language used by the user in their prompts. You MUST output all descriptions, categories, and text in the SAME language as the user's prompts.
+
+Use the update_user_profile tool to save the ${existingProfile ? "updated" : "new"} profile.`;
+        const { z } = await import("zod");
+        const schema = z.object({
+            preferences: z.array(z.object({
+                category: z.string(),
+                description: z.string(),
+                confidence: z.number(),
+                evidence: z.array(z.string()),
+            })),
+            patterns: z.array(z.object({
+                category: z.string(),
+                description: z.string(),
+            })),
+            workflows: z.array(z.object({
+                description: z.string(),
+                steps: z.array(z.string()),
+            })),
+        });
+        const result = await generateStructuredOutput({
+            providerName: CONFIG.opencodeProvider,
+            modelId: CONFIG.opencodeModel,
+            statePath: getStatePath(),
+            systemPrompt,
+            userPrompt: context,
+            schema,
+            temperature: CONFIG.memoryTemperature === false ? undefined : (CONFIG.memoryTemperature ?? 0.3),
+        });
+        if (existingProfile) {
+            const existingData = JSON.parse(existingProfile.profileData);
+            return userProfileManager.mergeProfileData(existingData, result);
+        }
+        return result;
+    }
     if (!CONFIG.memoryModel || !CONFIG.memoryApiUrl) {
         log("User Profile Config Check Failed:", {
             memoryModel: CONFIG.memoryModel,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-mem",
-  "version": "2.11.12",
+  "version": "2.12.0",
   "description": "OpenCode plugin that gives coding agents persistent memory using local vector database",
   "type": "module",
   "main": "dist/plugin.js",
@@ -33,11 +33,16 @@
     "access": "public"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.58",
+    "@ai-sdk/openai": "^3.0.41",
     "@opencode-ai/plugin": "^1.0.162",
+    "@opencode-ai/sdk": "^1.2.26",
     "@xenova/transformers": "^2.17.2",
+    "ai": "^6.0.116",
     "franc-min": "^6.2.0",
     "iso-639-3": "^3.0.1",
-    "usearch": "^2.21.4"
+    "usearch": "^2.21.4",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/bun": "^1.3.8",