@foxden-app/foxclaw 0.7.3 → 0.11.0

package/dist/opencode/adapter.d.ts

@@ -0,0 +1,11 @@
+import type { IEngineAdapter, EngineModel, EngineTurnRequest, EngineTurnExecution } from '../core/engine_spi.js';
+import type { OpencodeAppClient } from './client.js';
+export declare class OpencodeEngineAdapter implements IEngineAdapter {
+    private readonly client;
+    private readonly defaultModel?;
+    readonly id = "opencode";
+    readonly name = "OpenCode (SDK)";
+    constructor(client: OpencodeAppClient, defaultModel?: string | undefined);
+    listModels(): Promise<EngineModel[]>;
+    executeTurn(request: EngineTurnRequest): EngineTurnExecution;
+}

package/dist/opencode/adapter.js

@@ -0,0 +1,169 @@
+import { EventEmitter } from 'node:events';
+import { formatSdkError } from './client.js';
+import { buildAttachmentPrompt } from '../telegram/media.js';
+export class OpencodeEngineAdapter {
+    client;
+    defaultModel;
+    id = 'opencode';
+    name = 'OpenCode (SDK)';
+    constructor(client, defaultModel) {
+        this.client = client;
+        this.defaultModel = defaultModel;
+    }
+    async listModels() {
+        if (!this.client.isConnected())
+            return [];
+        try {
+            const response = await this.client.getClient().provider.list();
+            if (response.error || !response.data)
+                return [];
+            const { all, connected, default: defaultMap } = response.data;
+            const models = [];
+            for (const providerId of connected) {
+                const provider = all.find((p) => p.id === providerId);
+                if (!provider)
+                    continue;
+                const defaultForProvider = defaultMap[providerId];
+                for (const m of Object.values(provider.models)) {
+                    const modelFullId = `${providerId}/${m.id}`;
+                    models.push({
+                        id: modelFullId,
+                        name: `${provider.name} - ${m.name}`,
+                        isDefault: m.id === defaultForProvider,
+                    });
+                }
+            }
+            return models;
+        }
+        catch {
+            return [];
+        }
+    }
+    executeTurn(request) {
+        const emitter = new EventEmitter();
+        let sessionId = request.threadId;
+        let cancelled = false;
+        let promptText = request.prompt;
+        if (request.stagedAttachments && request.stagedAttachments.length > 0 && !request.prompt.includes('Telegram attachments:')) {
+            promptText = buildAttachmentPrompt(request.prompt, request.stagedAttachments);
+        }
+        let finalResult = null;
+        let turnError = null;
+        const resultWaiters = [];
+        const resolveWaiters = (res) => {
+            while (resultWaiters.length > 0) {
+                resultWaiters.shift()(res);
+            }
+        };
+        const run = async () => {
+            try {
+                const sdk = this.client.getClient();
+                if (!sessionId) {
+                    const createRes = await sdk.session.create({ directory: request.cwd });
+                    if (createRes.error || !createRes.data) {
+                        throw new Error(`Failed to create OpenCode session: ${formatSdkError(createRes.error)}`);
+                    }
+                    sessionId = createRes.data.id;
+                    emitter.emit('conversation', sessionId);
+                }
+                if (cancelled)
+                    return;
+                let accumulatedResponse = '';
+                const onEvent = (ev) => {
+                    if ('sessionId' in ev && ev.sessionId === sessionId) {
+                        if (ev.kind === 'text') {
+                            if (ev.delta) {
+                                accumulatedResponse += ev.delta;
+                                emitter.emit('delta', ev.delta);
+                            }
+                        }
+                        else if (ev.kind === 'tool') {
+                            emitter.emit('tool', {
+                                name: ev.tool,
+                                args: undefined,
+                                output: undefined,
+                                status: ev.status === 'running' ? 'running' : ev.status === 'error' ? 'failed' : 'completed',
+                            });
+                        }
+                        else if (ev.kind === 'idle') {
+                            cleanup();
+                            finalResult = {
+                                kind: 'result',
+                                status: 'SUCCESS',
+                                response: accumulatedResponse,
+                                conversationId: sessionId,
+                            };
+                            emitter.emit('result', finalResult);
+                            resolveWaiters(finalResult);
+                        }
+                        else if (ev.kind === 'error') {
+                            cleanup();
+                            turnError = new Error(ev.message);
+                            finalResult = {
+                                kind: 'result',
+                                status: 'ERROR',
+                                response: ev.message,
+                                conversationId: sessionId,
+                            };
+                            emitter.emit('result', finalResult);
+                            emitter.emit('error', turnError);
+                            resolveWaiters(finalResult);
+                        }
+                    }
+                };
+                const cleanup = () => {
+                    this.client.off('event', onEvent);
+                };
+                this.client.on('event', onEvent);
+                let modelParam;
+                const targetModel = request.model || this.defaultModel;
+                if (targetModel && targetModel.includes('/')) {
+                    const [pId, ...mRest] = targetModel.split('/');
+                    modelParam = { providerID: pId, modelID: mRest.join('/') };
+                }
+                const promptRes = await sdk.session.promptAsync({
+                    sessionID: sessionId,
+                    directory: request.cwd,
+                    parts: [{ type: 'text', text: promptText }],
+                    ...(modelParam ? { model: modelParam } : {}),
+                });
+                if (promptRes.error) {
+                    cleanup();
+                    turnError = new Error(formatSdkError(promptRes.error));
+                    emitter.emit('error', turnError);
+                    resolveWaiters(null);
+                }
+                else {
+                    this.client.watchSessionUntilIdle(sessionId, request.cwd);
+                }
+            }
+            catch (err) {
+                turnError = err instanceof Error ? err : new Error(String(err));
+                emitter.emit('error', turnError);
+                resolveWaiters(null);
+            }
+        };
+        void run();
+        return {
+            turnId: sessionId ?? undefined,
+            cancel: () => {
+                cancelled = true;
+                if (sessionId) {
+                    void this.client.getClient().session.abort({ sessionID: sessionId }).catch(() => { });
+                }
+            },
+            waitForResult: async () => {
+                if (finalResult)
+                    return finalResult;
+                if (turnError)
+                    return null;
+                return new Promise((resolve) => {
+                    resultWaiters.push(resolve);
+                });
+            },
+            on: (event, listener) => {
+                emitter.on(event, listener);
+            },
+        };
+    }
+}

