@ai-sdk/harness-opencode 1.0.114 → 1.0.115

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @ai-sdk/harness-opencode
 
+## 1.0.115
+
+### Patch Changes
+
+- 0185c4d: fix(harness-opencode): refresh warm runtimes when native configuration changes
+- b3c82fd: fix(harness-opencode): preserve native compaction events without leaking internal summary text
+- Updated dependencies [91c2128]
+- Updated dependencies [2cd80b3]
+- Updated dependencies [2fa5e0e]
+  - @ai-sdk/provider-utils@5.0.42
+  - @ai-sdk/harness@1.0.113
+
 ## 1.0.114
 
 ### Patch Changes

package/README.md

@@ -27,4 +27,15 @@ Adapter-managed settings take precedence when the same key is present in
 `openCodeConfig`. Agent-local `permission` and deprecated `tools` settings are
 ignored so they cannot bypass harness permissions or built-in tool filtering.
 
+## Compaction events
+
+Native automatic and manual compaction emit a `compaction` stream part on
+completion. Internal summary text is available on that part, rather than
+streamed as assistant answer text. Summary model usage is preserved.
+
+With `includeRawChunks` enabled, `opencode.compaction` raw events expose
+`messageId` and `status` (`started` or `failed`). Successful completion uses
+the normalized `compaction` part, whose `harnessMetadata.opencode.messageId`
+identifies the same operation.
+
 See the AI SDK documentation for usage.

package/dist/bridge/index.mjs

