@wu529778790/open-im 1.11.8-beta.2 → 1.11.8-beta.3

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

@@ -1,10 +1,5 @@
-/**
- * OpenCode Adapter — run tasks through OpenCode CLI (`opencode run`)
- */
 import type { RunCallbacks, RunHandle, RunOptions, ToolAdapter } from './tool-adapter.interface.js';
 export declare class OpenCodeAdapter implements ToolAdapter {
-    private cliPath;
     readonly toolId = "opencode";
-    constructor(cliPath: string);
     run(prompt: string, sessionId: string | undefined, workDir: string, callbacks: RunCallbacks, options?: RunOptions): RunHandle;
 }

package/dist/adapters/opencode-adapter.js

@@ -1,15 +1,8 @@
-/**
- * OpenCode Adapter — run tasks through OpenCode CLI (`opencode run`)
- */
-import { runOpenCode } from '../opencode/cli-runner.js';
+import { runOpenCodeSdk } from '../opencode/sdk-runner.js';
 export class OpenCodeAdapter {
-    cliPath;
     toolId = 'opencode';
-    constructor(cliPath) {
-        this.cliPath = cliPath;
-    }
     run(prompt, sessionId, workDir, callbacks, options) {
-        return runOpenCode(this.cliPath, prompt, sessionId, workDir, {
+        const handle = runOpenCodeSdk(prompt, sessionId, workDir, {
             onText: callbacks.onText,
             onThinking: callbacks.onThinking,
             onToolUse: callbacks.onToolUse,
@@ -41,5 +34,10 @@ export class OpenCodeAdapter {
             skipPermissions: options?.skipPermissions,
             model: options?.model,
         });
+        return {
+            abort: () => {
+                handle.then(h => h.abort());
+            },
+        };
     }
 }

package/dist/adapters/registry.js

@@ -3,6 +3,7 @@ import { ClaudeSDKAdapter } from './claude-sdk-adapter.js';
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
 import { OpenCodeAdapter } from './opencode-adapter.js';
+import { startOpencode, stopOpencode, isOpencodeRunning } from '../opencode/sdk-manager.js';
 import { createLogger } from '../logger.js';
 import { destroyAllLiveChildren } from '../shared/process-kill.js';
 const log = createLogger('Registry');
@@ -15,7 +16,7 @@ const ADAPTER_FACTORIES = {
     claude: () => new ClaudeSDKAdapter(),
     codex: (c) => new CodexAdapter(c.codexCliPath),
     codebuddy: (c) => new CodeBuddyAdapter(c.codebuddyCliPath),
-    opencode: (c) => new OpenCodeAdapter(c.opencodeCliPath),
+    opencode: () => new OpenCodeAdapter(),
 };
 export function initAdapters(config) {
     adapters.clear();
@@ -27,6 +28,12 @@ export function initAdapters(config) {
         }
         log.info(`${aiCommand} adapter enabled`);
         adapters.set(aiCommand, factory(config));
+        // SDK 工具需要懒启动 server，这里先触发预热
+        if (aiCommand === 'opencode' && !isOpencodeRunning()) {
+            startOpencode().catch((err) => {
+                log.warn(`OpenCode SDK server prewarm failed (will retry on first use): ${err}`);
+            });
+        }
     }
 }
 export function getAdapter(aiCommand) {
@@ -34,6 +41,8 @@ export function getAdapter(aiCommand) {
 }
 export function cleanupAdapters() {
     ClaudeSDKAdapter.destroy();
+    // 关闭 opencode SDK server
+    stopOpencode();
     // 强制终止仍在运行的 CLI 子进程（Codex/CodeBuddy），避免僵尸 / 孤儿
     destroyAllLiveChildren();
     adapters.clear();

package/dist/config-web-page-i18n.d.ts

@@ -109,7 +109,7 @@ export declare const PAGE_TEXTS: {
         readonly claudeCli: "Claude CLI path";
         readonly codexCli: "Codex CLI path";
         readonly codebuddyCli: "CodeBuddy CLI path";
-        readonly opencodeCli: "OpenCode CLI path";
+        readonly opencodeSdkInfo: "OpenCode uses the built-in SDK integration. No CLI path needed.";
         readonly codexProxy: "Codex proxy";
         readonly codexApiKey: "OPENAI_API_KEY";
         readonly codexApiKeyTip: "Set the OpenAI API key used by Codex. You can also edit the auth file below.";
@@ -320,7 +320,7 @@ export declare const PAGE_TEXTS: {
         readonly claudeCli: "Claude CLI 路径";
         readonly codexCli: "Codex CLI 路径";
         readonly codebuddyCli: "CodeBuddy CLI 路径";
-        readonly opencodeCli: "OpenCode CLI 路径";
+        readonly opencodeSdkInfo: "OpenCode 使用 SDK 集成，无需配置 CLI 路径。";
         readonly codexProxy: "Codex 代理";
         readonly codexApiKey: "OPENAI_API_KEY";
         readonly codexApiKeyTip: "设置 Codex 使用的 OpenAI API Key。也可以在下方编辑 auth 文件。";

package/dist/config-web-page-i18n.js

@@ -109,7 +109,7 @@ export const PAGE_TEXTS = {
         claudeCli: "Claude CLI path",
         codexCli: "Codex CLI path",
         codebuddyCli: "CodeBuddy CLI path",
-        opencodeCli: "OpenCode CLI path",
+        opencodeSdkInfo: "OpenCode uses the built-in SDK integration. No CLI path needed.",
         codexProxy: "Codex proxy",
         codexApiKey: "OPENAI_API_KEY",
         codexApiKeyTip: "Set the OpenAI API key used by Codex. You can also edit the auth file below.",
@@ -321,7 +321,7 @@ export const PAGE_TEXTS = {
         claudeCli: "Claude CLI \u8def\u5f84",
         codexCli: "Codex CLI \u8def\u5f84",
         codebuddyCli: "CodeBuddy CLI \u8def\u5f84",
-        opencodeCli: "OpenCode CLI \u8def\u5f84",
+        opencodeSdkInfo: "OpenCode \u4f7f\u7528 SDK \u96c6\u6210\uff0c\u65e0\u9700\u914d\u7f6e CLI \u8def\u5f84\u3002",
         codexProxy: "Codex \u4ee3\u7406",
         codexApiKey: "OPENAI_API_KEY",
         codexApiKeyTip: "\u8bbe\u7f6e Codex \u4f7f\u7528\u7684 OpenAI API Key\u3002\u4e5f\u53ef\u4ee5\u5728\u4e0b\u65b9\u7f16\u8f91 auth \u6587\u4ef6\u3002",

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

@@ -0,0 +1,11 @@
+import type { OpencodeClient } from '@opencode-ai/sdk/v2/client';
+export declare function startOpencode(options?: {
+    hostname?: string;
+    port?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+}): Promise<OpencodeClient>;
+export declare function stopOpencode(): void;
+export declare function getOpencodeClient(): OpencodeClient;
+export declare function isOpencodeRunning(): boolean;
+export declare function connectToOpencode(baseUrl?: string): Promise<OpencodeClient>;

package/dist/opencode/sdk-manager.js

@@ -0,0 +1,46 @@
+import { createOpencode, createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { createLogger } from '../logger.js';
+const log = createLogger('OpenCodeSDK');
+let instance = null;
+export async function startOpencode(options) {
+    if (instance) {
+        log.info('OpenCode SDK already running');
+        return instance.client;
+    }
+    log.info('Starting OpenCode SDK server...');
+    const result = await createOpencode({
+        hostname: options?.hostname ?? '127.0.0.1',
+        port: options?.port ?? 0,
+        signal: options?.signal,
+        timeout: options?.timeout ?? 15000,
+    });
+    log.info(`OpenCode server started at ${result.server.url}`);
+    instance = result;
+    return instance.client;
+}
+export function stopOpencode() {
+    if (instance) {
+        log.info('Stopping OpenCode SDK server...');
+        instance.server.close();
+        instance = null;
+        log.info('OpenCode SDK server stopped');
+    }
+}
+export function getOpencodeClient() {
+    if (!instance) {
+        throw new Error('OpenCode SDK not started');
+    }
+    return instance.client;
+}
+export function isOpencodeRunning() {
+    return instance !== null;
+}
+export async function connectToOpencode(baseUrl) {
+    if (instance)
+        return instance.client;
+    const url = baseUrl ?? 'http://127.0.0.1:4096';
+    log.info(`Connecting to existing OpenCode server at ${url}`);
+    const client = createOpencodeClient({ baseUrl: url });
+    instance = { client, server: { url, close() { } } };
+    return client;
+}

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

@@ -0,0 +1,27 @@
+export interface OpenCodeSdkRunCallbacks {
+    onText: (accumulated: string) => void;
+    onThinking?: (accumulated: string) => void;
+    onToolUse?: (toolName: string, toolInput?: Record<string, unknown>) => void;
+    onComplete: (result: {
+        success: boolean;
+        result: string;
+        accumulated: string;
+        cost: number;
+        durationMs: number;
+        model?: string;
+        numTurns: number;
+        toolStats: Record<string, number>;
+    }) => void;
+    onError: (error: string) => void;
+    onSessionId?: (sessionId: string) => void;
+    onSessionInvalid?: () => void;
+}
+export interface OpenCodeSdkRunOptions {
+    skipPermissions?: boolean;
+    model?: string;
+}
+export interface OpenCodeSdkRunHandle {
+    abort: () => void;
+}
+export declare function runOpenCodeSdk(prompt: string, sessionId: string | undefined, workDir: string, callbacks: OpenCodeSdkRunCallbacks, options?: OpenCodeSdkRunOptions): Promise<OpenCodeSdkRunHandle>;
+export declare function clearSessionCache(workDir?: string): void;

package/dist/opencode/sdk-runner.js

@@ -0,0 +1,151 @@
+import { startOpencode } from './sdk-manager.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('OpenCodeSDKRunner');
+const sessionCache = new Map();
+function parseModel(modelStr) {
+    const slashIdx = modelStr.indexOf('/');
+    if (slashIdx > 0) {
+        return { providerID: modelStr.slice(0, slashIdx), modelID: modelStr.slice(slashIdx + 1) };
+    }
+    return { providerID: 'anthropic', modelID: modelStr };
+}
+export async function runOpenCodeSdk(prompt, sessionId, workDir, callbacks, options) {
+    const client = await startOpencode();
+    const abortController = new AbortController();
+    const startTime = Date.now();
+    let currentSessionId = sessionId;
+    if (!currentSessionId) {
+        currentSessionId = sessionCache.get(workDir);
+    }
+    if (!currentSessionId) {
+        try {
+            const projectName = workDir.split('/').filter(Boolean).pop() || 'project';
+            const result = await client.session.create({
+                directory: workDir,
+                title: `open-im: ${projectName}`,
+            });
+            currentSessionId = result.data?.id;
+            if (!currentSessionId) {
+                throw new Error('Session creation returned no ID');
+            }
+            sessionCache.set(workDir, currentSessionId);
+            callbacks.onSessionId?.(currentSessionId);
+            log.info(`Created session ${currentSessionId} for ${workDir}`);
+        }
+        catch (err) {
+            const msg = (err instanceof Error ? err.message : String(err));
+            log.error('Failed to create session:', msg);
+            callbacks.onError(msg);
+            return { abort: () => { } };
+        }
+    }
+    else {
+        log.info(`Using ${sessionId ? 'provided' : 'cached'} session ${currentSessionId}`);
+    }
+    let accumulatedText = '';
+    let accumulatedThinking = '';
+    const toolStats = {};
+    let runSettled = false;
+    const subscribeEvents = async () => {
+        try {
+            const sse = await client.global.event({ signal: abortController.signal });
+            for await (const raw of sse.stream) {
+                const ev = raw;
+                const payload = ev?.payload;
+                if (!payload?.properties)
+                    continue;
+                if (payload.properties.sessionID !== currentSessionId)
+                    continue;
+                switch (payload.type) {
+                    case 'session.next.text.delta': {
+                        const delta = payload.properties.delta;
+                        if (delta) {
+                            accumulatedText += delta;
+                            callbacks.onText(accumulatedText);
+                        }
+                        break;
+                    }
+                    case 'session.next.reasoning.delta': {
+                        const delta = payload.properties.delta;
+                        if (delta) {
+                            accumulatedThinking += delta;
+                            callbacks.onThinking?.(accumulatedThinking);
+                        }
+                        break;
+                    }
+                    case 'session.next.tool.called': {
+                        const tool = payload.properties.tool;
+                        if (tool) {
+                            toolStats[tool] = (toolStats[tool] || 0) + 1;
+                            callbacks.onToolUse?.(tool, payload.properties.input);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (!abortController.signal.aborted) {
+                log.debug('SSE stream ended:', err?.message);
+            }
+        }
+    };
+    const background = subscribeEvents();
+    try {
+        const result = await client.session.prompt({
+            sessionID: currentSessionId,
+            directory: workDir,
+            parts: [{ type: 'text', text: prompt }],
+            ...(options?.model ? { model: parseModel(options.model) } : {}),
+        });
+        abortController.abort();
+        await background.catch(() => { });
+        runSettled = true;
+        const data = result.data;
+        const parts = data?.parts ?? [];
+        const finalText = parts
+            .filter((p) => p.type === 'text' && typeof p.text === 'string')
+            .map(p => p.text)
+            .join('\n');
+        const cost = data?.info?.cost ?? 0;
+        callbacks.onComplete({
+            success: true,
+            result: finalText,
+            accumulated: accumulatedText || finalText,
+            cost,
+            durationMs: Date.now() - startTime,
+            numTurns: 1,
+            toolStats,
+        });
+    }
+    catch (err) {
+        abortController.abort();
+        await background.catch(() => { });
+        if (runSettled)
+            return { abort: () => { } };
+        const msg = (err instanceof Error ? err.message : String(err));
+        log.error('OpenCode SDK error:', msg);
+        if (/session\s*(not found|expired|corrupt)|no\s*session/i.test(msg)) {
+            sessionCache.delete(workDir);
+            callbacks.onSessionInvalid?.();
+        }
+        runSettled = true;
+        callbacks.onError(msg);
+    }
+    return {
+        abort: () => {
+            if (!abortController.signal.aborted) {
+                abortController.abort();
+                client.session.abort({ sessionID: currentSessionId }).catch(() => { });
+            }
+        },
+    };
+}
+export function clearSessionCache(workDir) {
+    if (workDir) {
+        sessionCache.delete(workDir);
+    }
+    else {
+        sessionCache.clear();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.11.8-beta.2",
+  "version": "1.11.8-beta.3",
   "description": "Your AI coding assistant, in every chat app. Multi-platform IM bridge for Claude Code, Codex, and CodeBuddy.",
   "type": "module",
   "main": "dist/index.js",
@@ -55,6 +55,7 @@
     "@anthropic-ai/sdk": "^0.104.2",
     "@aws-sdk/client-s3": "^3.1035.0",
     "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@opencode-ai/sdk": "^1.17.9",
     "@sentry/node": "^10.58.0",
     "centrifuge": "^5.5.3",
     "dingtalk-stream": "^2.1.4",