@sw-market/openclaw-opencode-bridge 0.1.2 → 0.1.4

package/README.md

@@ -1,29 +1,37 @@
 # @sw-market/openclaw-opencode-bridge
 
-OpenClaw plugin bridge for OpenCode realtime sessions.
+OpenClaw plugin that bridges gateway methods to a built-in `@opencode-ai/sdk` runtime.
 
-## Goals
+## What It Does
 
-- Keep long-lived sessions keyed by `conversationKey`/`sessionKey`.
-- Stream OpenCode realtime events back to OpenClaw gateway.
-- Support interactive confirmations (`interaction.required` -> `chat.action` -> `interaction.resolved`).
-- Emit file change summaries (`file.changed`) for downstream clients (Flutter/Feishu/others).
+- Registers gateway methods:
+  - `opencode.chat.send`
+  - `opencode.chat.action`
+- Maintains OpenCode sessions by `sessionKey`.
+- Streams realtime events to OpenClaw:
+  - assistant deltas
+  - tool start/result
+  - interaction required/resolved (permission/question)
+  - file change summaries
+  - progress and run completion
 
-## Install To OpenClaw
+## Install
 
 ```bash
-openclaw plugins install @sw-market/openclaw-opencode-bridge
+openclaw plugins install @sw-market/openclaw-opencode-bridge@0.1.4
 ```
 
-After install, verify plugin exists:
+Verify:
 
 ```bash
-openclaw plugins list
+openclaw plugins info openclaw-opencode-bridge
 ```
 
-## OpenClaw Config
+## Config
 
-In `~/.openclaw/openclaw.json`, enable plugin and set SDK adapter config:
+Plugin no longer requires external adapter modules (`sdkAdapterModule` was removed).
+
+Configure in `~/.openclaw/openclaw.json`:
 
 ```json
 {
@@ -32,10 +40,15 @@ In `~/.openclaw/openclaw.json`, enable plugin and set SDK adapter config:
       "openclaw-opencode-bridge": {
         "enabled": true,
         "config": {
-          "sdkAdapterModule": "/abs/path/to/opencode_sdk_adapter.mjs",
-          "sdkAdapterExport": "createOpenCodeSdkAdapter",
+          "opencodeBaseUrl": "http://127.0.0.1:4096",
+          "opencodeDirectory": "/home/xxll-gpu-5080/code/openclaw_workspace",
+          "opencodeAgent": "codex",
+          "opencodeProviderId": "custom-www-right-codes",
+          "opencodeModelId": "gpt-5.2",
+          "opencodeSystemPrompt": "",
           "sessionTtlMs": 1800000,
-          "cleanupIntervalMs": 60000
+          "cleanupIntervalMs": 60000,
+          "emitToAllClients": false
         }
       }
     }
@@ -43,62 +56,30 @@ In `~/.openclaw/openclaw.json`, enable plugin and set SDK adapter config:
 }
 ```
 
-You can also set adapter location by environment variable:
+## Environment Variables
+
+Config can also come from env:
 
 ```bash
-export OPENCODE_SDK_ADAPTER_MODULE=/abs/path/to/opencode_sdk_adapter.mjs
-export OPENCODE_SDK_ADAPTER_EXPORT=createOpenCodeSdkAdapter
+export OPENCODE_BASE_URL=http://127.0.0.1:4096
+export OPENCODE_WORKSPACE_DIR=/home/xxll-gpu-5080/code/openclaw_workspace
+export OPENCODE_AGENT=codex
+export OPENCODE_PROVIDER_ID=custom-www-right-codes
+export OPENCODE_MODEL_ID=gpt-5.2
+export OPENCODE_SYSTEM_PROMPT=""
 ```
 
-Adapter module contract:
-- export function `createOpenCodeSdkAdapter(ctx)` or export object directly.
-- returned object must implement `createSession(args)`.
-
-Note:
-- Plugin installation no longer requires `sdkAdapterModule` in config.
-- But runtime calls will fail until adapter module is provided via config or env.
-
-## Gateway Methods Provided
+## Adapter Routing (your Python adapter)
 
-This plugin registers:
-- `opencode.chat.send`
-- `opencode.chat.action`
-
-Set adapter side method routing:
+Keep your adapter method mapping:
 
 ```env
 BRIDGE_WS_CHAT_SEND_METHOD=opencode.chat.send
 BRIDGE_WS_CHAT_ACTION_METHOD=opencode.chat.action
 ```
 