@@ -648,6 +648,7 @@ function serialiseError(err) {
 import { randomUUID as randomUUID2 } from "crypto";
 import path2 from "path";
 import { argv, env as procEnv2 } from "process";
+import { isDeepStrictEqual } from "util";
 import {
   createOpencodeClient,
   createOpencodeServer
@@ -1036,6 +1037,30 @@ function createEmitStreamEvent({
   stripWorkDir: stripWorkDir2,
   formatError: formatError2
 }) {
+  const compactionMessages = /* @__PURE__ */ new Set();
+  let compactionTrigger = "auto";
+  let compaction;
+  const finishCompaction = (failed = false) => {
+    if (!compaction) return;
+    if (failed) {
+      emit({
+        type: "raw",
+        rawValue: {
+          type: "opencode.compaction",
+          messageId: compaction.id,
+          status: "failed"
+        }
+      });
+    } else {
+      emit({
+        type: "compaction",
+        trigger: compaction.trigger,
+        summary: [...compaction.text.values()].join(""),
+        harnessMetadata: { opencode: { messageId: compaction.id } }
+      });
+    }
+    compaction = void 0;
+  };
   return (event) => {
     const type = event.type;
     const props = event.properties ?? {};
@@ -1045,9 +1070,56 @@ function createEmitStreamEvent({
         const id = stringValue2(info.id);
         const role = stringValue2(info.role);
         if (id && role) state.messageRoles.set(id, role);
+        if (id && info.summary === true) {
+          if (!compactionMessages.has(id)) {
+            compactionMessages.add(id);
+            compaction = { id, trigger: compactionTrigger, text: /* @__PURE__ */ new Map() };
+            emitOpenCodeStreamStart({ info, state, emit });
+            emit({
+              type: "raw",
+              rawValue: {
+                type: "opencode.compaction",
+                messageId: id,
+                status: "started"
+              }
+            });
+          }
+          if (info.error && compaction?.id === id) finishCompaction(true);
+        }
       }
       return;
     }
+    if (type === "session.compacted") {
+      finishCompaction();
+      return;
+    }
+    if (type === "message.part.updated" || type === "message.part.delta") {
+      const part = asOpenCodeObject(props.part);
+      if (type === "message.part.updated" && part?.type === "compaction") {
+        compactionTrigger = part.auto === false ? "manual" : "auto";
+        return;
+      }
+      const messageId = stringValue2(
+        type === "message.part.updated" ? part?.messageID : props.messageID
+      );
+      if (messageId && compactionMessages.has(messageId)) {
+        if (type === "message.part.updated") {
+          if (messageId === compaction?.id && part?.type === "text") {
+            const id = stringValue2(part.id);
+            if (id && typeof part.text === "string") {
+              compaction.text.set(id, part.text);
+            }
+          }
+          emitLegacyStepFinishPart({ part: props.part, state, emit });
+        } else if (messageId === compaction?.id && props.field === "text") {
+          const id = stringValue2(props.partID);
+          if (id && compaction.text.has(id) && typeof props.delta === "string") {
+            compaction.text.set(id, compaction.text.get(id) + props.delta);
+          }
+        }
+        return;
+      }
+    }
     if (type === "message.part.delta") {
       emitLegacyPartDelta({ props, state, emit });
       return;
@@ -1268,6 +1340,7 @@ function createEmitStreamEvent({
       return;
     }
     if (type === "session.error" || type === "session.next.step.failed") {
+      finishCompaction(true);
       const error = props.error ?? event;
       emitError({
         error,
@@ -1835,38 +1908,57 @@ async function ensureRuntime({
   turn,
   emit
 }) {
-  if (runtime.client) return;
-  if (start.tools && start.tools.length > 0) {
-    runtime.toolNames = new Set(start.tools.map((tool) => tool.name));
-    runtime.relay = await startToolRelay({
-      tools: start.tools,
-      emit,
-      requestToolResult: turn.requestToolResult
-    });
+  if (runtime.client && isDeepStrictEqual(runtime.openCodeConfig, start.openCodeConfig)) {
+    return;
   }
-  const serverAuthHeaders = configureOpenCodeServerAuth({ env: procEnv2 });
-  const server = await createOpencodeServer({
-    hostname: "127.0.0.1",
-    port: 0,
-    timeout: 3e4,
-    config: buildOpenCodeConfig({
-      start,
-      relayPort: runtime.relay?.port
-    })
-  });
-  runtime.server = server;
-  runtime.client = createOpencodeClient({
-    baseUrl: server.url,
-    directory: workdir,
-    headers: serverAuthHeaders
-  });
-  const mcpStatus = await runtime.client.mcp.status();
-  const mcpServers = asOpenCodeObject(mcpStatus.data) ?? {};
-  runtime.mcpToolPrefixes = new Set(
-    Object.entries(mcpServers).filter(
-      ([serverName, status]) => serverName !== "harness-tools" && asOpenCodeObject(status)?.status === "connected"
-    ).map(([serverName]) => `${sanitizeMcpToolName(serverName)}_`)
-  );
+  closeRuntime();
+  try {
+    if (start.tools && start.tools.length > 0) {
+      runtime.toolNames = new Set(start.tools.map((tool) => tool.name));
+      runtime.relay = await startToolRelay({
+        tools: start.tools,
+        emit,
+        requestToolResult: turn.requestToolResult
+      });
+    }
+    const serverAuthHeaders = configureOpenCodeServerAuth({ env: procEnv2 });
+    const server = await createOpencodeServer({
+      hostname: "127.0.0.1",
+      port: 0,
+      timeout: 3e4,
+      config: buildOpenCodeConfig({
+        start,
+        relayPort: runtime.relay?.port
+      })
+    });
+    runtime.server = server;
+    runtime.client = createOpencodeClient({
+      baseUrl: server.url,
+      directory: workdir,
+      headers: serverAuthHeaders
+    });
+    const mcpStatus = await runtime.client.mcp.status();
+    const mcpServers = asOpenCodeObject(mcpStatus.data) ?? {};
+    runtime.mcpToolPrefixes = new Set(
+      Object.entries(mcpServers).filter(
+        ([serverName, status]) => serverName !== "harness-tools" && asOpenCodeObject(status)?.status === "connected"
+      ).map(([serverName]) => `${sanitizeMcpToolName(serverName)}_`)
+    );
+    runtime.openCodeConfig = structuredClone(start.openCodeConfig);
+  } catch (error) {
+    closeRuntime();
+    throw error;
+  }
+}
+function closeRuntime() {
+  runtime.relay?.close();
+  runtime.server?.close();
+  runtime.server = void 0;
+  runtime.client = void 0;
+  runtime.relay = void 0;
+  runtime.openCodeConfig = void 0;
+  runtime.toolNames = /* @__PURE__ */ new Set();
+  runtime.mcpToolPrefixes = /* @__PURE__ */ new Set();
 }
 function buildOpenCodeConfig({
   start,