package/dist/opencode/controller.js

@@ -720,7 +720,7 @@ export class OpencodeBridgeCore {
         const model = index >= 0 ? models[index] : models.find((item) => `${item.providerId}/${item.modelId}` === normalized || item.modelId === normalized || storeModel(item.providerId, item.modelId) === normalized);
         if (!model)
             throw new Error(localize(locale, `未知模型：${raw}`, `Unknown model: ${raw}`));
-        this.store.setChatSettings(scopeId, storeModel(model.providerId, model.modelId), null);
+        this.store.setChatModel(scopeId, storeModel(model.providerId, model.modelId));
         const prefs = readPrefs(this.store.getChatSettings(scopeId));
         if (prefs.variant && !model.variants.includes(prefs.variant))
             this.writePrefs(scopeId, { ...prefs, variant: null });
@@ -1792,7 +1792,7 @@ export class OpencodeBridgeCore {
                 }
                 else {
                     const parsed = parseStoredModel(action.value);
-                    this.store.setChatSettings(event.scopeId, action.value, null);
+                    this.store.setChatModel(event.scopeId, action.value);
                     this.writePrefs(event.scopeId, { ...readPrefs(this.store.getChatSettings(event.scopeId)), variant: null });
                     answer = `${parsed.providerId}/${parsed.modelId}`;
                 }

package/dist/store/database.d.ts

@@ -1,4 +1,5 @@
 import type { AccessPresetValue, ActiveTurnMessageMode, AppLocale, CachedThread, ChatSessionSettings, CollaborationModeValue, GuidedPlanSessionRecord, GuidedPlanSessionState, PendingAttachmentBatchRecord, PendingAttachmentBatchStatus, PendingApprovalRecord, QueuedTurnInputRecord, QueuedTurnInputStatus, ReasoningEffortValue, ThreadBinding } from '../types.js';
+import type { CumulativeTokenTotals, CumulativeTokenUsageRecord, TokenUsageDelta } from './token_usage.js';
 export interface ActiveTurnPreviewRecord {
     turnId: string;
     scopeId: string;
@@ -58,17 +59,50 @@ export declare class BridgeStore {
         scopeId: string;
         chatId: string;
     } | null;
+    migrateTelegramUnnamespacedScope(botId: string, chatId: string): void;
     getBinding(chatId: string): ThreadBinding | null;
     setBinding(chatId: string, threadId: string, cwd: string | null): void;
     listBindings(): ThreadBinding[];
     clearBinding(chatId: string): void;
+    getWatchedThread(chatId: string): string | null;
+    setWatchedThread(chatId: string, threadId: string | null): void;
+    listWatchedThreads(): Array<{
+        scopeId: string;
+        threadId: string;
+    }>;
     getChatSettings(chatId: string): ChatSessionSettings | null;
     setChatSettings(chatId: string, model: string | null, reasoningEffort: ReasoningEffortValue | null, locale?: AppLocale | null): void;
+    setChatModel(chatId: string, model: string | null): void;
+    setChatEffort(chatId: string, effort: ReasoningEffortValue | null): void;
     setChatLocale(chatId: string, locale: AppLocale): void;
     setChatAccessPreset(chatId: string, accessPreset: AccessPresetValue | null): void;
     setChatCollaborationMode(chatId: string, collaborationMode: CollaborationModeValue | null): void;
     setChatServiceTier(chatId: string, serviceTier: string | null): void;
     setChatActiveTurnMessageMode(chatId: string, activeTurnMessageMode: ActiveTurnMessageMode | null): void;
+    getActiveBackend(chatId: string): string | null;
+    setActiveBackend(chatId: string, backendId: string | null): void;
+    getScopeBackendBinding(scopeId: string, backendId: string): {
+        threadId: string;
+        cwd: string | null;
+        model?: string | null;
+        reasoningEffort?: string | null;
+        activeTurnMessageMode?: string | null;
+        serviceTier?: string | null;
+        accessPreset?: string | null;
+    } | null;
+    setScopeBackendBinding(scopeId: string, backendId: string, threadId: string, cwd: string | null, settings?: {
+        model?: string | null;
+        reasoningEffort?: string | null;
+        activeTurnMessageMode?: string | null;
+        serviceTier?: string | null;
+        accessPreset?: string | null;
+    } | null): void;
+    listScopeBackendBindings(scopeId: string): Array<{
+        backendId: string;
+        threadId: string;
+        cwd: string | null;
+        updatedAt: number;
+    }>;
     findChatIdByThreadId(threadId: string): string | null;
     findAllChatIdsByThreadId(threadId: string): string[];
     countBindings(): number;
@@ -141,5 +175,15 @@ export declare class BridgeStore {
     getCodexAuthPoolStats(): CodexAuthPoolStats;
     setCodexAuthQuotaSnapshot(runtimeId: string, candidateName: string, accountId: string, quotaIdentityId: string, snapshot: Pick<CodexAuthQuotaSnapshotRecord, 'capturedAtMs' | 'planType' | 'primaryWindowDurationMins' | 'primaryRemainingPercent' | 'secondaryWindowDurationMins' | 'secondaryRemainingPercent'> & Partial<Pick<CodexAuthQuotaSnapshotRecord, 'primaryResetsAt' | 'secondaryResetsAt'>>): void;
     listCodexAuthQuotaSnapshots(quotaIdentityIds: string[]): CodexAuthQuotaSnapshotRecord[];
+    recordTokenUsage(delta: TokenUsageDelta, backendId?: string): void;
+    setBackendCumulativeTokenUsage(usage: {
+        inputTokens: number;
+        outputTokens: number;
+        cachedTokens?: number;
+        totalTokens?: number;
+        turnsCount?: number;
+    }, backendId: string): void;
+    getCumulativeTokenUsage(backendId?: string): CumulativeTokenTotals;
+    getAllBackendTokenUsages(): CumulativeTokenUsageRecord[];
     private ensureColumn;
 }