om-memory-system 5.10.1 → 6.1.0-next.237

package/dist/adapters/opencode/opencode-provider.js

@@ -1,150 +1,41 @@
 /**
- * Structured output via the opencode HTTP server.
+ * Structured output through the OpenCode V2 plugin context.
  *
- * Replaces the older 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 it with a JSON schema,
- * then delete the session so it does not pollute the user's TUI session
- * list.
- *
- * Internal capture sessions are least-privilege (issue #189): ordinary
- * agent tools are denied, only StructuredOutput is allowed, a dedicated
- * agent caps steps, and a hard timeout fails closed.
- *
- * The primary transport is the authenticated v2 SDK client initialized from
- * the plugin host's client configuration. A raw fetch fallback remains for
- * older SDK builds that do not expose the v2 session methods.
+ * OpenCode owns the user's provider sign-in, token refresh and routing, so OMMS asks it
+ * for one sessionless text generation (`ctx.generate.text`) per call. The generation
+ * has no session, agent or tools, so it cannot touch the user's session list or files.
+ * The reply must be one JSON object; OMMS parses it and validates it with the caller's
+ * schema. A hard timeout fails closed.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { diagnosticUrl, readJson, responseStatus, } from "./opencode-diagnostics.js";
-import { INTERNAL_CAPTURE_SESSION_TITLE, trackInternalCaptureSession, untrackInternalCaptureSession, } from "./internal-capture-sessions.js";
-import { createLazyV2Client } from "./opencode-sdk-client.js";
-import { httpStatusError, parseRetryAfter } from "../../core/capture-retry-policy.js";
-/** Dedicated agent registered via the plugin config hook (step-capped). */
-export const STRUCTURED_OUTPUT_AGENT = "omms-structured";
-/** Hard ceiling for a single internal structured-output prompt. */
+import { latestOpencodeSessionModel } from "./opencode-host.js";
+export { getOpencodeHost } from "./opencode-host.js";
+/** Error texts for a reply that holds no usable JSON; capture diagnostics classify them. */
+export const OPENCODE_EMPTY_REPLY = "omms: opencode returned an empty reply";
+export const OPENCODE_NO_JSON_REPLY = "omms: the model did not return a JSON object";
+/** Hard ceiling for a single internal structured-output request. */
 export const STRUCTURED_OUTPUT_TIMEOUT_MS = 90_000;
 let _structuredOutputTimeoutMs = STRUCTURED_OUTPUT_TIMEOUT_MS;
-/** Test helper: override the structured-output prompt timeout. Pass undefined to reset. */
+/** Test helper: override the structured-output timeout. Pass undefined to reset. */
 export function setStructuredOutputTimeoutMsForTests(ms) {
     _structuredOutputTimeoutMs = ms ?? STRUCTURED_OUTPUT_TIMEOUT_MS;
 }
-export const STRUCTURED_OUTPUT_PERMISSIONS = [
-    { permission: "*", pattern: "*", action: "deny" },
-    { permission: "StructuredOutput", pattern: "*", action: "allow" },
-];
-export const STRUCTURED_OUTPUT_TOOLS = {
-    "*": false,
-    StructuredOutput: true,
-};
-export const STRUCTURED_OUTPUT_METADATA = {
-    omms: {
-        internal: true,
-        purpose: "structured-output",
-    },
-};
-const _internalSessions = new Set();
 let _connectedProviders = new Set();