-## Library Usage (standalone)
-
-```ts
-import {
-  OpenClawOpenCodeBridge,
-  type OpenCodeSdkAdapter,
-} from "@sw-market/openclaw-opencode-bridge";
-
-const sdk: OpenCodeSdkAdapter = createYourOpenCodeSdkAdapter();
-const bridge = new OpenClawOpenCodeBridge(sdk, {
-  sessionTtlMs: 30 * 60 * 1000,
-});
-
-const started = await bridge.chatSend({
-  sessionKey: "sw:feishu:chat_001",
-  message: "list files and update README",
-});
-
-for await (const frame of started.events) {
-  // forward frame to OpenClaw gateway `event` pipeline
-  console.log(frame);
-}
-```
-
-## Contract
-
-- `chatSend`: start or continue a coding run.
-- `chatAction`: handle action replay (interaction reply, cancel run).
-- `dispose`: stop cleanup timer and release all in-memory sessions.
+## Notes
 
-The bridge is SDK-agnostic. You provide an adapter that knows how to invoke OpenCode SDK and return typed async events.
+- This plugin is now SDK-first and beta-oriented. It does not keep legacy template compatibility.
+- The OpenCode server must be reachable at `opencodeBaseUrl`.
+- `opencodeProviderId` and `opencodeModelId` are optional. If omitted, OpenCode server defaults are used.

package/dist/openclaw-extension.js

@@ -1,10 +1,8 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
 import { OpenClawOpenCodeBridge, } from "./index.js";
+import { createOpenCodeSdkAdapter } from "./sdk-adapter-opencode.js";
 const CHAT_SEND_METHOD = "opencode.chat.send";
 const CHAT_ACTION_METHOD = "opencode.chat.action";
