opencode-collaboration 0.4.0 → 0.5.0

package/README.md

@@ -27,6 +27,7 @@ Run several opencode terminals in parallel (different repos, worktrees, or tasks
 - **Explicit TUI controls**: palette actions use host dialogs for selection and confirmation; slash wrappers remain available for automation and compatibility
 - Local only: everything stays on your machine (Unix-domain sockets on macOS/Linux, loopback TCP on Windows, plus a compatibility loopback listener for v1 peers)
 - The peer name is appended to this process's root session titles, so every opencode window shows who it is at a glance
+- Peer-triggered turns run under the receiving session's selected agent/mode (e.g. a custom `teacher`) instead of opencode's default `build`, so that agent's model, tools and permission rules apply. The mode is taken from the session's last human input (message or command) and its server-persisted agent; if none is known yet, the default agent is used
 
 ## Install
 

package/README.zh-CN.md

@@ -27,6 +27,7 @@
 - **明确的 TUI 控制**：面板操作使用宿主对话框进行选择确认；斜杠命令封装仍可用于自动化和兼容性场景
 - 纯本地运行：一切都在你的机器上（macOS/Linux 使用 Unix 域套接字，Windows 使用回环 TCP，另有一个兼容 v1 对端的回环监听器）
 - 本进程的 peer 名字会追加到根会话标题后面，一眼就能看出每个 opencode 窗口是谁
+- peer 触发的回合会沿用接收方会话当前选中的 agent/模式（如自定义的 `teacher`），而不是 opencode 默认的 `build`，因此该 agent 的模型、工具与权限规则都会生效。模式取自该会话最近一条人类输入（消息或命令）及其服务端持久化的 agent；若尚无所知则使用默认 agent
 
 ## 安装
 

package/dist/delivery.d.ts

@@ -18,6 +18,18 @@ export interface DeliveryOptions {
     logger: Logger;
     /** Protocol-v2 delivery targets this session immediately, even while busy. */
     immediate?: boolean;
+    /**
+     * The agent/mode the receiving session currently has selected (e.g. a custom
+     * "teacher"). When set, injected peer turns run under it instead of opencode's
+     * default agent. Returns undefined when unknown.
+     */
+    agent?: () => string | undefined;
+    /**
+     * Called when an injection failed because the recorded agent no longer
+     * exists, so the caller can drop it. The message is then retried once under
+     * opencode's default agent instead of requeue-looping on the same error.
+     */
+    onAgentRejected?: () => void;
     /**
      * Max time one prompt injection may take before it is treated as a delivery
      * failure and the message is requeued. Without this bound a hung

package/dist/delivery.js

@@ -62,28 +62,15 @@ export function Delivery(opts) {
         const status = sdkResult?.response?.status;
         const statusText = sdkResult?.response?.statusText;
         const detail = status ? ` (${status}${statusText ? ` ${statusText}` : ""})` : "";
-        throw new Error(`OpenCode prompt injection failed${detail}: ${String(sdkResult?.error ?? "request failed")}`);
+        const rawError = sdkResult?.error;
+        const errorText = rawError == null
+            ? "request failed"
+            : typeof rawError === "string"
+                ? rawError
+                : JSON.stringify(rawError);
+        throw new Error(`OpenCode prompt injection failed${detail}: ${errorText}`);
     }
-    async function inject(sessionId, text, message) {
-        const part = {
-            type: "text",
-            text,
-            synthetic: true,
-            metadata: {
-                peerMessage: message ? {
-                    version: 2,
-                    messageId: message.id,
-                    fromEndpointId: message.from.instanceId,
-                    toSessionId: sessionId,
-                } : true,
-            },
-        };
-        const messageID = message ? deterministicPeerMessageId(sessionId, message) : undefined;
-        const body = {
-            ...(messageID ? { messageID } : {}),
-            ...(message ? { system: REPLY_DIRECTIVE } : {}),
-            parts: [part],
-        };
+    async function sendPrompt(sessionId, body) {
         const session = opts.client.session;
         if (typeof session.promptAsync === "function") {
             const result = await withTimeout(session.promptAsync({
@@ -97,11 +84,59 @@ export function Delivery(opts) {
         }
         const result = await withTimeout(opts.client.session.prompt({
             path: { id: sessionId },
-            body,
+            body: body,
             query: { directory: opts.directory },
         }));
         assertPromptSucceeded(result);
     }
+    function isAgentNotFoundError(err) {
+        const source = err;
+        const text = [
+            err instanceof Error ? err.message : String(err),
+            source?.data?.message,
+            source?.responseBody,
+            source?.body,
+        ]
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .join(" ")
+            .toLowerCase();
+        return text.includes("agent not found");
+    }
+    async function inject(sessionId, text, message) {
+        const messageID = message ? deterministicPeerMessageId(sessionId, message) : undefined;
+        const buildBody = (agent) => ({
+            ...(messageID ? { messageID } : {}),
+            ...(agent ? { agent } : {}),
+            ...(message ? { system: REPLY_DIRECTIVE } : {}),
+            parts: [
+                {
+                    type: "text",
+                    text,
+                    synthetic: true,
+                    metadata: {
+                        peerMessage: message ? {
+                            version: 2,
+                            messageId: message.id,
+                            fromEndpointId: message.from.instanceId,
+                            toSessionId: sessionId,
+                        } : true,
+                    },
+                },
+            ],
+        });
+        const agent = opts.agent?.();
+        try {
+            await sendPrompt(sessionId, buildBody(agent));
+        }
+        catch (err) {
+            // The recorded agent no longer exists (e.g. removed from config). Drop it
+            // and retry once under opencode's default agent instead of requeue-looping.
+            if (!agent || !isAgentNotFoundError(err))
+                throw err;
+            opts.onAgentRejected?.();
+            await sendPrompt(sessionId, buildBody(undefined));
+        }
+    }
     async function flushOnce() {
         if (flushing)
             return false;

package/dist/index.d.ts

@@ -22,6 +22,7 @@
 import type { Plugin, PluginModule } from "@opencode-ai/plugin";
 import type { QueueInstance } from "./queue.js";
 import type { DeliveryInstance } from "./delivery.js";
+export declare const PLUGIN_VERSION: string;
 export declare function runReliabilitySweep(queue: QueueInstance, delivery: Pick<DeliveryInstance, "flush">): Promise<void>;
 export declare const PeersPlugin: Plugin;
 export declare const plugin: PluginModule;

package/dist/index.js

@@ -19,6 +19,7 @@
  * listener; the receiving instance injects into its own session via the
  * opencode SDK immediately, including while the target session is busy.
  */
+import { readFileSync } from "node:fs";
 import { resolveConfig, defaultPeerName } from "./config.js";
 import { Registry, newInboxToken, newInstanceId } from "./registry.js";
 import { InboxListener } from "./listener.js";
@@ -31,7 +32,18 @@ import { PeerPermissions } from "./permissions.js";
 import { buildPeerTools } from "./tools/peers-tools.js";
 import { handlePeersCommand } from "./commands.js";
 import { consumeCommand, createLogger, errorMessage } from "./feedback.js";
-const PLUGIN_VERSION = "0.2.2";
+// 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.
+function readPluginVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export const PLUGIN_VERSION = readPluginVersion();
 const COMMAND_NAMES = new Set(["peers", "list-agents", "peers-name", "peers-inbox", "peers-outbox"]);
 /**
  * Command definitions injected through the `config` hook. opencode 1.18 does
@@ -279,6 +291,8 @@ export const PeersPlugin = async (ctx, pluginOptions) => {
             if (disposing)
                 return;
             await runtime.noteActivity(input.sessionID);
+            if (input.agent)
+                await runtime.noteAgent(input.sessionID, input.agent);
             if (!disposing)
                 await registry.heartbeat();
         },

package/dist/session-runtime.d.ts

@@ -28,6 +28,7 @@ export interface SessionRuntimeInstance {
         properties?: Record<string, unknown>;
     }) => Promise<boolean>;
     noteActivity: (sessionId: string) => Promise<void>;
+    noteAgent: (sessionId: string, agent: string) => Promise<void>;
     queueForSession: (sessionId: string) => QueueInstance | null;
     deliveryForSession: (sessionId: string) => DeliveryInstance | null;
     sweep: () => Promise<void>;

package/dist/session-runtime.js

@@ -38,6 +38,8 @@ export function SessionRuntime(opts) {
             current.updatedAt = Math.max(current.updatedAt, session.time.updated);
             if (status)
                 setStatus(current, status);
+            if (session.agent)
+                current.agent = session.agent;
             return current;
         }
         const queue = createSessionMessageQueue({ config: opts.config, sessionId: session.id, logger: opts.logger });
@@ -51,6 +53,7 @@ export function SessionRuntime(opts) {
             updatedAt: session.time.updated,
             queue,
             tracker,
+            agent: session.agent,
             delivery: undefined,
         };
         if (endpoint.status !== "idle")
@@ -62,6 +65,10 @@ export function SessionRuntime(opts) {
             directory: session.directory || opts.directory,
             logger: opts.logger,
             immediate: true,
+            agent: () => endpoint.agent,
+            onAgentRejected: () => {
+                endpoint.agent = undefined;
+            },
         });
         endpoints.set(session.id, endpoint);
         return endpoint;
@@ -390,6 +397,13 @@ export function SessionRuntime(opts) {
                     setStatus(endpoint, "busy");
             });
         },
+        noteAgent(sessionId, agent) {
+            return whileRunning(undefined, async () => {
+                const endpoint = await findSession(sessionId);
+                if (endpoint)
+                    endpoint.agent = agent;
+            });
+        },
         queueForSession(sessionId) {
             return endpoints.get(sessionId)?.queue ?? null;
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-collaboration",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "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",