om-memory-system 5.11.0-next.234 → 6.1.1

package/README.md

@@ -23,7 +23,7 @@ for model choices and privacy controls.
 ## Set up
 
 Use Node.js **22.14 or later** for the terminal command and Claude Code hooks.
-OMMS supports OpenCode v2, Claude Code and the
+OMMS supports OpenCode v2 (not older OpenCode versions), Claude Code and the
 [Pi coding agent](https://www.npmjs.com/package/@earendil-works/pi-coding-agent).
 
 > Automatic history import is enabled by default and makes model calls.

package/dist/adapters/opencode/auto-capture-host.d.ts

@@ -1,3 +1,3 @@
-import type { PluginInput } from "@opencode-ai/plugin";
 import type { AutoCaptureHost } from "../../core/host.js";
-export declare function createOpenCodeAutoCaptureHost(ctx: PluginInput): AutoCaptureHost;
+import type { OpencodeHost } from "./opencode-host.js";
+export declare function createOpenCodeAutoCaptureHost(host: Pick<OpencodeHost, "session">): AutoCaptureHost;

package/dist/adapters/opencode/auto-capture-host.js

@@ -1,27 +1,17 @@
 import { CONFIG } from "../../config.js";
 import { extractOpenCodeConversation } from "./conversation.js";
 import { generateOpenCodeAutoCaptureSummary } from "./auto-capture-summary.js";
-export function createOpenCodeAutoCaptureHost(ctx) {
+import { showOpencodeNotice } from "./toast.js";
+export function createOpenCodeAutoCaptureHost(host) {
     const notify = async (notification) => {
-        if (!ctx.client?.tui)
-            return;
-        await ctx.client.tui
-            .showToast({
-            body: notification,
-        })
-            .then(() => undefined)
-            .catch(() => undefined);
+        showOpencodeNotice(notification);
     };
     return {
         host: "opencode",
         isCaptureReady: () => CONFIG.autoCaptureProviderStatus.ready,
         getConversation: async (sessionId, promptMessageId) => {
-            if (!ctx.client)
-                throw new Error("Client not available");
-            const response = await ctx.client.session.messages({ path: { id: sessionId } });
-            if (!response.data)
-                return null;
-            return extractOpenCodeConversation(response.data, promptMessageId);
+            const messages = await host.session.context({ sessionID: sessionId });
+            return extractOpenCodeConversation(messages, promptMessageId);
         },
         summarize: (request) => generateOpenCodeAutoCaptureSummary(request, notify),
         notify,

package/dist/adapters/opencode/auto-capture-summary.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { OPENCODE_EMPTY_REPLY, OPENCODE_NO_JSON_REPLY } from "./opencode-provider.js";
 import { CONFIG } from "../../config.js";
 import { resolveOpencodeHostModel } from "../../services/ai/live-model-choice.js";
 import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
@@ -31,8 +32,10 @@ CAPTURE if: code changed, bug fixed, feature added, decision made`;
 function hostModelFailureReason(error) {
     if (error instanceof Error && error.name === "ZodError")
         return "schema-mismatch";
-    if (String(error).includes("returned no structured output"))
+    if (String(error).includes(OPENCODE_EMPTY_REPLY))
         return "empty-text";
+    if (String(error).includes(OPENCODE_NO_JSON_REPLY))
+        return "invalid-json";
     return "call-error";
 }
 export async function generateOpenCodeAutoCaptureSummary(request, notify) {
@@ -46,7 +49,7 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
             if (CONFIG.memoryModel && CONFIG.opencodeProvider) {
                 log("opencodeProvider takes precedence over memoryModel for auto-capture");
             }
-            const { isProviderConnected, getV2Client, generateStructuredOutput, resolveOpencodeModelRef, } = await loadOpencodeProvider();
+            const { isProviderConnected, getOpencodeHost, generateStructuredOutput, resolveOpencodeModelRef, } = await loadOpencodeProvider();
             // "inherit" (explicit, or no model configured at all) follows this prompt's session model.
             const { providerID, modelID } = resolveOpencodeModelRef({
                 ...hostModel,
@@ -58,9 +61,9 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
             if (!isProviderConnected(providerID)) {
                 throw new Error(`opencode provider '${providerID}' is not connected. Check your opencode provider configuration.`);
             }
-            const v2Client = getV2Client();
-            if (!v2Client) {
-                throw new Error("omms: v2 client not initialized; cannot perform structured-output capture");
+            const host = getOpencodeHost();
+            if (!host) {
+                throw new Error("omms: the OpenCode plugin context is not ready; cannot perform structured-output capture");
             }
             const { detectLanguage, getLanguageName } = await import("../../services/language-detector.js");
             const targetLang = CONFIG.autoCaptureLanguage === "auto" || !CONFIG.autoCaptureLanguage
@@ -77,7 +80,7 @@ export async function generateOpenCodeAutoCaptureSummary(request, notify) {
             diagnostics.systemPrompt = systemPrompt;
             diagnostics.userPrompt = aiPrompt;
             const result = await generateStructuredOutput({
-                client: v2Client,
+                host,
                 providerID,
                 modelID,
                 systemPrompt,

package/dist/adapters/opencode/backfill-models.js

@@ -38,6 +38,6 @@ export async function resolveOpencodeBackfillModels(config = CONFIG, context) {
     if (!context.connected.includes(ref.providerID)) {
         throw new Error(`OpenCode backfill provider ${ref.providerID} is not connected`);
     }
-    const models = await (context.makeModels ?? createOpencodeImportModels)(ref, context.directory);
+    const models = await (context.makeModels ?? createOpencodeImportModels)(ref);
     return { model: `${ref.providerID}/${ref.modelID}`, models };
 }

package/dist/adapters/opencode/backfill-startup.js

@@ -6,7 +6,8 @@ import { drainOpencodeCaptureRetries } from "../../services/auto-capture.js";
 import { registerCaptureRetryDrain } from "../../services/capture-retry-drain.js";
 import { resolveOpencodeBackfillModels } from "./backfill-models.js";
 import { createOpencodeImportModels } from "./opencode-import-models.js";
-import { getV2Client, isProviderConnected } from "./opencode-provider.js";
+import { listOpencodeModels } from "./opencode-host.js";
+import { getOpencodeHost, isProviderConnected } from "./opencode-provider.js";
 /** Start after connected providers load, without delaying plugin initialisation. */
 export function startOpencodeBackfill(input) {
     return scheduleAutoBackfill({
@@ -24,10 +25,10 @@ export function registerOpencodeBackfillModels(input) {
 export function registerOpencodeImportModels() {
     registerOpencodeHostModels({
         isProviderConnected: (providerID) => isProviderConnected(providerID),
-        createImportModels: (ref, directory) => createOpencodeImportModels(ref, directory),
+        createImportModels: (ref) => createOpencodeImportModels(ref),
         async listSettingsModels() {
-            const client = getV2Client();
-            return client ? listOpencodeClientModels(client) : null;
+            const host = getOpencodeHost();
+            return host ? listOpencodeClientModels(() => listOpencodeModels(host)) : null;
         },
     });
 }

package/dist/adapters/opencode/conversation.d.ts

@@ -1,2 +1,6 @@
 import type { CaptureConversation } from "../../core/host.js";
-export declare function extractOpenCodeConversation(messages: any[], promptMessageId: string): CaptureConversation | null;
+/**
+ * The reply to one prompt from OpenCode V2 session messages (`ctx.session.context`):
+ * the assistant messages after the prompt, up to the next user, synthetic or system message.
+ */
+export declare function extractOpenCodeConversation(messages: readonly any[], promptMessageId: string): CaptureConversation | null;

package/dist/adapters/opencode/conversation.js

@@ -12,36 +12,36 @@ function formatToolInput(inputValue) {
     }
     return "";
 }
+/** Message types that start a new turn: the user's prompt and messages sent for the user. */
+const TURN_START_TYPES = new Set(["user", "synthetic", "system"]);
+/**
+ * The reply to one prompt from OpenCode V2 session messages (`ctx.session.context`):
+ * the assistant messages after the prompt, up to the next user, synthetic or system message.
+ */
 export function extractOpenCodeConversation(messages, promptMessageId) {
-    const promptIndex = messages.findIndex((message) => message.info?.id === promptMessageId);
+    const promptIndex = messages.findIndex((message) => message?.id === promptMessageId);
     if (promptIndex === -1)
         return null;
-    const responseMessages = [];
-    for (const message of messages.slice(promptIndex + 1)) {
-        if (message.info?.role === "user")
-            break;
-        responseMessages.push(message);
-    }
     const textResponses = [];
     const toolCalls = [];
     const sourceEntryIds = [];
-    for (const message of responseMessages) {
-        if (message.info?.role !== "assistant")
-            continue;
-        if (typeof message.info?.id === "string")
-            sourceEntryIds.push(message.info.id);
-        if (!Array.isArray(message.parts))
+    for (const message of messages.slice(promptIndex + 1)) {
+        if (TURN_START_TYPES.has(message?.type))
+            break;
+        if (message?.type !== "assistant")
             continue;
-        const textParts = message.parts.filter((part) => part.type === "text" && typeof part.text === "string" && part.text.trim());
-        if (textParts.length > 0) {
-            textResponses.push(textParts
-                .map((part) => part.text)
-                .join("\n")
-                .trim());
-        }
-        for (const tool of message.parts.filter((part) => part.type === "tool")) {
-            // V1 parts name the tool `tool`; the V2 plugin API names it `name`.
-            const name = tool.tool || tool.name || "unknown";
+        if (typeof message.id === "string")
+            sourceEntryIds.push(message.id);
+        const content = Array.isArray(message.content) ? message.content : [];
+        const text = content
+            .filter((part) => part?.type === "text" && typeof part.text === "string" && part.text.trim())
+            .map((part) => part.text)
+            .join("\n")
+            .trim();
+        if (text)
+            textResponses.push(text);
+        for (const tool of content.filter((part) => part?.type === "tool")) {
+            const name = tool.name || "unknown";
             const input = boundToolInput(formatToolInput(tool.state?.input));
             const path = readToolPath(name, tool.state?.input);
             toolCalls.push({

package/dist/adapters/opencode/import-command.d.ts

@@ -24,15 +24,3 @@ export interface OpencodeImportCommandInput {
 }
 /** Parse, run, and describe one import; always resolves to text for the session. */
 export declare function runOpencodeImportCommand(input: OpencodeImportCommandInput): Promise<string>;
-/** The model of the session's latest user message, from the V1 message list. */
-export declare function latestUserMessageModel(client: {
-    session: {
-        messages: (input: {
-            path: {
-                id: string;
-            };
-        }) => Promise<{
-            data?: any;
-        }>;
-    };
-}, sessionID: string): Promise<OpencodeModelRef | null>;

package/dist/adapters/opencode/import-command.js

@@ -55,7 +55,7 @@ export async function runOpencodeImportCommand(input) {
                 return `${name}: OpenCode provider "${ref.providerID}" is not connected`;
             }
         }
-        const models = ref && !parsed.dryRun ? await createOpencodeImportModels(ref, input.directory) : {};
+        const models = ref && !parsed.dryRun ? await createOpencodeImportModels(ref) : {};
         if (!parsed.dryRun) {
             try {
                 await memoryClient.warmup();
@@ -89,19 +89,3 @@ export async function runOpencodeImportCommand(input) {
         importCommandRunning = false;
     }
 }
-/** The model of the session's latest user message, from the V1 message list. */
-export async function latestUserMessageModel(client, sessionID) {
-    try {
-        const messages = (await client.session.messages({ path: { id: sessionID } })).data ?? [];
-        for (let i = messages.length - 1; i >= 0; i--) {
-            const model = messages[i]?.info?.role === "user" ? messages[i].info.model : undefined;
-            if (model?.providerID && model?.modelID) {
-                return { providerID: model.providerID, modelID: model.modelID };
-            }
-        }
-    }
-    catch (error) {
-        log("OpenCode import: could not read the session model", { error: String(error) });
-    }
-    return null;
-}

package/dist/adapters/opencode/internal-capture-sessions.d.ts

@@ -1,4 +1 @@
 export { INTERNAL_CAPTURE_SESSION_TITLE, INTERNAL_CAPTURE_SESSION_TITLES, isInternalCaptureSessionTitle, } from "../../importer/opencode-internal-sessions.js";
-export declare function trackInternalCaptureSession(sessionID: string): void;
-export declare function untrackInternalCaptureSession(sessionID: string): void;
-export declare function isTrackedInternalCaptureSession(sessionID: string): boolean;

package/dist/adapters/opencode/internal-capture-sessions.js

@@ -1,27 +1 @@
 export { INTERNAL_CAPTURE_SESSION_TITLE, INTERNAL_CAPTURE_SESSION_TITLES, isInternalCaptureSessionTitle, } from "../../importer/opencode-internal-sessions.js";
-/** Grace period so session.idle can still match after best-effort delete. */
-const UNTRACK_GRACE_MS = 60_000;
-const trackedSessionIDs = new Set();
-const untrackTimers = new Map();
-export function trackInternalCaptureSession(sessionID) {
-    const pending = untrackTimers.get(sessionID);
-    if (pending) {
-        clearTimeout(pending);
-        untrackTimers.delete(sessionID);
-    }
-    trackedSessionIDs.add(sessionID);
-}
-export function untrackInternalCaptureSession(sessionID) {
-    const pending = untrackTimers.get(sessionID);
-    if (pending) {
-        clearTimeout(pending);
-    }
-    const timer = setTimeout(() => {
-        trackedSessionIDs.delete(sessionID);
-        untrackTimers.delete(sessionID);
-    }, UNTRACK_GRACE_MS);
-    untrackTimers.set(sessionID, timer);
-}
-export function isTrackedInternalCaptureSession(sessionID) {
-    return trackedSessionIDs.has(sessionID);
-}

package/dist/adapters/opencode/memory-tool.d.ts

@@ -1,4 +1,3 @@
-import { type ToolDefinition } from "@opencode-ai/plugin";
-import { type MemoryOperationContext } from "../../core/memory-operations.js";
-/** The OpenCode V1 `memory` tool. V2 reaches it through the V1 plugin's `tool.memory`. */
-export declare function opencodeMemoryTool(description: string, base: Pick<MemoryOperationContext, "directory" | "tags">): ToolDefinition;
+import { type MemoryOperationArgs, type MemoryOperationContext } from "../../core/memory-operations.js";
+/** Run the OpenCode `memory` tool. The V2 plugin registers it in `src/v2/tools.ts`. */
+export declare function runOpencodeMemoryTool(args: MemoryOperationArgs, base: Pick<MemoryOperationContext, "directory" | "tags">, sessionID: string | undefined): Promise<string>;

package/dist/adapters/opencode/memory-tool.js

@@ -1,53 +1,11 @@
-import { tool } from "@opencode-ai/plugin";
 import { executeMemoryOperation, } from "../../core/memory-operations.js";
-/** The OpenCode V1 `memory` tool. V2 reaches it through the V1 plugin's `tool.memory`. */
-export function opencodeMemoryTool(description, base) {
-    return tool({
-        description,
-        args: {
-            mode: tool.schema
-                .enum([
-                "add",
-                "memorise",
-                "memorize",
-                "recall",
-                "search",
-                "profile",
-                "list",
-                "forget",
-                "help",
-                "migrate",
-                "list-shards",
-                "export",
-                "import",
-            ])
-                .optional(),
-            content: tool.schema.string().optional(),
-            query: tool.schema.string().optional(),
-            tags: tool.schema.string().optional(),
-            type: tool.schema.string().optional(),
-            topic: tool.schema.string().optional(),
-            done: tool.schema.string().optional(),
-            doing: tool.schema.string().optional(),
-            next: tool.schema.string().optional(),
-            memoryId: tool.schema.string().optional(),
-            limit: tool.schema.number().optional(),
-            scope: tool.schema.enum(["project", "all-projects"]).optional(),
-            fromPath: tool.schema.string().optional(),
-            fromHash: tool.schema.string().optional(),
-            outputPath: tool.schema.string().optional(),
-            inputPath: tool.schema.string().optional(),
-            dryRun: tool.schema.boolean().optional(),
-            allowLinkedSource: tool.schema.boolean().optional(),
-        },
-        async execute(args, context) {
-            // The session ID lets `memorise` replace its own snapshot.
-            const result = await executeMemoryOperation(args, {
-                ...base,
-                host: "opencode",
-                hostSessionId: context?.sessionID,
-            });
-            return JSON.stringify(result);
-        },
+/** Run the OpenCode `memory` tool. The V2 plugin registers it in `src/v2/tools.ts`. */
+export async function runOpencodeMemoryTool(args, base, sessionID) {
+    // The session ID lets `memorise` replace its own snapshot.
+    const result = await executeMemoryOperation(args, {
+        ...base,
+        host: "opencode",
+        hostSessionId: sessionID,
     });
+    return JSON.stringify(result);
 }

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

@@ -0,0 +1,27 @@
+import type { Context } from "@opencode/plugin/promise/plugin";
+/** The parts of the OpenCode V2 plugin context that OMMS reads outside `setup`. */
+export type OpencodeHost = Pick<Context, "session" | "generate" | "model">;
+/** One OpenCode model, as the Settings page and backfill list it. */
+export type OpencodeModelInfo = {
+    readonly providerID: string;
+    readonly id: string;
+    readonly name: string;
+};
+/** Set once in the V2 plugin's `setup`; holds no store handle, so a space switch keeps it. */
+export declare function setOpencodeHost(host: OpencodeHost | undefined): void;
+export declare function getOpencodeHost(): OpencodeHost | undefined;
+/**
+ * Remember the model of the latest model request this plugin saw. `inherit` falls back to it
+ * when a call has no prompt model, because headless OpenCode writes no `model.json`.
+ * Pass `undefined` to forget it.
+ */
+export declare function rememberOpencodeSessionModel(model: {
+    readonly providerID: string;
+    readonly id: string;
+} | undefined): void;
+export declare function latestOpencodeSessionModel(): {
+    providerID: string;
+    modelID: string;
+} | undefined;
+/** The models OpenCode lists, each with a display name. */
+export declare function listOpencodeModels(host: Pick<OpencodeHost, "model">): Promise<OpencodeModelInfo[]>;

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

@@ -0,0 +1,30 @@
+let current;
+/** Set once in the V2 plugin's `setup`; holds no store handle, so a space switch keeps it. */
+export function setOpencodeHost(host) {
+    current = host;
+}
+export function getOpencodeHost() {
+    return current;
+}
+let sessionModel;
+/**
+ * Remember the model of the latest model request this plugin saw. `inherit` falls back to it
+ * when a call has no prompt model, because headless OpenCode writes no `model.json`.
+ * Pass `undefined` to forget it.
+ */
+export function rememberOpencodeSessionModel(model) {
+    sessionModel =
+        model?.providerID && model.id ? { providerID: model.providerID, modelID: model.id } : undefined;
+}
+export function latestOpencodeSessionModel() {
+    return sessionModel;
+}
+/** The models OpenCode lists, each with a display name. */
+export async function listOpencodeModels(host) {
+    const result = await host.model.list();
+    return result.data.map((model) => ({
+        providerID: model.providerID,
+        id: model.id,
+        name: model.name || model.id,
+    }));
+}

package/dist/adapters/opencode/opencode-import-models.d.ts

@@ -4,8 +4,8 @@ export interface OpencodeModelRef {
     providerID: string;
     modelID: string;
 }
-/** Capture and profile calls routed through OpenCode's structured-output sessions. */
-export declare function createOpencodeImportModels(ref: OpencodeModelRef, directory: string): Promise<{
+/** Capture and profile calls routed through OpenCode's sessionless generation. */
+export declare function createOpencodeImportModels(ref: OpencodeModelRef): Promise<{
     capture: CaptureSummaryProvider;
     profile: ModelPort;
 }>;

package/dist/adapters/opencode/opencode-import-models.js

@@ -1,12 +1,12 @@
 import { CONFIG } from "../../config.js";
 import { buildBoundedSummaryPrompt } from "../../core/capture-context.js";
 import { loadOpencodeProvider } from "./opencode-provider-loader.js";
-/** Capture and profile calls routed through OpenCode's structured-output sessions. */
-export async function createOpencodeImportModels(ref, directory) {
-    const { getV2Client, generateStructuredOutput } = await loadOpencodeProvider();
-    const client = getV2Client();
-    if (!client)
-        throw new Error("the OpenCode client is not ready; retry in a moment");
+/** Capture and profile calls routed through OpenCode's sessionless generation. */
+export async function createOpencodeImportModels(ref) {
+    const { getOpencodeHost, generateStructuredOutput } = await loadOpencodeProvider();
+    const host = getOpencodeHost();
+    if (!host)
+        throw new Error("the OpenCode plugin context is not ready; retry in a moment");
     const { z } = await import("zod");
     const { buildCaptureSystemPrompt, createUserProfileAnalysisSchema, parseCaptureSummary } = await import("../../core/extraction.js");
     const { detectLanguage, getLanguageName } = await import("../../services/language-detector.js");
@@ -22,12 +22,11 @@ export async function createOpencodeImportModels(ref, directory) {
                 : detectLanguage(request.userPrompt);
             const systemPrompt = buildCaptureSystemPrompt(getLanguageName(target));
             const result = await generateStructuredOutput({
-                client,
+                host,
                 ...ref,
                 systemPrompt,
                 userPrompt: buildBoundedSummaryPrompt(request.context, systemPrompt, z.toJSONSchema(captureSchema)),
                 schema: captureSchema,
-                directory,
             });
             const parsed = parseCaptureSummary(JSON.stringify(result));
             if (!parsed)
@@ -41,12 +40,11 @@ export async function createOpencodeImportModels(ref, directory) {
         modelId: ref.modelID,
         async complete(systemPrompt, userPrompt) {
             const result = await generateStructuredOutput({
-                client,
+                host,
                 ...ref,
                 systemPrompt,
                 userPrompt,
                 schema: profileSchema,
-                directory,
             });
             return JSON.stringify(result);
         },

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

@@ -1,72 +1,32 @@
 /**
- * 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 type { z } from "zod";
-import type { OpencodeClient } from "@opencode-ai/sdk/v2/client";
-import { type HostTransport } from "./opencode-sdk-client.js";
-/** Dedicated agent registered via the plugin config hook (step-capped). */
-export declare const STRUCTURED_OUTPUT_AGENT = "omms-structured";
-/** Hard ceiling for a single internal structured-output prompt. */
+import { type OpencodeHost } 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 declare const OPENCODE_EMPTY_REPLY = "omms: opencode returned an empty reply";
+export declare const OPENCODE_NO_JSON_REPLY = "omms: the model did not return a JSON object";
+/** Hard ceiling for a single internal structured-output request. */
 export declare const STRUCTURED_OUTPUT_TIMEOUT_MS = 90000;
-/** Test helper: override the structured-output prompt timeout. Pass undefined to reset. */
+/** Test helper: override the structured-output timeout. Pass undefined to reset. */
 export declare function setStructuredOutputTimeoutMsForTests(ms: number | undefined): void;
-export declare const STRUCTURED_OUTPUT_PERMISSIONS: ({
-    permission: string;
-    pattern: string;
-    action: "deny";
-} | {
-    permission: string;
-    pattern: string;
-    action: "allow";
-})[];
-export declare const STRUCTURED_OUTPUT_TOOLS: Record<string, boolean>;
-export declare const STRUCTURED_OUTPUT_METADATA: {
-    omms: {
-        internal: boolean;
-        purpose: string;
-    };
-};
-export declare function setHostFetch(customFetch: typeof fetch): void;
-export declare function resetHostFetch(): void;
-/** Test helper: forget the server URL, as in the native V2 plugin. */
-export declare function resetV2BaseUrlForTests(): void;
 export declare function setConnectedProviders(providers: string[]): void;
 export declare function isProviderConnected(providerName: string): boolean;
-export declare function setV2Client(client: OpencodeClient): void;
-export declare function getV2Client(): OpencodeClient | undefined;
-export declare function createV2Client(serverUrl: URL | string, transport?: HostTransport): OpencodeClient;
-/** True while an internal structured-output session is live (create → delete). */
-export declare function isInternalStructuredSession(sessionID: string): boolean;
-/** Test helper: clear tracked internal session IDs. */
-export declare function resetInternalStructuredSessions(): void;
 export interface StructuredOutputOptions<T> {
-    client: OpencodeClient;
+    host: Pick<OpencodeHost, "generate">;
     providerID: string;
     modelID: string;
     systemPrompt: string;
     userPrompt: string;
     schema: z.ZodType<T>;
-    directory?: string;
-    retryCount?: number;
-    /** Called with the raw reply before it is parsed, for capture diagnostics. */
+    /** Called with the parsed reply before it is validated, for capture diagnostics. */
     onReply?: (reply: StructuredOutputReply) => void;
 }
 export interface StructuredOutputReply {
@@ -77,9 +37,10 @@ export interface StructuredOutputReply {
 /**
  * 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 declare function resolveOpencodeModelRef(opts: {
     providerID: string;
@@ -92,10 +53,10 @@ export declare function resolveOpencodeModelRef(opts: {
     providerID: string;
     modelID: string;
 };
+/** The JSON object in a model reply: the whole reply, a fenced block, or the outer braces. */
+export declare function parseJsonReply(text: string): unknown;
 /**
- * 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.
+ * 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 declare function generateStructuredOutput<T>(opts: StructuredOutputOptions<T>): Promise<T>;