-let _v2Client;
-let _v2BaseUrl;
-let _hostFetch;
-let _useSdkTransport = false;
-export function setHostFetch(customFetch) {
-    _hostFetch = customFetch;
-}
-export function resetHostFetch() {
-    _hostFetch = undefined;
-}
-/** Test helper: forget the server URL, as in the native V2 plugin. */
-export function resetV2BaseUrlForTests() {
-    _v2BaseUrl = undefined;
-    _useSdkTransport = false;
-}
 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, transport) {
-    const baseUrl = typeof serverUrl === "string" ? serverUrl : serverUrl.toString();
-    const activeTransport = transport ?? (_hostFetch ? { fetch: _hostFetch } : undefined);
-    _v2BaseUrl = baseUrl;
-    _useSdkTransport = Boolean(activeTransport?.fetch || activeTransport?.headers);
-    return createLazyV2Client(baseUrl, activeTransport);
-}
-/** True while an internal structured-output session is live (create → delete). */
-export function isInternalStructuredSession(sessionID) {
-    return _internalSessions.has(sessionID);
-}
-/** Test helper: clear tracked internal session IDs. */
-export function resetInternalStructuredSessions() {
-    _internalSessions.clear();
-}
-function markInternalSession(sessionID) {
-    _internalSessions.add(sessionID);
-}
-function unmarkInternalSession(sessionID) {
-    _internalSessions.delete(sessionID);
-}
-function sessionCreateBody() {
-    return {
-        title: INTERNAL_CAPTURE_SESSION_TITLE,
-        permission: STRUCTURED_OUTPUT_PERMISSIONS,
-        metadata: STRUCTURED_OUTPUT_METADATA,
-    };
-}
-function sessionPromptFields(args) {
-    return {
-        model: { providerID: args.providerID, modelID: args.modelID },
-        agent: STRUCTURED_OUTPUT_AGENT,
-        system: args.systemPrompt,
-        parts: [{ type: "text", text: args.userPrompt }],
-        tools: STRUCTURED_OUTPUT_TOOLS,
-        // `noReply` suppresses assistant generation in current OpenCode builds,
-        // which also suppresses `info.structured_output`; structured capture needs
-        // the assistant run even though the temporary session is deleted afterward.
-        format: {
-            type: "json_schema",
-            schema: args.jsonSchema,
-            ...(args.retryCount !== undefined ? { retryCount: args.retryCount } : {}),
-        },
-    };
-}
-function reportReply(onReply, data) {
-    if (!onReply)
-        return;
-    try {
-        onReply({
-            ...(typeof data.info.finish === "string" ? { finish: data.info.finish } : {}),
-            partTypes: (Array.isArray(data.parts) ? data.parts : [])
-                .map((part) => typeof part === "object" && part !== null ? part.type : undefined)
-                .filter((type) => typeof type === "string"),
-            structuredOutput: data.info.structured_output ?? data.info.structured,
-        });
-    }
-    catch {
-        // Diagnostics must never change the call's result.
-    }
-}
 /**
  * Resolve `opencodeModel: "inherit"` to a concrete provider/model.
  *
- * Prefer an explicit prompt-recorded model (auto-capture path). Otherwise fall
- * back to OpenCode's recent model list so profile-learning / conflict / dedup
- * paths don't send the literal model id "inherit" (ProviderModelNotFoundError).
+ * Prefer an explicit prompt-recorded model (auto-capture path), then the latest
+ * model request this plugin saw, then OpenCode's recent model list, so
+ * profile-learning / conflict / dedup paths don't send the literal model id
+ * "inherit" (ProviderModelNotFoundError).
  */
 export function resolveOpencodeModelRef(opts) {
     if (opts.modelID !== "inherit") {
@@ -153,6 +44,10 @@ export function resolveOpencodeModelRef(opts) {
     if (opts.prompt?.providerId && opts.prompt?.modelId) {
         return { providerID: opts.prompt.providerId, modelID: opts.prompt.modelId };
     }
+    // The latest request's model is the session model; headless OpenCode has no model.json.
+    const latest = latestOpencodeSessionModel();
+    if (latest)
+        return latest;
     const recent = readRecentOpencodeModel(opts.providerID);
     if (recent)
         return recent;
@@ -178,279 +73,81 @@ function readRecentOpencodeModel(preferredProvider) {
         return undefined;
     }
 }
-/**
- * Generate one structured-output completion via opencode's HTTP API.
- * Throws on: session.create failure, prompt failure, AssistantMessage.error
- * (StructuredOutputError / ApiError / ...), missing `info.structured`,
- * timeout, or final Zod validation failure.
- */
-export async function generateStructuredOutput(opts) {
-    const resolved = resolveOpencodeModelRef({
-        providerID: opts.providerID,
-        modelID: opts.modelID,
-    });
-    const { client, systemPrompt, userPrompt, schema, directory, retryCount, onReply } = opts;
-    const { providerID, modelID } = resolved;
-    const jsonSchema = schema.toJSONSchema?.() ?? (await import("zod")).z.toJSONSchema(schema);
-    // The native V2 plugin has no server URL: it hands over a client whose
-    // session API wraps the plugin context, so that client is the only transport.
-    if ((_useSdkTransport || !_v2BaseUrl) && hasV2SessionClient(client)) {
-        return generateViaSdkClient(client, {
-            providerID,
-            modelID,
-            systemPrompt,
-            userPrompt,
-            directory,
-            retryCount,
-            jsonSchema,
-            schema,
-            onReply,
-        });
-    }
-    const baseUrl = _v2BaseUrl;
-    if (!baseUrl) {
-        throw new Error("omms: v2 server base URL not initialized; call createV2Client(serverUrl) first");
-    }
-    const base = stripTrailingSlash(baseUrl);
-    const sessionID = await createSession(base, directory);
-    markInternalSession(sessionID);
-    try {
-        const reply = await withStructuredOutputTimeout(() => promptSession(base, {
-            sessionID,
-            directory,
-            providerID,
-            modelID,
-            systemPrompt,
-            userPrompt,
-            jsonSchema,
-            retryCount,
-        }), () => abortSession(base, sessionID, directory));
-        reportReply(onReply, reply);
-        const info = reply.info;
-        if (info.error) {
-            throw assistantError(info.error);
-        }
-        const structuredOutput = info.structured_output ?? info.structured;
-        if (structuredOutput === undefined || structuredOutput === null) {
-            throw new Error("omms: opencode returned no structured output (info.structured_output/info.structured were empty)");
-        }
-        return schema.parse(structuredOutput);
-    }
-    finally {
-        unmarkInternalSession(sessionID);
-        // Best-effort: leaving a transient session behind is cosmetic, not
-        // worth failing a successful capture if cleanup itself errors.
-        try {
-            await deleteSession(base, sessionID, directory);
-        }
-        catch {
-            // intentionally swallowed
-        }
-        finally {
-            untrackInternalCaptureSession(sessionID);
-        }
-    }
-}
-function hasV2SessionClient(client) {
-    const session = client.session;
-    if (typeof session !== "object" || session === null)
-        return false;
-    const candidate = session;
-    return (typeof candidate.create === "function" &&
-        typeof candidate.prompt === "function" &&
-        typeof candidate.delete === "function");
-}
-async function generateViaSdkClient(client, args) {
-    const createdResponse = await client.session.create({
-        ...sessionCreateBody(),
-        ...(args.directory ? { directory: args.directory } : {}),
-    });
-    const created = readSdkData(createdResponse, "POST /session");
-    if (!created.id) {
-        throw new Error("omms: session.create returned no session id; cannot generate structured output");
-    }
-    const sessionID = created.id;
-    trackInternalCaptureSession(sessionID);
-    markInternalSession(sessionID);
+function structuredPrompt(systemPrompt, userPrompt, jsonSchema) {
+    return [
+        systemPrompt,
+        userPrompt,
+        [
+            "Return only one JSON object matching this JSON Schema.",
+            "Do not wrap the JSON in Markdown.",
+            JSON.stringify(jsonSchema),
+        ].join("\n"),
+    ]
+        .filter(Boolean)
+        .join("\n\n");
+}
+/** The JSON object in a model reply: the whole reply, a fenced block, or the outer braces. */
+export function parseJsonReply(text) {
+    const trimmed = text.trim();
+    const fenced = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1];
+    const candidate = fenced ?? trimmed;
     try {
-        const promptResponse = await withStructuredOutputTimeout(() => client.session.prompt({
-            sessionID,
-            ...(args.directory ? { directory: args.directory } : {}),
-            ...sessionPromptFields(args),
-        }), () => client.session.abort?.({
-            sessionID,
-            ...(args.directory ? { directory: args.directory } : {}),
-        }));
-        const data = readSdkData(promptResponse, "POST /session/{id}/message");
-        if (!data.info) {
-            throw new Error("omms: prompt response missing `info`");
-        }
-        reportReply(args.onReply, data);
-        if (data.info.error) {
-            throw assistantError(data.info.error);
-        }
-        const structuredOutput = data.info.structured_output ?? data.info.structured;
-        if (structuredOutput === undefined || structuredOutput === null) {
-            throw new Error("omms: opencode returned no structured output (info.structured_output/info.structured were empty)");
-        }
-        return args.schema.parse(structuredOutput);
+        return JSON.parse(candidate);
     }
-    finally {
-        unmarkInternalSession(sessionID);
-        try {
-            await client.session.delete({
-                sessionID,
-                ...(args.directory ? { directory: args.directory } : {}),
-            });
-        }
-        catch {
-            // Best-effort cleanup for the transient capture session.
-        }
-        finally {
-            untrackInternalCaptureSession(sessionID);
+    catch {
+        const start = candidate.indexOf("{");
+        const end = candidate.lastIndexOf("}");
+        if (start >= 0 && end > start) {
+            try {
+                return JSON.parse(candidate.slice(start, end + 1));
+            }
+            catch {
+                // The parser's own message can quote the reply, which must not reach the log.
+            }
         }
+        throw new Error(OPENCODE_NO_JSON_REPLY);
     }
 }
-async function withStructuredOutputTimeout(run, onTimeout) {
+async function withStructuredOutputTimeout(run) {
     let timer;
     const timeoutMs = _structuredOutputTimeoutMs;
-    const timeoutPromise = new Promise((_, reject) => {
+    const timeout = new Promise((_, reject) => {
         timer = setTimeout(() => {
             reject(new Error(`omms: structured-output timed out after ${timeoutMs}ms`));
         }, timeoutMs);
     });
     try {
-        return await Promise.race([run(), timeoutPromise]);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes("structured-output timed out after")) {
-            try {
-                await onTimeout();
-            }
-            catch {
-                // best-effort abort
-            }
-        }
-        throw error;
+        // On a timeout the pending generation's result is dropped.
+        return await Promise.race([run(), timeout]);
     }
     finally {
         if (timer !== undefined)
             clearTimeout(timer);
     }
 }
-function readSdkData(response, label) {
-    const result = response;
-    if (result?.error !== undefined) {
-        const status = result.response ? ` (${responseStatus(result.response)})` : "";
-        const responseUrl = result.response?.url || result.request?.url;
-        const url = responseUrl ? diagnosticUrl(responseUrl) : "the authenticated client";
-        const message = `omms: opencode ${label} failed at ${url}${status}: <redacted response body>`;
-        if (!result.response)
-            throw new Error(message);
-        throw httpStatusError(message, result.response.status, parseRetryAfter(result.response.headers?.get?.("retry-after")));
-    }
-    if (result?.data === undefined) {
-        throw new Error(`omms: opencode ${label} returned no response data`);
-    }
-    return result.data;
-}
-function stripTrailingSlash(url) {
-    return url.endsWith("/") ? url.slice(0, -1) : url;
-}
-function buildQuery(directory) {
-    if (!directory)
-        return "";
-    return `?directory=${encodeURIComponent(directory)}`;
-}
-async function fetchJson(endpoint, init) {
-    let res;
-    try {
-        res = await activeFetch()(new Request(endpoint.url, init));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`omms: failed to fetch ${endpoint.label} at ${diagnosticUrl(endpoint.url)}: ${message}`, { cause: error });
-    }
-    return readJson(res, endpoint);
-}
-async function createSession(base, directory) {
-    const url = `${base}/session${buildQuery(directory)}`;
-    const body = await fetchJson({ label: "POST /session", url }, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(sessionCreateBody()),
-    });
-    if (!body.id) {
-        throw new Error("omms: session.create returned no session id; cannot generate structured output");
-    }
-    trackInternalCaptureSession(body.id);
-    return body.id;
-}
-/** The model's error reply, with its HTTP status when OpenCode reports one. */
-function assistantError(error) {
-    const message = `omms: opencode reported ${error.name}: ${formatAssistantError(error)}`;
-    const status = error.data?.statusCode;
-    return typeof status === "number" ? httpStatusError(message, status) : new Error(message);
-}
-function formatAssistantError(error) {
-    if (!error.data)
-        return error.name;
-    const details = safeAssistantErrorDetails(error.data);
-    if (!error.data.message)
-        return details;
-    return details ? `${error.data.message}; ${details}` : error.data.message;
-}
-function safeAssistantErrorDetails(data) {
-    const safeFields = {};
-    for (const key of ["statusCode", "providerID", "modelID"]) {
-        const value = data[key];
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-            safeFields[key] = value;
-        }
-    }
-    const entries = Object.entries(safeFields);
-    if (entries.length === 0)
-        return "";
-    return `details=${JSON.stringify(Object.fromEntries(entries))}`;
-}
-async function promptSession(base, args) {
-    const url = `${base}/session/${encodeURIComponent(args.sessionID)}/message${buildQuery(args.directory)}`;
-    const body = sessionPromptFields(args);
-    const data = await fetchJson({ label: "POST /session/{id}/message", url }, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
+/**
+ * Generate one structured-output reply with one sessionless `ctx.generate.text` request.
+ * Throws on a failed request, a reply with no JSON object, a timeout, or a schema mismatch.
+ */
+export async function generateStructuredOutput(opts) {
+    const { providerID, modelID } = resolveOpencodeModelRef({
+        providerID: opts.providerID,
+        modelID: opts.modelID,
     });
-    if (!data.info) {
-        throw new Error("omms: prompt response missing `info`");
-    }
-    return data;
-}
-async function abortSession(base, sessionID, directory) {
-    const url = `${base}/session/${encodeURIComponent(sessionID)}/abort${buildQuery(directory)}`;
+    const jsonSchema = opts.schema.toJSONSchema?.() ?? (await import("zod")).z.toJSONSchema(opts.schema);
+    const generated = await withStructuredOutputTimeout(() => opts.host.generate.text({
+        prompt: structuredPrompt(opts.systemPrompt, opts.userPrompt, jsonSchema),
+        model: { providerID, id: modelID },
+    }));
+    const text = generated?.text ?? "";
+    if (!text.trim())
+        throw new Error(OPENCODE_EMPTY_REPLY);
+    const structuredOutput = parseJsonReply(text);
     try {
-        await activeFetch()(new Request(url, { method: "POST" }));
+        opts.onReply?.({ partTypes: ["text"], structuredOutput });
     }
     catch {
-        // best-effort
-    }
-}
-async function deleteSession(base, sessionID, directory) {
-    const url = `${base}/session/${encodeURIComponent(sessionID)}${buildQuery(directory)}`;
-    let res;
-    try {
-        res = await activeFetch()(new Request(url, { method: "DELETE" }));
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`omms: failed to fetch DELETE /session/{id} at ${diagnosticUrl(url)}: ${message}`, { cause: error });
-    }
-    // DELETE /session/:id returns boolean. We only care that it ran; failures
-    // are swallowed at the call site.
-    if (!res.ok) {
-        throw new Error(`omms: opencode DELETE /session/{id} failed at ${diagnosticUrl(url)} (${responseStatus(res)})`);
+        // Diagnostics must never change the call's result.
     }
-}
-function activeFetch() {
-    return _hostFetch ?? globalThis.fetch;
+    return opts.schema.parse(structuredOutput);
 }

package/dist/adapters/opencode/package-skills.d.ts

@@ -4,12 +4,7 @@
  * bundles the plugin into one file at another depth.
  */
 export declare function packageSkillsFolder(moduleUrl?: string): string;
-/**
- * V1: add the package's skills folder to OpenCode's skill paths once. The V1
- * SDK `Config` type has no `skills` key, although OpenCode reads it.
- */
-export declare function applySkillsPathConfig(config: object, folder?: string): void;
-/** V2: add the package's skills to the plugin's skill list once. */
+/** Add the package's skills to the plugin's skill list once. */
 export declare function addPackageSkill(editor: {
     get(id: string): unknown;
     add(skill: any): void;

package/dist/adapters/opencode/package-skills.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { log } from "../../services/logger.js";
@@ -27,22 +27,7 @@ export function packageSkillsFolder(moduleUrl = import.meta.url) {
     return join(dirname(fileURLToPath(moduleUrl)), "..", "..", "..", "skills");
 }
 const defaultFolder = packageSkillsFolder();
-/**
- * V1: add the package's skills folder to OpenCode's skill paths once. The V1
- * SDK `Config` type has no `skills` key, although OpenCode reads it.
- */
-export function applySkillsPathConfig(config, folder = defaultFolder) {
-    const cfg = config;
-    if (!existsSync(folder)) {
-        log("OMMS skills folder not found; the packaged skills are not loaded", { folder });
-        return;
-    }
-    const paths = cfg.skills?.paths ?? [];
-    if (paths.includes(folder))
-        return;
-    cfg.skills = { ...cfg.skills, paths: [...paths, folder] };
-}
-/** V2: add the package's skills to the plugin's skill list once. */
+/** Add the package's skills to the plugin's skill list once. */
 export function addPackageSkill(editor, folder = defaultFolder) {
     for (const name of SKILL_NAMES) {
         if (editor.get(name))

package/dist/adapters/opencode/profile-learning.d.ts

@@ -1,5 +1,4 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-export declare function performUserProfileLearning(ctx: PluginInput, directory: string): Promise<void>;
+export declare function performUserProfileLearning(directory: string): Promise<void>;
 import { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX } from "../../core/extraction.js";
 export { createUserProfileAnalysisSchema, USER_PROFILE_LLM_CONFIDENCE_MAX };
 export declare function createUserProfileToolSchema(existingProfile: boolean): {

package/dist/adapters/opencode/profile-learning.js

@@ -10,8 +10,9 @@ import { shouldStartAutoCleanup } from "../../services/user-profile/auto-cleanup
 import { sortProfileItems } from "../../utils/profile.js";
 import { truncateToMaxBytes } from "../../utils/context-limit.js";
 import { loadOpencodeProvider } from "./opencode-provider-loader.js";
+import { showOpencodeNotice } from "./toast.js";
 let isLearningRunning = false;
-export async function performUserProfileLearning(ctx, directory) {
+export async function performUserProfileLearning(directory) {
     if (isLearningRunning)
         return;
     if (!profileBackoff.canRun())
@@ -182,16 +183,11 @@ Rules:
                 .catch(() => { });
         }
         if (CONFIG.showUserProfileToasts) {
-            await ctx.client?.tui
-                .showToast({
-                body: {
-                    title: "User Profile Updated",
-                    message: `Analyzed ${prompts.length} of ${count} pending prompts and updated your profile`,
-                    variant: "success",
-                    duration: 3000,
-                },
-            })
-                .catch(() => { });
+            showOpencodeNotice({
+                title: "User Profile Updated",
+                message: `Analyzed ${prompts.length} of ${count} pending prompts and updated your profile`,
+                variant: "success",
+            });
         }
     }
     catch (error) {
@@ -461,12 +457,12 @@ async function analyzeUserProfile(context, existingProfile) {
         log("user-profile-learning: trying opencode provider");
         try {
             const { generateStructuredOutput } = await loadOpencodeProvider();
-            const { getOpenCodeClient } = await import("./profile-llm-client.js");
+            const { getOpencodeProfileHost } = await import("./profile-llm-client.js");
             log("user-profile-learning: opencode provider diag", {
                 provider: resolveOpencodeHostModel(CONFIG)?.providerID,
                 model: resolveOpencodeHostModel(CONFIG)?.modelID,
             });
-            const v2Client = await getOpenCodeClient();
+            const host = await getOpencodeProfileHost();
             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.
@@ -483,7 +479,7 @@ Use the update_user_profile tool to save the ${existingProfile ? "updated" : "ne
             log("user-profile-learning: calling LLM", { contextLen: context.length });
             const result = await Promise.race([
                 generateStructuredOutput({
-                    client: v2Client,
+                    host,
                     providerID: resolveOpencodeHostModel(CONFIG).providerID,
                     modelID: resolveOpencodeHostModel(CONFIG).modelID,
                     systemPrompt,
@@ -565,18 +561,18 @@ If no clear chains, return { "paths": [] }.`;
         try {
             const { z } = await import("zod");
             const { generateStructuredOutput } = await loadOpencodeProvider();
-            const { getOpenCodeClient } = await import("./profile-llm-client.js");
-            let v2Client;
+            const { getOpencodeProfileHost } = await import("./profile-llm-client.js");
+            let host;
             try {
-                v2Client = await getOpenCodeClient();
+                host = await getOpencodeProfileHost();
             }
             catch {
                 // provider not available, skip learning paths
             }
-            if (v2Client) {
+            if (host) {
                 result = (await Promise.race([
                     generateStructuredOutput({
-                        client: v2Client,
+                        host,
                         providerID: resolveOpencodeHostModel(CONFIG).providerID,
                         modelID: resolveOpencodeHostModel(CONFIG).modelID,
                         systemPrompt,

package/dist/adapters/opencode/profile-llm-client.d.ts

@@ -1,2 +1,3 @@
-import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
-export declare function getOpenCodeClient(): Promise<OpencodeClient>;
+import type { OpencodeHost } from "./opencode-host.js";
+/** The OpenCode plugin context for profile calls, once the host model's provider is signed in. */
+export declare function getOpencodeProfileHost(): Promise<OpencodeHost>;