@jskit-ai/assistant-core 0.1.199 → 0.1.201

package/src/server/conversation/memoryStorage.js

@@ -1,76 +1,11 @@
-/** Reference adapter for transient conversations. Scope must be an app-issued string. */
+import { createConversationStorage } from "./storage.js";
+
+/** Transient storage: share one instance across the application's conversations. */
 export function createMemoryConversationStorage() {
   const conversations = new Map();
-  const pending = new Map();
-
-  function key(scope) {
-    if (typeof scope !== "string" || !scope.trim()) throw new TypeError("Conversation scope must be a nonempty string.");
-    return scope;
-  }
-
-  function transaction(turns) {
-    return {
-      async listTurnIds() { return [...turns.keys()]; },
-      async nextTurnId() { return String(Math.max(0, ...[...turns.keys()].map(Number).filter(Number.isSafeInteger)) + 1).padStart(6, "0"); },
-      async hasMessage(id) {
-        return Boolean(id) && [...turns.values()].some((turn) => turn.messages.some((message) => message.messageId === id));
-      },
-      async readTurn(id) {
-        const turn = turns.get(id);
-        if (!turn) return null;
-        const find = (role) => turn.messages.find((message) => message.role === role) || null;
-        const thinking = turn.messages.filter((message) => message.role === "thinking");
-        const commentary = turn.messages.filter((message) => message.role === "commentary");
-        const activity = [...thinking, ...commentary].sort((a, b) => a.at.localeCompare(b.at));
-        const system = find("system"), user = find("user"), assistant = find("assistant");
-        return structuredClone({
-          turnId: id, user, assistant, thinking, commentary,
-          ...(system ? { system } : {}), ...(turn.metadata ? { metadata: turn.metadata } : {}),
-          messages: [system, user, ...activity, assistant].filter(Boolean)
-        });
-      },
-      async appendMessage(id, { turnMetadata, ...message }) {
-        const turn = turns.get(id) || { messages: [] };
-        if (turnMetadata) turn.metadata = structuredClone(turnMetadata);
-        turn.messages.push(structuredClone(message));
-        turns.set(id, turn);
-      },
-      async replaceAssistant(id, message) {
-        if (!id) throw new TypeError("Assistant replacement requires a turn id.");
-        const turn = turns.get(id) || { messages: [] };
-        const previous = turn.messages.find((entry) => entry.role === "assistant");
-        turn.messages = turn.messages.filter((entry) => entry.role !== "assistant");
-        turn.messages.push({ ...previous, ...structuredClone(message), at: previous?.at || message.at });
-        turns.set(id, turn);
-      }
-    };
-  }
-
-  async function write(scope, callback, remove = false) {
-    const id = key(scope);
-    const previous = pending.get(id) || Promise.resolve();
-    const operation = previous.then(async () => {
-      const draft = structuredClone(conversations.get(id) || new Map());
-      const result = await callback(transaction(draft));
-      if (remove) conversations.delete(id);
-      else conversations.set(id, draft);
-      return result;
-    });
-    const settled = operation.then(() => undefined, () => undefined);
-    pending.set(id, settled);
-    try { return await operation; }
-    finally { if (pending.get(id) === settled) pending.delete(id); }
-  }
-
-  return Object.freeze({
-    write,
-    async read(scope, callback) {
-      const id = key(scope);
-      await pending.get(id);
-      return callback(transaction(structuredClone(conversations.get(id) || new Map())));
-    },
-    async deleteConversation(scope) {
-      await write(scope, async () => {}, true);
-    }
+  return createConversationStorage({
+    readRecord: (id) => conversations.get(id) || { turns: new Map(), metadata: {} },
+    writeRecord: (id, record) => { conversations.set(id, record); },
+    deleteRecord: (id) => { conversations.delete(id); }
   });
 }

package/src/server/conversation/nativeHistoryExport.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+
+export function canonicalNativeHistoryJson(value) {
+  return JSON.stringify(value, (_key, entry) => entry && typeof entry === "object" && !Array.isArray(entry)
+    ? Object.fromEntries(Object.keys(entry).sort().map((key) => [key, entry[key]])) : entry);
+}
+
+// Providers own record projection; this small sink owns the common byte bound,
+// callback backpressure and exact content revision used before retirement.
+export function createNativeHistoryExport(onRecord, { signal, maxBytes = 2 * 1024 ** 3 } = {}) {
+  if (typeof onRecord !== "function") throw new TypeError("Native export requires a record callback.");
+  const digest = createHash("sha256");
+  let bytes = 0;
+  let recordCount = 0;
+  return {
+    async emit(record) {
+      signal?.throwIfAborted();
+      const serialized = `${canonicalNativeHistoryJson(record)}\n`;
+      bytes += Buffer.byteLength(serialized);
+      if (bytes > maxBytes) throw new Error("Native export exceeded its byte limit; history was not retired.");
+      digest.update(serialized);
+      recordCount++;
+      // An admitted host callback may still publish under the archive lock.
+      // Cancellation must await its completion; the host owns cancelling its IO.
+      await onRecord(record);
+      signal?.throwIfAborted();
+    },
+    complete(extra = {}) {
+      signal?.throwIfAborted();
+      return { revision: digest.digest("hex"), bytes, recordCount, ...extra };
+    }
+  };
+}
+
+// Shared by the three native owners. The host must durably preserve customer
+// history, check references across projects and exclude external CLI writers.
+// This callback is trusted server code, never request data or a retention rule.
+export async function retireNativeConversation({ binding, inspect, remove, beforeDelete, readConversation, exportConversation }) {
+  if (typeof beforeDelete !== "function") throw new TypeError("Native retirement requires a host preservation callback.");
+  if (!binding?.conversationId || !path.isAbsolute(binding.workdir || "")) {
+    throw new TypeError("Native retirement requires an exact conversation and absolute native directory.");
+  }
+  const before = await inspect();
+  if (before.length === 0) return { ok: true, alreadyAbsent: true, conversationIds: [] };
+  const snapshot = JSON.stringify(before);
+  const ids = new Set(before.map((entry) => entry.conversationId));
+  const inventory = {
+    binding: structuredClone(binding),
+    conversations: structuredClone(before)
+  };
+  if (readConversation) {
+    inventory.readConversation = (id) => {
+      if (!ids.has(id)) throw new Error("Cannot export a conversation outside the inspected native family.");
+      return readConversation(id);
+    };
+  }
+  const exported = new Map();
+  let preserving = true;
+  if (exportConversation) {
+    inventory.exportConversation = async (id, onRecord) => {
+      if (!preserving || !ids.has(id)) throw new Error("Cannot export a conversation outside the inspected preservation scope.");
+      const result = await exportConversation(id, onRecord);
+      if (!/^[a-f0-9]{64}$/u.test(result?.revision || "")) throw new Error("Native export did not confirm a complete history revision.");
+      exported.set(id, result.revision);
+      return result;
+    };
+  }
+  let proof;
+  try { proof = await beforeDelete(inventory); }
+  finally { preserving = false; }
+  if (proof?.preserved !== true || proof?.exclusive !== true) {
+    throw new Error("The host did not confirm preserved history and exclusive ownership of every native conversation.");
+  }
+  if (exportConversation) {
+    if (exported.size !== ids.size) throw new Error("Preserve the complete native export of every inspected conversation before retirement.");
+    for (const id of ids) {
+      if ((await exportConversation(id, async () => {})).revision !== exported.get(id)) {
+        throw new Error("Native history changed during preservation. Export and preserve it again before retirement.");
+      }
+    }
+  }
+  if (JSON.stringify(await inspect()) !== snapshot) {
+    throw new Error("Native history changed during preservation. Inspect and preserve it again before retirement.");
+  }
+  await remove(before);
+  if ((await inspect()).length !== 0) throw new Error("Native deletion was not confirmed; retain the cleanup receipt and retry.");
+  return { ok: true, alreadyAbsent: false, conversationIds: before.map((entry) => entry.conversationId) };
+}
+

package/src/server/conversation/nativeStorage.js

@@ -0,0 +1,23 @@
+const policies = Object.freeze({
+  // Codex's deletion transaction locks writers and rejects rollout references
+  // outside the deletion family, including another live fork.
+  codex: Object.freeze({ requiresWriterExclusion: false }),
+  claude: Object.freeze({
+    requiresWriterExclusion: true,
+    allowsManagedServer: false,
+    matchesProcess: ({ executable, commandLine }) =>
+      /(?:^|[\0/])claude(?:\0|$)|@anthropic-ai\/claude-code\//u.test(`${executable || ""}\0${commandLine}`)
+  }),
+  opencode: Object.freeze({
+    requiresWriterExclusion: true,
+    allowsManagedServer: true,
+    matchesProcess: ({ executable, commandLine }) =>
+      /(?:^|[\0/])opencode(?:\0|$)/u.test(`${executable || ""}\0${commandLine}`)
+  })
+});
+
+/** The host owns process inventory, identity proof and the exclusion lock. */
+export function nativeConversationStoragePolicy(engineId) {
+  if (!Object.hasOwn(policies, engineId)) throw new TypeError("Unsupported native storage writer owner.");
+  return policies[engineId];
+}

package/src/server/conversation/openCodeClient.js

@@ -1,6 +1,7 @@
 import { pathToFileURL } from "node:url";
 import { Buffer } from "node:buffer";
 import path from "node:path";
+import { createNativeHistoryExport, retireNativeConversation } from "./nativeHistoryExport.js";
 
 const OPENCODE_RESPONSE_LIMIT_BYTES = 2 * 1024 * 1024;
 const OPENCODE_CATALOG_LIMIT_BYTES = 32 * 1024 * 1024;
@@ -210,14 +211,21 @@ function stablePromptBody(input = {}) {
   const modelID = text(model.modelID || model.id);
   const providerID = text(model.providerID);
   const prompt = typeof input?.prompt?.text === "string" ? input.prompt.text : "";
-  if (!prompt.trim()) {
-    throw new TypeError("OpenCode prompt requests require text.");
+  const content = (input.prompt?.content || []).map(part => {
+    if (part.type === "text" && typeof part.text === "string") return { type: "text", text: part.text };
+    if (part.type === "image" && part.image instanceof Uint8Array && ["image/png", "image/jpeg", "image/webp", "image/gif"].includes(part.mediaType)) {
+      return { type: "file", mime: part.mediaType, url: `data:${part.mediaType};base64,${Buffer.from(part.image).toString("base64")}` };
+    }
+    throw new TypeError("OpenCode prompt content must contain text or authorized image bytes.");
+  });
+  if (!prompt.trim() && !content.length) {
+    throw new TypeError("OpenCode prompt requests require text or attachment content.");
   }
   return {
     ...(text(input.agent) ? { agent: text(input.agent) } : {}),
     ...(text(input.id) ? { messageID: text(input.id) } : {}),
     ...(modelID && providerID ? { model: { modelID, providerID } } : {}),
-    parts: [{ text: prompt, type: "text" }, ...(input.attachments || [])
+    parts: [...(prompt ? [{ text: prompt, type: "text" }] : []), ...content, ...(input.attachments || [])
       .filter((attachment) => attachment.contentType?.startsWith("image/"))
       .map((attachment) => ({
         type: "file", mime: attachment.contentType, filename: attachment.fileName,
@@ -266,39 +274,67 @@ function createOpenCodeServerClient({
   const authorization = `Basic ${Buffer.from(`${text(username) || "opencode"}:${String(password)}`).toString("base64")}`;
   const scopedDirectory = text(directory);
 
-  function requestHeaders(accept = "application/json", body = undefined) {
+  function requestHeaders(accept = "application/json", body = undefined, directory = scopedDirectory) {
     return {
       accept,
       authorization,
-      ...(scopedDirectory ? { "x-opencode-directory": scopedDirectory } : {}),
+      ...(directory ? { "x-opencode-directory": directory } : {}),
       ...(body === undefined ? {} : { "content-type": "application/json" })
     };
   }
 
-  async function request(method = "GET", requestPath = "/", {
+  async function requestResponse(method = "GET", requestPath = "/", {
     body,
+    directory = scopedDirectory,
     limitBytes = OPENCODE_RESPONSE_LIMIT_BYTES,
     signal
   } = {}) {
     const response = await fetchImpl(new URL(requestPath, origin), {
       body: body === undefined ? undefined : JSON.stringify(body),
-      headers: requestHeaders("application/json", body),
+      headers: requestHeaders("application/json", body, directory),
       method,
       signal
     });
-    const source = response.status === 204
-      ? ""
-      : await readBoundedResponse(response, limitBytes);
-    const payload = parsedJson(source);
-    if (!response.ok) {
-      throw openCodeServerError(responseErrorMessage(payload), {
-        body: payload,
-        method,
-        path: requestPath,
-        status: response.status
-      });
+    try {
+      const source = response.status === 204 ? "" : await readBoundedResponse(response, limitBytes);
+      if (!response.ok) {
+        const payload = parsedJson(source);
+        throw openCodeServerError(responseErrorMessage(payload), {
+          body: payload, method, path: requestPath, status: response.status
+        });
+      }
+      return { source, headers: response.headers };
+    } finally { await response.body?.cancel().catch(() => {}); }
+  }
+
+  async function request(method, requestPath, options) {
+    return parsedJson((await requestResponse(method, requestPath, options)).source);
+  }
+
+  async function requestStorageResponse(route, { signal, maxBytes = 4 * 1024 * 1024, body } = {}) {
+    // The first storage request can initialize the saved directory after the
+    // global health endpoint is ready. Allow the normal startup deadline.
+    const deadline = AbortSignal.timeout(30_000);
+    const boundedSignal = signal ? AbortSignal.any([signal, deadline]) : deadline;
+    boundedSignal.throwIfAborted();
+    const { source, headers } = await requestResponse(body === undefined ? "GET" : "PATCH", route, {
+      body, signal: boundedSignal, limitBytes: maxBytes, directory: ""
+    });
+    boundedSignal.throwIfAborted();
+    return { data: source ? JSON.parse(source) : null, headers };
+  }
+
+  async function storageInventory(route, options) {
+    const { data: rows } = await requestStorageResponse(route, options);
+    if (!Array.isArray(rows) || rows.length > 1000 || rows.some((row) => !/^ses_[a-zA-Z0-9]+$/u.test(row?.id))) {
+      throw new Error("OpenCode returned an incomplete or invalid storage inventory.");
     }
-    return payload;
+    return rows;
+  }
+
+  function storageConversationPath(conversationId) {
+    if (!/^ses_[a-zA-Z0-9]+$/u.test(conversationId)) throw new TypeError("Invalid OpenCode conversation id.");
+    return `/session/${encodeURIComponent(conversationId)}`;
   }
 
   async function *events(sessionId = "", { onReady = null, signal } = {}) {
@@ -394,6 +430,58 @@ function createOpenCodeServerClient({
   }
 
   return Object.freeze({
+    async allowConversationAttachments(conversationId, attachments) {
+      const route = storageConversationPath(conversationId);
+      const { data: session } = await requestStorageResponse(route);
+      if (session?.id !== conversationId) throw new Error("OpenCode returned another conversation.");
+      const permission = [...(session.permission || [])];
+      const previousLength = permission.length;
+      for (const attachment of attachments) {
+        const pattern = path.join(path.dirname(attachment.path), "*").replaceAll("\\", "/");
+        const rule = permission.findLast((item) => item.permission === "external_directory" && item.pattern === pattern);
+        if (rule?.action !== "allow") permission.push({ permission: "external_directory", pattern, action: "allow" });
+      }
+      if (permission.length !== previousLength) {
+        await requestStorageResponse(route, { body: { permission } });
+      }
+    },
+    async listConversationChildren(conversationId, { signal } = {}) {
+      const children = await storageInventory(`${storageConversationPath(conversationId)}/children`, { signal });
+      if (children.some((child) => child.parentID !== conversationId)) {
+        throw new Error("OpenCode returned an incomplete or invalid child inventory.");
+      }
+      return children;
+    },
+    async listConversationsForDirectory(directory, { signal } = {}) {
+      if (!path.isAbsolute(directory || "")) throw new TypeError("OpenCode inventory requires an absolute native directory.");
+      // Use the global persisted inventory: the project-scoped /session
+      // listing loses its Git project identity once archived source is gone.
+      // Request one beyond our limit to detect a truncated inventory.
+      const rows = await storageInventory(`/experimental/session?${new URLSearchParams({ directory, limit: "1001" })}`, { signal });
+      if (rows.some((row) => typeof row.directory !== "string")) throw new Error("OpenCode inventory has no native directory.");
+      return rows.filter((row) => row.directory === directory);
+    },
+    async readConversationStorage(conversationId, { signal } = {}) {
+      // The native storage record does not resolve a live source workspace.
+      const { data } = await requestStorageResponse(storageConversationPath(conversationId), { signal });
+      if (data?.id !== conversationId || !path.isAbsolute(data.directory || "")) {
+        throw new Error("OpenCode returned an invalid native conversation record.");
+      }
+      return data;
+    },
+    async readConversationStoragePage(conversationId, { before = "", signal } = {}) {
+      const route = `${storageConversationPath(conversationId)}/message`;
+      if (typeof before !== "string" || before.length > 8192) throw new TypeError("Invalid OpenCode storage cursor.");
+      const query = new URLSearchParams({ limit: "1", ...(before ? { before } : {}) });
+      const { data, headers } = await requestStorageResponse(`${route}?${query}`, {
+        signal, maxBytes: 64 * 1024 * 1024
+      });
+      const nextCursor = headers.get("x-next-cursor");
+      if (!nextCursor && /rel="next"/u.test(headers.get("link") || "")) {
+        throw new Error("OpenCode omitted its native history continuation cursor.");
+      }
+      return { data, nextCursor };
+    },
     async agents({ directory = "", signal } = {}) {
       return request("GET", `/agent${queryString({ directory })}`, {
         limitBytes: OPENCODE_CATALOG_LIMIT_BYTES,
@@ -438,6 +526,21 @@ function createOpenCodeServerClient({
     async health({ signal } = {}) {
       return request("GET", "/global/health", { signal });
     },
+    async prepareDirectory({ signal } = {}) {
+      // Global health and the v2 session routes do not initialize the directory
+      // used by prompt/abort. Complete that native startup before exposing a
+      // conversation whose first Stop would otherwise wait for plugin installs.
+      const deadline = AbortSignal.timeout(30_000);
+      const boundedSignal = signal ? AbortSignal.any([signal, deadline]) : deadline;
+      boundedSignal.throwIfAborted();
+      const result = await request("GET", "/path", { signal: boundedSignal });
+      boundedSignal.throwIfAborted();
+      if (!text(result?.directory)) {
+        throw openCodeServerError("OpenCode did not confirm its conversation directory is ready.", {
+          code: "assistant_opencode_directory_unavailable", method: "GET", path: "/path"
+        });
+      }
+    },
     async interrupt(sessionId = "", { signal } = {}) {
       return request("POST", stableSessionPath(sessionId, "/abort"), { signal });
     },
@@ -520,7 +623,94 @@ function openCodeAssistantMessageText(message = {}) {
   return [...new Set(values)].join("\n\n");
 }
 
+// Native preservation uses the storage API independently of the saved worktree.
+// Status still comes from the exact directory-scoped control client.
+async function inspectOpenCodeConversationFamily(storageClient, controlClient, binding, { signal } = {}) {
+  const queue = [binding.conversationId];
+  const seen = new Set();
+  const records = [];
+  for (let index = 0; index < queue.length; index += 1) {
+    signal?.throwIfAborted();
+    const conversationId = queue[index];
+    if (seen.has(conversationId) || queue.length > 1000) throw new Error("OpenCode native family is cyclic or exceeds its inventory limit.");
+    seen.add(conversationId);
+    let native;
+    try { native = await storageClient.readConversationStorage(conversationId, { signal }); }
+    catch (error) { if (error.statusCode === 404 && index === 0) return []; throw error; }
+    if (native?.id !== conversationId || native?.directory !== binding.workdir ||
+        (await controlClient.sessionStatus(conversationId, { signal })).type !== "idle") {
+      throw new Error("OpenCode retirement requires an idle native family in the exact saved directory.");
+    }
+    records.push({ conversationId, workdir: native.directory,
+      ...(Number.isFinite(native.time?.created) ? { createdAt: new Date(native.time.created).toISOString() } : {}),
+      ...(Number.isFinite(native.time?.updated) ? { updatedAt: new Date(native.time.updated).toISOString() } : {}) });
+    const children = await storageClient.listConversationChildren(conversationId, { signal });
+    for (const child of children) {
+      if (child.directory !== binding.workdir) throw new Error("OpenCode child directory differs from its saved owner.");
+      queue.push(child.id);
+    }
+  }
+  return records.sort((left, right) => left.conversationId.localeCompare(right.conversationId));
+}
+
+async function exportOpenCodeNativeHistory(storageClient, controlClient, id, onRecord, { signal: inputSignal } = {}) {
+  const deadline = AbortSignal.timeout(300_000);
+  const signal = inputSignal ? AbortSignal.any([inputSignal, deadline]) : deadline;
+  const output = createNativeHistoryExport(onRecord, { signal });
+  const info = await storageClient.readConversationStorage(id, { signal });
+  if (info?.id !== id || (await controlClient.sessionStatus(id, { signal })).type !== "idle") {
+    throw new Error("OpenCode native export requires the exact idle conversation.");
+  }
+  await output.emit({ type: "thread", thread: info, text: [] });
+  const messageIds = new Set();
+  const cursors = new Set();
+  let before = "";
+  let pages = 0;
+  while (true) {
+    signal.throwIfAborted();
+    if (++pages > 20_000) throw new Error("OpenCode native export exceeded its page limit; history was not retired.");
+    const response = await storageClient.readConversationStoragePage(id, { before, signal });
+    if (!Array.isArray(response?.data) || response.data.length > 1 ||
+        (response.nextCursor !== null && (typeof response.nextCursor !== "string" || !response.nextCursor || response.nextCursor.length > 8192)) ||
+        (response.data.length === 0 && response.nextCursor !== null)) {
+      throw new Error("OpenCode returned an incomplete or invalid native message page.");
+    }
+    for (const message of response.data) {
+      const info = message?.info;
+      if (!/^msg_[a-zA-Z0-9_]{1,256}$/u.test(info?.id) || info.sessionID !== id ||
+          !["user", "assistant"].includes(info.role) || !Array.isArray(message.parts) || messageIds.has(info.id)) {
+        throw new Error("OpenCode returned an invalid or duplicate native message.");
+      }
+      messageIds.add(info.id);
+      const content = openCodeAssistantMessageText({ content: message.parts });
+      await output.emit({ type: "message", message, text: content ? [{ role: info.role, text: content,
+        branchId: id, messageId: info.id,
+        ...(info.parentID ? { parentMessageId: info.parentID } : {}),
+        ...(Number.isFinite(info.time?.created) ? { createdAt: new Date(info.time.created).toISOString() } : {}),
+        ...(Number.isFinite(info.time?.completed) ? { completedAt: new Date(info.time.completed).toISOString() } : {}),
+        ...(info.modelID || info.model?.modelID ? { modelId: info.modelID || info.model.modelID } : {}),
+        ...(info.providerID || info.model?.providerID ? { modelProviderId: info.providerID || info.model.providerID } : {}),
+        ...(info.agent ? { agent: info.agent } : {}) }] : [] });
+    }
+    if (response.nextCursor === null) break;
+    if (cursors.has(response.nextCursor)) throw new Error("OpenCode repeated a native history cursor.");
+    cursors.add(response.nextCursor);
+    before = response.nextCursor;
+  }
+  return output.complete();
+}
+
+/** Retire the exact native family after the host's durable preservation. */
+async function retireOpenCodeConversationHistory(storageClient, controlClient, binding, options = {}) {
+  const inspect = () => inspectOpenCodeConversationFamily(storageClient, controlClient, binding, { signal: options.signal });
+  return retireNativeConversation({ binding, inspect, beforeDelete: options.beforeDelete,
+    readConversation: async (id) => ({ info: await storageClient.readConversationStorage(id), messages: (await controlClient.messages(id)).data }),
+    exportConversation: (id, onRecord) => exportOpenCodeNativeHistory(storageClient, controlClient, id, onRecord, { signal: options.signal }),
+    remove: () => controlClient.deleteSession(binding.conversationId) });
+}
+
 export {
+  retireOpenCodeConversationHistory,
   openCodeAssistantMessageText,
   OPENCODE_RESPONSE_LIMIT_BYTES,
   createOpenCodeServerClient,

package/src/server/conversation/openCodePlugin.js

@@ -0,0 +1,84 @@
+import { createOpenCodeConversationAdapter } from "./providers/opencode.js";
+import { wrapNativeCommand } from "./commandWrapper.js";
+import { readOpenCodeEnvironments, openCodeEnvironmentForSession, openCodeEnvironmentForDirectory,
+  assertOpenCodeModelProvider, limitOpenCodeModelOutput } from "./openCodeRuntime.js";
+
+// Runs in OpenCode. The host writes this private binding before every dispatch;
+// the native system hook also rereads it after automatic compaction.
+export default async function conversationInstructions({ client, registryPath = process.env.JSKIT_OPENCODE_ENV_REGISTRY,
+  resolveHostInstructions } = {}) {
+  const schemas = JSON.parse(process.env.JSKIT_OPENCODE_TOOL_SCHEMAS || "[]");
+  const definitions = new Map(schemas.map(({ function: definition }) => [definition.name, definition]));
+  const environments = () => readOpenCodeEnvironments(registryPath);
+  async function readBinding(id) {
+    const binding = await openCodeEnvironmentForSession(await environments(), id, client);
+    if (!binding) throw new Error("This native conversation has no instruction owner.");
+    return binding;
+  }
+  const adapter = createOpenCodeConversationAdapter({
+    async resolveInstructions(id) {
+      const { conversation } = await readBinding(id);
+      if (!conversation) return null;
+      return { identity: conversation.systemPrompt, placement: "replace", read: () => conversation.systemPrompt };
+    }
+  });
+  const hostInstructions = resolveHostInstructions ? createOpenCodeConversationAdapter({
+    resolveInstructions: async id => (await resolveHostInstructions(id))?.instructions
+  }) : null;
+  return {
+    "experimental.chat.system.transform": hostInstructions ? async (input, output) => {
+      const selected = await resolveHostInstructions(input.sessionID || input.sessionId);
+      return selected?.conversation
+        ? adapter.transformSystem(input, output)
+        : hostInstructions.transformSystem(input, output);
+    } : adapter.transformSystem,
+    event: hostInstructions ? event => { hostInstructions.event(event); adapter.event(event); } : adapter.event,
+    "chat.params": async (input, output) => {
+      const binding = await readBinding(input.sessionID);
+      assertOpenCodeModelProvider(binding, input);
+      limitOpenCodeModelOutput(input, output);
+    },
+    "tool.execute.before": async ({ tool, sessionID }, output) => {
+      const { conversation } = await readBinding(sessionID);
+      const allowed = definitions.has(tool)
+        ? conversation?.tools?.schemas.some(({ function: definition }) => definition.name === tool)
+        : conversation?.nativeTools;
+      if (!allowed) {
+        throw new Error("This conversation has no authorization for that native tool.");
+      }
+      if (tool === "bash" && conversation.commandWrapper) {
+        output.args.command = wrapNativeCommand(conversation.commandWrapper, output.args.command);
+      }
+    },
+    "shell.env": async ({ sessionID, cwd }, output) => {
+      const binding = sessionID ? await readBinding(sessionID) : openCodeEnvironmentForDirectory(await environments(), cwd);
+      if (binding?.conversation?.nativeTools) {
+        Object.assign(output.env, binding.env);
+      }
+    },
+    // OpenCode 1.18.31 accepts JSON Schema properties from plugins. Preserve the
+    // original required/optional fields through its native definition hook.
+    "tool.definition": ({ toolID }, output) => {
+      const definition = definitions.get(toolID);
+      if (definition) output.jsonSchema = definition.parameters;
+    },
+    tool: Object.fromEntries([...definitions].map(([name, definition]) => [name, {
+      description: definition.description, args: definition.parameters.properties,
+      async execute(input, context) {
+        if (!context.callID || !context.sessionID || !context.messageID) {
+          throw new Error("OpenCode did not supply an application tool identity.");
+        }
+        const connection = (await readBinding(context.sessionID)).conversation?.tools;
+        if (!connection?.schemas.some(({ function: definition }) => definition.name === name)) {
+          throw new Error("This conversation has no authorization for that native tool.");
+        }
+        const response = await fetch(connection.url, { method: "POST", signal: context.abort,
+          headers: { authorization: `Bearer ${connection.token}`, "content-type": "application/json" },
+          body: JSON.stringify({ sessionId: context.sessionID, messageId: context.messageID, id: context.callID, name, input }) });
+        const result = await response.json();
+        if (!response.ok) throw new Error(result.error || "The application tool request failed.");
+        return JSON.stringify(result);
+      }
+    }]))
+  };
+}