opencode-collaboration 0.5.2 → 0.6.1

package/dist/delivery.js

@@ -22,7 +22,9 @@ const REPLY_DIRECTIVE = "This turn was triggered by a plain-text message from an
     "- If the message is only an acknowledgement, a thank-you, an agreement, a status update that " +
     "needs no action, or a confirmation that the task is done, do NOT reply — briefly tell your user and stop.\n" +
     "Never send acknowledgement-only, thanks, or agreement messages: they cause an endless " +
-    "back-and-forth between agents. Once you and the peer have reached a conclusion, stop.";
+    "back-and-forth between agents. Once you and the peer have reached a conclusion, stop.\n" +
+    "When you call send_message (or any tool), always include a brief text message in the same " +
+    "assistant turn; never emit a bare tool call with no text.";
 const NOTICE_FOOTER = "---\n" +
     "This is an automated notification from the opencode-collaboration plugin. " +
     "Show it to the user verbatim, then stop. Do not take further action.";

package/dist/index.js

@@ -31,6 +31,7 @@ import { Outbox } from "./outbox.js";
 import { PeerPermissions } from "./permissions.js";
 import { buildPeerTools } from "./tools/peers-tools.js";
 import { handlePeersCommand } from "./commands.js";
+import { sanitizeMessages } from "./sanitize.js";
 import { consumeCommand, createLogger, errorMessage } from "./feedback.js";
 // Read the real package version at runtime so registry entries never report a
 // stale hardcoded number. Falls back to "0.0.0" if package.json is unavailable.
@@ -280,6 +281,15 @@ export const PeersPlugin = async (ctx, pluginOptions) => {
             if (disposing)
                 return;
             const e = event;
+            if (e.type && e.type.includes("agent.switched")) {
+                const probe = e.properties ?? {};
+                await logger("debug", "agent switch event observed", {
+                    type: e.type,
+                    sessionID: typeof probe.sessionID === "string" ? probe.sessionID : undefined,
+                    agent: typeof probe.agent === "string" ? probe.agent : undefined,
+                    messageID: typeof probe.messageID === "string" ? probe.messageID : undefined,
+                });
+            }
             const changed = await runtime.handleEvent(e);
             if (changed && !disposing)
                 await registry.heartbeat();
@@ -296,6 +306,22 @@ export const PeersPlugin = async (ctx, pluginOptions) => {
             if (!disposing)
                 await registry.heartbeat();
         },
+        "experimental.chat.messages.transform": async (_input, output) => {
+            if (disposing)
+                return;
+            // Clean the model-bound history before any provider sees it. opencode can
+            // leave empty text parts on tool-call turns and fully-empty assistant
+            // messages on failed turns; strict providers reject both, poisoning every
+            // later request in the session. Stripping them here is non-destructive to
+            // the stored history (parentID/tool pairing is untouched).
+            const messages = output.messages;
+            if (!Array.isArray(messages) || messages.length === 0)
+                return;
+            const dropped = sanitizeMessages(messages);
+            if (dropped > 0) {
+                await logger("warn", "stripped empty assistant messages from the outgoing history", { dropped });
+            }
+        },
         "command.execute.before": async (input, output) => {
             if (disposing)
                 return;

package/dist/sanitize.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Sanitization for the model-bound conversation history.
+ *
+ * opencode can record tool-call turns with an empty text part (text="") and,
+ * when a turn fails to stream, a fully empty assistant message (0 parts).
+ * Strict model providers reject either ("missing input.content.text",
+ * "assistant must not be empty"), poisoning every later request in the
+ * session. We clean the outgoing history in the
+ * experimental.chat.messages.transform hook instead of touching storage, so
+ * provider-side parentID/tool pairing is never disturbed.
+ */
+export interface SanitizeMessage {
+    info?: {
+        role?: string;
+        summary?: boolean;
+    };
+    parts?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+}
+/**
+ * Mutates `messages` in place:
+ *  - removes empty/whitespace-only text parts from every message, and
+ *  - drops assistant messages that end up with no parts at all.
+ * Returns how many assistant messages were dropped.
+ */
+export declare function sanitizeMessages<T extends SanitizeMessage>(messages: T[]): number;

package/dist/sanitize.js

@@ -0,0 +1,38 @@
+/**
+ * Sanitization for the model-bound conversation history.
+ *
+ * opencode can record tool-call turns with an empty text part (text="") and,
+ * when a turn fails to stream, a fully empty assistant message (0 parts).
+ * Strict model providers reject either ("missing input.content.text",
+ * "assistant must not be empty"), poisoning every later request in the
+ * session. We clean the outgoing history in the
+ * experimental.chat.messages.transform hook instead of touching storage, so
+ * provider-side parentID/tool pairing is never disturbed.
+ */
+/**
+ * Mutates `messages` in place:
+ *  - removes empty/whitespace-only text parts from every message, and
+ *  - drops assistant messages that end up with no parts at all.
+ * Returns how many assistant messages were dropped.
+ */
+export function sanitizeMessages(messages) {
+    for (const message of messages) {
+        if (Array.isArray(message.parts)) {
+            message.parts = message.parts.filter((part) => part?.type !== "text" || (part.text ?? "").trim().length > 0);
+        }
+    }
+    let dropped = 0;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        const role = message.info?.role;
+        // Never drop compaction summary messages (info.summary === true): the model
+        // may depend on them for context that predates the compaction.
+        if (role === "assistant" &&
+            message.info?.summary !== true &&
+            (!message.parts || message.parts.length === 0)) {
+            messages.splice(index, 1);
+            dropped++;
+        }
+    }
+    return dropped;
+}

package/dist/session-runtime.js

@@ -387,6 +387,22 @@ export function SessionRuntime(opts) {
                     setStatus(endpoint, event.type === "session.idle" ? "idle" : normalizeStatus(properties.status));
                     return true;
                 }
+                // The user toggled the session's agent/mode (e.g. build<->plan). Peer
+                // injections use the last-known agent, so refreshing here keeps the
+                // next injected turn under the mode the user actually selected — even
+                // when the toggle happens without a follow-up user message.
+                if (event.type === "session.next.agent.switched" ||
+                    event.type === "session.next.agent.switched.1") {
+                    const sessionId = properties.sessionID;
+                    const agent = properties.agent;
+                    if (!sessionId || !agent)
+                        return false;
+                    const endpoint = await findSession(sessionId);
+                    if (!endpoint)
+                        return false;
+                    endpoint.agent = agent;
+                    return true;
+                }
                 return false;
             });
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-collaboration",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "description": "Cross-session messaging for opencode — let independent sessions discover and text each other, modeled after Claude Code's cross-session messaging",
   "type": "module",
   "main": "./dist/index.js",