-const DEFAULT_ADAPTER_EXPORT = "createOpenCodeSdkAdapter";
+const DEFAULT_OPENCODE_BASE_URL = "http://127.0.0.1:4096";
 let bridgePromise = null;
 let bridgeInstance = null;
 function asObject(value) {
@@ -49,66 +47,33 @@ function toErrorMessage(error) {
 }
 function parseConfig(pluginConfig) {
     const raw = pluginConfig ?? {};
-    const sdkAdapterModuleRaw = readString(raw, "sdkAdapterModule") || String(process.env.OPENCODE_SDK_ADAPTER_MODULE || "").trim();
-    const sdkAdapterModule = sdkAdapterModuleRaw || undefined;
-    const sdkAdapterExport = readString(raw, "sdkAdapterExport") ||
-        String(process.env.OPENCODE_SDK_ADAPTER_EXPORT || "").trim() ||
-        DEFAULT_ADAPTER_EXPORT;
+    const opencodeBaseUrl = readString(raw, "opencodeBaseUrl") ||
+        String(process.env.OPENCODE_BASE_URL || "").trim() ||
+        DEFAULT_OPENCODE_BASE_URL;
+    const opencodeDirectory = readString(raw, "opencodeDirectory") || String(process.env.OPENCODE_WORKSPACE_DIR || "").trim() || undefined;
+    const opencodeAgent = readString(raw, "opencodeAgent") || String(process.env.OPENCODE_AGENT || "").trim() || undefined;
+    const opencodeProviderId = readString(raw, "opencodeProviderId") ||
+        String(process.env.OPENCODE_PROVIDER_ID || "").trim() ||
+        undefined;
+    const opencodeModelId = readString(raw, "opencodeModelId") || String(process.env.OPENCODE_MODEL_ID || "").trim() || undefined;
+    const opencodeSystemPrompt = readString(raw, "opencodeSystemPrompt") ||
+        String(process.env.OPENCODE_SYSTEM_PROMPT || "").trim() ||
+        undefined;
     const sessionTtlMs = readOptionalPositiveInt(raw, "sessionTtlMs");
     const cleanupIntervalMs = readOptionalPositiveInt(raw, "cleanupIntervalMs");
     const emitToAllClients = raw.emitToAllClients === true;
     return {
-        sdkAdapterModule,
-        sdkAdapterExport,
+        opencodeBaseUrl,
+        opencodeDirectory,
+        opencodeAgent,
+        opencodeProviderId,
+        opencodeModelId,
+        opencodeSystemPrompt,
         sessionTtlMs,
         cleanupIntervalMs,
         emitToAllClients,
     };
 }
-function resolveModuleSpecifier(api, moduleSpecifier) {
-    const raw = moduleSpecifier.trim();
-    if (!raw) {
-        throw new Error("OpenCode SDK adapter is not configured. Set plugins.entries.openclaw-opencode-bridge.config.sdkAdapterModule " +
-            "or env OPENCODE_SDK_ADAPTER_MODULE.");
-    }
-    const looksLikePath = raw.startsWith("./") ||
-        raw.startsWith("../") ||
-        raw.startsWith("/") ||
-        raw.startsWith(".\\") ||
-        /^[a-zA-Z]:[\\/]/.test(raw);
-    if (!looksLikePath) {
-        return raw;
-    }
-    const absolutePath = path.isAbsolute(raw) ? raw : api.resolvePath(raw);
-    if (!existsSync(absolutePath)) {
-        throw new Error(`sdkAdapterModule path does not exist: ${absolutePath}`);
-    }
-    return pathToFileURL(absolutePath).href;
-}
-function isOpenCodeSdkAdapter(value) {
-    const obj = asObject(value);
-    if (!obj) {
-        return false;
-    }
-    return typeof obj.createSession === "function";
-}
-async function loadSdkAdapter(api, config) {
-    const moduleSpecifier = resolveModuleSpecifier(api, config.sdkAdapterModule ?? "");
-    const loaded = await import(moduleSpecifier);
-    const exported = loaded[config.sdkAdapterExport];
-    let candidate = exported;
-    if (typeof exported === "function") {
-        candidate = await Promise.resolve(exported({
-            api,
-            pluginConfig: config,
-        }));
-    }
-    if (!isOpenCodeSdkAdapter(candidate)) {
-        throw new Error(`Invalid OpenCode SDK adapter from "${config.sdkAdapterModule}" export "${config.sdkAdapterExport}". ` +
-            "Expected an object with createSession(args) function.");
-    }
-    return candidate;
-}
 function respondError(respond, code, message) {
     respond(false, undefined, {
         code,
@@ -215,13 +180,21 @@ async function ensureBridge(api) {
     }
     if (!bridgePromise) {
         bridgePromise = (async () => {
-            const sdk = await loadSdkAdapter(api, config);
+            const sdk = createOpenCodeSdkAdapter({
+                baseUrl: config.opencodeBaseUrl,
+                directory: config.opencodeDirectory,
+                agent: config.opencodeAgent,
+                providerId: config.opencodeProviderId,
+                modelId: config.opencodeModelId,
+                systemPrompt: config.opencodeSystemPrompt,
+                logger: api.logger,
+            });
             const bridge = new OpenClawOpenCodeBridge(sdk, {
                 sessionTtlMs: config.sessionTtlMs,
                 cleanupIntervalMs: config.cleanupIntervalMs,
             });
             bridgeInstance = bridge;
-            api.logger.info(`[${CHAT_SEND_METHOD}] bridge initialized`);
+            api.logger.info(`[${CHAT_SEND_METHOD}] bridge initialized (baseUrl=${config.opencodeBaseUrl}, directory=${config.opencodeDirectory ?? "<default>"})`);
             return bridge;
         })();
     }

package/dist/sdk-adapter-opencode.d.ts

@@ -0,0 +1,18 @@
+import type { OpenCodeSdkAdapter } from "./index.js";
+type Logger = {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+    error?: (message: string) => void;
+    debug?: (message: string) => void;
+};
+export interface OpenCodeSdkRuntimeConfig {
+    baseUrl: string;
+    directory?: string;
+    agent?: string;
+    providerId?: string;
+    modelId?: string;
+    systemPrompt?: string;
+    logger?: Logger;
+}
+export declare function createOpenCodeSdkAdapter(config: OpenCodeSdkRuntimeConfig): OpenCodeSdkAdapter;
+export default createOpenCodeSdkAdapter;

package/dist/sdk-adapter-opencode.js

@@ -0,0 +1,727 @@
+import { createOpencodeClient } from "@opencode-ai/sdk/v2";
+function asObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    return value;
+}
+function asObjectArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        const obj = asObject(item);
+        if (obj) {
+            out.push(obj);
+        }
+    }
+    return out;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const out = [];
+    for (const item of value) {
+        if (typeof item !== "string") {
+            continue;
+        }
+        const trimmed = item.trim();
+        if (trimmed) {
+            out.push(trimmed);
+        }
+    }
+    return out;
+}
+function readString(source, key) {
+    const value = source[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function optionIdFromLabel(label, index) {
+    const normalized = label
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    return normalized || `option_${index + 1}`;
+}
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+function formatSdkError(error) {
+    const obj = asObject(error);
+    if (!obj) {
+        return toErrorMessage(error);
+    }
+    const name = readString(obj, "name");
+    const message = readString(obj, "message");
+    const data = asObject(obj.data);
+    const dataMessage = data ? readString(data, "message") : "";
+    const text = dataMessage || message || JSON.stringify(obj);
+    if (name && text) {
+        return `${name}: ${text}`;
+    }
+    return text || "Unknown SDK error";
+}
+async function requestNoError(label, request) {
+    const result = asObject(await request);
+    if (!result) {
+        throw new Error(`${label} returned invalid response`);
+    }
+    if (result.error !== undefined) {
+        throw new Error(`${label} failed: ${formatSdkError(result.error)}`);
+    }
+    return result.data;
+}
+function getEventSessionId(eventType, properties) {
+    const direct = readString(properties, "sessionID");
+    if (direct) {
+        return direct;
+    }
+    const info = asObject(properties.info);
+    if (info) {
+        const fromInfo = readString(info, "sessionID");
+        if (fromInfo) {
+            return fromInfo;
+        }
+    }
+    const part = asObject(properties.part);
+    if (part) {
+        const fromPart = readString(part, "sessionID");
+        if (fromPart) {
+            return fromPart;
+        }
+    }
+    if (eventType === "message.part.delta") {
+        const fromDelta = readString(properties, "sessionID");
+        if (fromDelta) {
+            return fromDelta;
+        }
+    }
+    return undefined;
+}
+function resolveToolEvents(part) {
+    const tool = readString(part, "tool") || "tool";
+    const state = asObject(part.state);
+    if (!state) {
+        return [];
+    }
+    const status = readString(state, "status");
+    if (!status) {
+        return [];
+    }
+    const input = asObject(state.input) ?? undefined;
+    if (status === "pending" || status === "running") {
+        return [
+            {
+                kind: "tool_called",
+                tool,
+                args: input,
+            },
+        ];
+    }
+    if (status === "completed") {
+        const output = readString(state, "output") || readString(state, "title") || "Tool completed";
+        return [
+            {
+                kind: "tool_result",
+                tool,
+                ok: true,
+                result: output,
+            },
+        ];
+    }
+    if (status === "error") {
+        const message = readString(state, "error") || "Tool failed";
+        return [
+            {
+                kind: "tool_result",
+                tool,
+                ok: false,
+                result: message,
+            },
+        ];
+    }
+    return [];
+}
+function resolveTextDelta(part, runState) {
+    const partId = readString(part, "id");
+    const text = readString(part, "text");
+    if (!partId || !text) {
+        return [];
+    }
+    const previous = runState.partTextById.get(partId) ?? "";
+    runState.partTextById.set(partId, text);
+    const delta = text.startsWith(previous) ? text.slice(previous.length) : text;
+    if (!delta) {
+        return [];
+    }
+    return [
+        {
+            kind: "assistant_delta",
+            delta,
+            text,
+        },
+    ];
+}
+function resolvePatchEvents(part) {
+    const files = asStringArray(part.files);
+    const events = [];
+    for (const file of files) {
+        events.push({
+            kind: "file_changed",
+            path: file,
+            op: "update",
+            summary: "Patch generated by OpenCode",
+        });
+    }
+    return events;
+}
+function resolveQuestionSummary(questions) {
+    const lines = [];
+    const defaultAnswers = [];
+    const firstQuestionOptionById = {};
+    let firstQuestionOptions = [];
+    let firstQuestionDefaultOption;
+    questions.forEach((question, index) => {
+        const text = readString(question, "question") || readString(question, "header") || `Question ${index + 1}`;
+        lines.push(`${index + 1}. ${text}`);
+        const options = asObjectArray(question.options);
+        const labels = options
+            .map((opt) => readString(opt, "label"))
+            .filter((label) => label.length > 0);
+        defaultAnswers.push(labels[0] ? [labels[0]] : [""]);
+        if (index === 0) {
+            firstQuestionOptions = options.map((opt, optIndex) => {
+                const title = readString(opt, "label") || `Option ${optIndex + 1}`;
+                const id = optionIdFromLabel(title, optIndex);
+                firstQuestionOptionById[id] = title;
+                const description = readString(opt, "description") || undefined;
+                return {
+                    id,
+                    title,
+                    description,
+                };
+            });
+            firstQuestionDefaultOption = firstQuestionOptions[0]?.id;
+        }
+    });
+    return {
+        message: lines.join("\n"),
+        options: firstQuestionOptions,
+        defaultOption: firstQuestionDefaultOption,
+        defaultAnswers,
+        optionById: firstQuestionOptionById,
+    };
+}
+function resolveQuestionAnswers(payload, pending) {
+    const fallback = pending.defaultAnswers.map((row) => [...row]);
+    if (!payload) {
+        return fallback;
+    }
+    const explicitAnswers = payload.answers;
+    if (Array.isArray(explicitAnswers)) {
+        const rows = [];
+        for (const row of explicitAnswers) {
+            if (!Array.isArray(row)) {
+                continue;
+            }
+            const values = row
+                .map((item) => (typeof item === "string" ? item.trim() : ""))
+                .filter((item) => item.length > 0);
+            rows.push(values.length > 0 ? values : [""]);
+        }
+        if (rows.length > 0) {
+            return rows;
+        }
+    }
+    const answerValue = payload.answer;
+    if (typeof answerValue === "string" && answerValue.trim()) {
+        fallback[0] = [answerValue.trim()];
+        return fallback;
+    }
+    if (Array.isArray(answerValue)) {
+        const first = answerValue
+            .map((item) => (typeof item === "string" ? item.trim() : ""))
+            .filter((item) => item.length > 0);
+        if (first.length > 0) {
+            fallback[0] = first;
+            return fallback;
+        }
+    }
+    const optionId = typeof payload.optionId === "string" ? payload.optionId.trim() : "";
+    if (optionId && pending.firstQuestionOptionById[optionId]) {
+        fallback[0] = [pending.firstQuestionOptionById[optionId]];
+        return fallback;
+    }
+    return fallback;
+}
+function mapPermissionDecision(decision, payload) {
+    if (decision !== "approve") {
+        return "reject";
+    }
+    return payload?.always === true ? "always" : "once";
+}
+function extractNestedErrorMessage(value) {
+    const obj = asObject(value);
+    if (!obj) {
+        return toErrorMessage(value);
+    }
+    const data = asObject(obj.data);
+    const dataMessage = data ? readString(data, "message") : "";
+    const message = readString(obj, "message");
+    const name = readString(obj, "name");
+    const text = dataMessage || message || JSON.stringify(obj);
+    return name ? `${name}: ${text}` : text;
+}
+function mapSdkEvent(args) {
+    const event = asObject(args.rawEvent);
+    if (!event) {
+        return [];
+    }
+    const type = readString(event, "type");
+    if (!type) {
+        return [];
+    }
+    const properties = asObject(event.properties) ?? {};
+    const eventSessionId = getEventSessionId(type, properties);
+    if (eventSessionId && eventSessionId !== args.sessionState.sessionId) {
+        return [];
+    }
+    const out = [];
+    if (type === "message.part.delta") {
+        if (readString(properties, "field") === "text") {
+            const delta = readString(properties, "delta");
+            if (delta) {
+                out.push({
+                    kind: "assistant_delta",
+                    delta,
+                });
+            }
+        }
+        return out;
+    }
+    if (type === "message.part.updated") {
+        const part = asObject(properties.part);
+        if (!part) {
+            return out;
+        }
+        const partType = readString(part, "type");
+        if (partType === "text") {
+            out.push(...resolveTextDelta(part, args.runState));
+        }
+        else if (partType === "tool") {
+            out.push(...resolveToolEvents(part));
+        }
+        else if (partType === "patch") {
+            out.push(...resolvePatchEvents(part));
+        }
+        return out;
+    }
+    if (type === "permission.asked") {
+        const interactionId = readString(properties, "id");
+        if (!interactionId) {
+            return out;
+        }
+        const permission = readString(properties, "permission") || "permission";
+        const patterns = asStringArray(properties.patterns);
+        const patternText = patterns.length > 0 ? patterns.join(", ") : "*";
+        args.sessionState.pendingInteractions.set(interactionId, {
+            kind: "permission",
+            requestId: interactionId,
+        });
+        out.push({
+            kind: "interaction_required",
+            interactionId,
+            interactionType: "permission",
+            title: "Permission required",
+            message: `${permission} on ${patternText}`,
+            options: [
+                { id: "approve_once", title: "Approve once" },
+                { id: "approve_always", title: "Approve always" },
+                { id: "reject", title: "Reject" },
+            ],
+            defaultOption: "approve_once",
+        });
+        return out;
+    }
+    if (type === "question.asked") {
+        const interactionId = readString(properties, "id");
+        if (!interactionId) {
+            return out;
+        }
+        const questions = asObjectArray(properties.questions);
+        const summary = resolveQuestionSummary(questions);
+        args.sessionState.pendingInteractions.set(interactionId, {
+            kind: "question",
+            requestId: interactionId,
+            defaultAnswers: summary.defaultAnswers,
+            firstQuestionOptionById: summary.optionById,
+        });
+        out.push({
+            kind: "interaction_required",
+            interactionId,
+            interactionType: "question",
+            title: "Question from OpenCode",
+            message: summary.message || "Answer is required.",
+            options: summary.options.length > 0
+                ? summary.options
+                : [
+                    {
+                        id: "answer",
+                        title: "Reply",
+                        description: "Provide an answer in payload.answer or payload.answers",
+                    },
+                ],
+            defaultOption: summary.defaultOption,
+        });
+        return out;
+    }
+    if (type === "permission.replied") {
+        const interactionId = readString(properties, "requestID");
+        if (!interactionId) {
+            return out;
+        }
+        const reply = readString(properties, "reply");
+        args.sessionState.pendingInteractions.delete(interactionId);
+        out.push({
+            kind: "interaction_resolved",
+            interactionId,
+            decision: reply === "reject" ? "reject" : "approve",
+            status: "resolved",
+            source: "opencode",
+        });
+        return out;
+    }
+    if (type === "question.replied" || type === "question.rejected") {
+        const interactionId = readString(properties, "requestID");
+        if (!interactionId) {
+            return out;
+        }
+        args.sessionState.pendingInteractions.delete(interactionId);
+        out.push({
+            kind: "interaction_resolved",
+            interactionId,
+            decision: type === "question.rejected" ? "reject" : "approve",
+            status: "resolved",
+            source: "opencode",
+        });
+        return out;
+    }
+    if (type === "session.status") {
+        const status = asObject(properties.status);
+        const statusType = status ? readString(status, "type") : "";
+        if (!statusType) {
+            return out;
+        }
+        if (statusType === "busy") {
+            args.runState.seenBusy = true;
+            out.push({
+                kind: "progress",
+                stage: "session_busy",
+                message: "OpenCode is processing the request",
+            });
+            return out;
+        }
+        if (statusType === "retry") {
+            const attemptValue = status?.attempt;
+            const attempt = typeof attemptValue === "number" && Number.isFinite(attemptValue) ? Math.floor(attemptValue) : undefined;
+            const message = readString(status ?? {}, "message") || "OpenCode is retrying";
+            out.push({
+                kind: "progress",
+                stage: "session_retry",
+                message: attempt ? `${message} (attempt ${attempt})` : message,
+            });
+            return out;
+        }
+        if (statusType === "idle" && args.runState.seenBusy) {
+            args.runState.completed = true;
+            out.push({
+                kind: "run_completed",
+                status: "succeeded",
+            });
+            return out;
+        }
+        return out;
+    }
+    if (type === "session.idle" && args.runState.seenBusy) {
+        args.runState.completed = true;
+        out.push({
+            kind: "run_completed",
+            status: "succeeded",
+        });
+        return out;
+    }
+    if (type === "session.error") {
+        const errorMessage = extractNestedErrorMessage(properties.error ?? properties);
+        args.runState.completed = true;
+        args.runState.lastError = errorMessage;
+        out.push({
+            kind: "assistant_final",
+            text: errorMessage,
+            summary: "OpenCode run failed",
+            status: "failed",
+        });
+        out.push({
+            kind: "run_completed",
+            status: "failed",
+            error: errorMessage,
+        });
+        return out;
+    }
+    if (type === "session.diff") {
+        const diffs = asObjectArray(properties.diff);
+        for (const diff of diffs) {
+            const file = readString(diff, "file");
+            if (!file) {
+                continue;
+            }
+            const status = readString(diff, "status");
+            const op = status === "added" ? "create" : status === "deleted" ? "delete" : "update";
+            const additions = typeof diff.additions === "number" ? diff.additions : 0;
+            const deletions = typeof diff.deletions === "number" ? diff.deletions : 0;
+            out.push({
+                kind: "file_changed",
+                path: file,
+                op,
+                summary: `Diff +${additions} -${deletions}`,
+            });
+        }
+        return out;
+    }
+    if (type === "file.watcher.updated") {
+        const file = readString(properties, "file");
+        if (!file) {
+            return out;
+        }
+        const watcherEvent = readString(properties, "event");
+        const op = watcherEvent === "add" ? "create" : watcherEvent === "unlink" ? "delete" : "update";
+        out.push({
+            kind: "file_changed",
+            path: file,
+            op,
+            summary: `File watcher event: ${watcherEvent || "change"}`,
+        });
+        return out;
+    }
+    if (type === "file.edited") {
+        const file = readString(properties, "file");
+        if (!file) {
+            return out;
+        }
+        out.push({
+            kind: "file_changed",
+            path: file,
+            op: "update",
+            summary: "File edited",
+        });
+        return out;
+    }
+    return out;
+}
+class OpenCodeSessionRuntime {
+    client;
+    config;
+    state;
+    constructor(client, config, sessionId) {
+        this.client = client;
+        this.config = config;
+        this.state = {
+            sessionId,
+            pendingInteractions: new Map(),
+            activeRunAbort: null,
+        };
+    }
+    async *sendMessage(args) {
+        if (this.state.activeRunAbort) {
+            throw new Error("A run is already active for this session. Wait for completion before sending another message.");
+        }
+        const runAbort = new AbortController();
+        this.state.activeRunAbort = runAbort;
+        const runState = {
+            seenBusy: false,
+            completed: false,
+            partTextById: new Map(),
+        };
+        try {
+            const stream = await this.client.event.subscribe({
+                directory: this.config.directory,
+            }, {
+                signal: runAbort.signal,
+                sseMaxRetryAttempts: 0,
+            });
+            const body = {
+                messageID: args.idempotencyKey,
+                parts: [
+                    {
+                        type: "text",
+                        text: args.message,
+                    },
+                ],
+            };
+            if (this.config.agent) {
+                body.agent = this.config.agent;
+            }
+            if (this.config.systemPrompt) {
+                body.system = this.config.systemPrompt;
+            }
+            if (this.config.providerId && this.config.modelId) {
+                body.model = {
+                    providerID: this.config.providerId,
+                    modelID: this.config.modelId,
+                };
+            }
+            await requestNoError("session.promptAsync", this.client.session.promptAsync({
+                sessionID: this.state.sessionId,
+                directory: this.config.directory,
+                ...body,
+            }));
+            yield {
+                kind: "progress",
+                stage: "submitted",
+                message: "Message submitted to OpenCode",
+            };
+            for await (const rawEvent of stream.stream) {
+                const events = mapSdkEvent({
+                    rawEvent,
+                    sessionState: this.state,
+                    runState,
+                });
+                for (const event of events) {
+                    yield event;
+                }
+                if (runState.completed) {
+                    runAbort.abort();
+                    break;
+                }
+            }
+            if (!runState.completed) {
+                const finalError = runState.lastError || "OpenCode event stream closed before completion";
+                yield {
+                    kind: "run_completed",
+                    status: "failed",
+                    error: finalError,
+                };
+            }
+        }
+        catch (error) {
+            const message = `OpenCode streaming failed: ${toErrorMessage(error)}`;
+            this.config.logger?.error?.(message);
+            yield {
+                kind: "assistant_final",
+                text: message,
+                summary: "OpenCode runtime error",
+                status: "failed",
+            };
+            yield {
+                kind: "run_completed",
+                status: "failed",
+                error: message,
+            };
+        }
+        finally {
+            runAbort.abort();
+            if (this.state.activeRunAbort === runAbort) {
+                this.state.activeRunAbort = null;
+            }
+        }
+    }
+    async *sendAction(args) {
+        if (args.action.type === "cancel_run") {
+            const reason = args.action.reason?.trim() || "Run cancelled by user";
+            if (this.state.activeRunAbort) {
+                this.state.activeRunAbort.abort();
+                this.state.activeRunAbort = null;
+            }
+            await requestNoError("session.abort", this.client.session.abort({
+                sessionID: this.state.sessionId,
+                directory: this.config.directory,
+            }));
+            yield {
+                kind: "progress",
+                stage: "cancelled",
+                message: reason,
+            };
+            yield {
+                kind: "run_completed",
+                status: "failed",
+                error: reason,
+            };
+            return;
+        }
+        const interactionId = args.action.interactionId;
+        const pending = this.state.pendingInteractions.get(interactionId);
+        if (!pending) {
+            throw new Error(`Unknown interactionId: ${interactionId}`);
+        }
+        const payload = asObject(args.action.payload);
+        if (pending.kind === "permission") {
+            const reply = mapPermissionDecision(args.action.decision, payload);
+            await requestNoError("permission.reply", this.client.permission.reply({
+                requestID: pending.requestId,
+                directory: this.config.directory,
+                reply,
+                message: payload ? readString(payload, "message") || undefined : undefined,
+            }));
+        }
+        else {
+            if (args.action.decision === "reject" || args.action.decision === "cancel") {
+                await requestNoError("question.reject", this.client.question.reject({
+                    requestID: pending.requestId,
+                    directory: this.config.directory,
+                }));
+            }
+            else {
+                const answers = resolveQuestionAnswers(payload, pending);
+                await requestNoError("question.reply", this.client.question.reply({
+                    requestID: pending.requestId,
+                    directory: this.config.directory,
+                    answers,
+                }));
+            }
+        }
+        this.state.pendingInteractions.delete(interactionId);
+        yield {
+            kind: "interaction_resolved",
+            interactionId,
+            decision: args.action.decision,
+            status: "resolved",
+            source: args.action.source || "openclaw-opencode-bridge",
+        };
+    }
+    async close() {
+        if (this.state.activeRunAbort) {
+            this.state.activeRunAbort.abort();
+            this.state.activeRunAbort = null;
+        }
+    }
+}
+async function createSessionId(client, config, sessionKey) {
+    const data = await requestNoError("session.create", client.session.create({
+        directory: config.directory,
+        title: `openclaw:${sessionKey}`,
+    }));
+    const session = data ? asObject(data) : null;
+    const sessionId = session ? readString(session, "id") : "";
+    if (!sessionId) {
+        throw new Error("session.create failed: missing session id");
+    }
+    return sessionId;
+}
+export function createOpenCodeSdkAdapter(config) {
+    const client = createOpencodeClient({
+        baseUrl: config.baseUrl,
+        directory: config.directory,
+    });
+    return {
+        async createSession(args) {
+            const sessionId = await createSessionId(client, config, args.sessionKey);
+            config.logger?.info?.(`[openclaw-opencode-bridge] OpenCode session created: key=${args.sessionKey} id=${sessionId}`);
+            return new OpenCodeSessionRuntime(client, config, sessionId);
+        },
+    };
+}
+export default createOpenCodeSdkAdapter;

package/openclaw.plugin.json

@@ -1,18 +1,34 @@
 {
   "id": "openclaw-opencode-bridge",
   "name": "OpenCode Bridge",
-  "description": "Bridge OpenClaw gateway chat.send/chat.action with OpenCode SDK streams",
+  "description": "Bridge OpenClaw gateway chat.send/chat.action with built-in OpenCode SDK runtime",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {
-      "sdkAdapterModule": {
+      "opencodeBaseUrl": {
         "type": "string",
-        "description": "Node module specifier or path to SDK adapter module (optional if OPENCODE_SDK_ADAPTER_MODULE is set)"
+        "description": "OpenCode server base URL used by @opencode-ai/sdk (default: http://127.0.0.1:4096)"
       },
-      "sdkAdapterExport": {
+      "opencodeDirectory": {
         "type": "string",
-        "description": "Export name from sdkAdapterModule (default: createOpenCodeSdkAdapter)"
+        "description": "Workspace directory passed to OpenCode SDK requests"
+      },
+      "opencodeAgent": {
+        "type": "string",
+        "description": "Optional OpenCode agent id used by session.promptAsync"
+      },
+      "opencodeProviderId": {
+        "type": "string",
+        "description": "Optional provider id for model override"
+      },
+      "opencodeModelId": {
+        "type": "string",
+        "description": "Optional model id for model override (requires opencodeProviderId)"
+      },
+      "opencodeSystemPrompt": {
+        "type": "string",
+        "description": "Optional system prompt sent with each chat message"
       },
       "sessionTtlMs": {
         "type": "integer",
@@ -29,13 +45,29 @@
     }
   },
   "uiHints": {
-    "sdkAdapterModule": {
-      "label": "SDK Adapter Module",
-      "help": "Absolute/relative path or npm package that exports OpenCode SDK adapter."
+    "opencodeBaseUrl": {
+      "label": "OpenCode Base URL",
+      "help": "Defaults to http://127.0.0.1:4096. You can also use env OPENCODE_BASE_URL."
+    },
+    "opencodeDirectory": {
+      "label": "OpenCode Directory",
+      "help": "You can also use env OPENCODE_WORKSPACE_DIR."
+    },
+    "opencodeAgent": {
+      "label": "OpenCode Agent",
+      "help": "You can also use env OPENCODE_AGENT."
+    },
+    "opencodeProviderId": {
+      "label": "OpenCode Provider",
+      "help": "You can also use env OPENCODE_PROVIDER_ID."
+    },
+    "opencodeModelId": {
+      "label": "OpenCode Model",
+      "help": "You can also use env OPENCODE_MODEL_ID."
     },
-    "sdkAdapterExport": {
-      "label": "SDK Adapter Export",
-      "help": "Export name in the adapter module. Default is createOpenCodeSdkAdapter."
+    "opencodeSystemPrompt": {
+      "label": "OpenCode System Prompt",
+      "help": "You can also use env OPENCODE_SYSTEM_PROMPT."
     },
     "sessionTtlMs": {
       "label": "Session TTL (ms)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sw-market/openclaw-opencode-bridge",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OpenClaw plugin bridge for OpenCode realtime streaming and interaction actions",
   "type": "module",
   "main": "dist/index.js",
@@ -29,6 +29,9 @@
       "./dist/openclaw-extension.js"
     ]
   },
+  "dependencies": {
+    "@opencode-ai/sdk": "^1.2.15"
+  },
   "devDependencies": {
     "@types/node": "^22.15.0",
     "rimraf": "^6.0.1",