@kafca/agentdock 0.1.44 → 0.1.46

package/dist-electron/services/local-ai-core/src/runtime/server.js

@@ -3,11 +3,288 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalAiCoreServer = void 0;
 const node_http_1 = require("node:http");
 const server_routes_js_1 = require("./server-routes.js");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
+class OpenAiChatCompletionStreamAdapter {
+    options;
+    created = Math.floor(Date.now() / 1000);
+    completionId;
+    assistantPreviewContentByHandle = new Map();
+    thoughtContentByHandle = new Map();
+    emittedMessageIds = new Set();
+    closed = false;
+    roleSent = false;
+    constructor(options) {
+        this.options = options;
+        this.completionId = `chatcmpl_${sanitizeOpenAiId(options.runId)}`;
+    }
+    start() {
+        this.options.response.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive',
+        });
+        this.sendChunk({ role: 'assistant' }, {
+            event: 'run_started',
+            kind: 'assistant',
+            run_id: this.options.runId,
+        });
+        this.roleSent = true;
+    }
+    handleBridgeEvent(event) {
+        if (this.closed || String(event.replyCtx || '') !== this.options.runId) {
+            return;
+        }
+        if (!this.roleSent) {
+            this.start();
+        }
+        if (event.type === 'typing_stop') {
+            this.finish('stop', { event: 'run_finished', kind: 'status' });
+            return;
+        }
+        if ((event.type === 'status' || event.type === 'card') && event.error) {
+            this.error(event.error, 'runtime_error');
+            return;
+        }
+        if (event.type === 'buttons' && event.bridgeKind === 'permission') {
+            this.error('Unexpected permission request for yolo OpenAI chat run.', 'unexpected_permission_request');
+            return;
+        }
+        if (event.type === 'preview_start' || event.type === 'update_message') {
+            this.handlePreviewEvent(event);
+            return;
+        }
+        if (event.type === 'reply') {
+            this.handleReplyEvent(event);
+            return;
+        }
+        if (event.type === 'status' || event.type === 'card') {
+            this.sendChunk({}, {
+                event: event.type,
+                kind: event.bridgeKind || 'status',
+                run_id: this.options.runId,
+                content: event.content,
+                ok: event.ok,
+                card: event.card,
+            });
+        }
+    }
+    replayMessage(input) {
+        if (this.closed || this.emittedMessageIds.has(input.id)) {
+            return;
+        }
+        this.emittedMessageIds.add(input.id);
+        const event = {
+            type: 'reply',
+            replyCtx: this.options.runId,
+            messageId: input.id,
+            content: input.content,
+            bridgeKind: input.bridgeKind,
+            bridgeStatus: input.bridgeStatus,
+            toolCall: input.toolCall,
+        };
+        this.handleReplyEvent(event);
+    }
+    finish(finishReason = 'stop', agentdock = {}) {
+        if (this.closed) {
+            return;
+        }
+        const chunk = this.baseChunk({}, {
+            run_id: this.options.runId,
+            ...agentdock,
+        }, finishReason);
+        this.options.response.write(createOpenAiSseData(chunk));
+        this.options.response.write(createOpenAiDone());
+        this.closed = true;
+        this.options.onClose();
+        this.options.response.end();
+    }
+    error(message, code = 'runtime_error') {
+        if (this.closed) {
+            return;
+        }
+        const chunk = this.baseChunk({}, {
+            run_id: this.options.runId,
+            event: 'error',
+            kind: 'status',
+        });
+        chunk.error = {
+            message,
+            type: code,
+            code,
+        };
+        this.options.response.write(createOpenAiSseData(chunk));
+        this.options.response.write(createOpenAiDone());
+        this.closed = true;
+        this.options.onClose();
+        this.options.response.end();
+    }
+    handlePreviewEvent(event) {
+        const content = String(event.content || '');
+        const handle = String(event.previewHandle || event.messageId || event.replyCtx || '');
+        if (!content || !handle) {
+            return;
+        }
+        if (event.bridgeKind === 'thought') {
+            const prior = this.thoughtContentByHandle.get(handle) || '';
+            const delta = diffAccumulatedText(prior, content);
+            this.thoughtContentByHandle.set(handle, content);
+            if (!delta) {
+                return;
+            }
+            this.sendProgressChunk(this.progressText('thinking', delta), {
+                event: 'thought_delta',
+                kind: 'thought',
+                run_id: this.options.runId,
+                thought: {
+                    content,
+                    delta,
+                    preview_handle: handle,
+                },
+            });
+            return;
+        }
+        if (event.bridgeKind && event.bridgeKind !== 'assistant') {
+            return;
+        }
+        const prior = this.assistantPreviewContentByHandle.get(handle) || '';
+        const delta = diffAccumulatedText(prior, content);
+        this.assistantPreviewContentByHandle.set(handle, content);
+        if (!delta) {
+            return;
+        }
+        this.sendChunk({ content: delta }, {
+            event: 'assistant_delta',
+            kind: 'assistant',
+            run_id: this.options.runId,
+            preview_handle: handle,
+        });
+    }
+    handleReplyEvent(event) {
+        const content = String(event.content || '');
+        if (event.messageId) {
+            if (this.emittedMessageIds.has(event.messageId)) {
+                return;
+            }
+            this.emittedMessageIds.add(event.messageId);
+        }
+        if (event.bridgeKind === 'tool') {
+            this.sendProgressChunk(this.formatToolProgressContent(event), {
+                event: 'tool_update',
+                kind: 'tool',
+                run_id: this.options.runId,
+                message_id: event.messageId,
+                tool: event.toolCall || {
+                    output: content,
+                },
+            });
+            return;
+        }
+        if (event.bridgeKind === 'plan') {
+            this.sendProgressChunk(this.progressText('plan', content), {
+                event: 'plan_update',
+                kind: 'plan',
+                run_id: this.options.runId,
+                message_id: event.messageId,
+                plan: {
+                    content,
+                },
+            });
+            return;
+        }
+        if (event.bridgeKind === 'thought') {
+            this.sendProgressChunk(this.progressText('thinking', content), {
+                event: 'thought_message',
+                kind: 'thought',
+                run_id: this.options.runId,
+                message_id: event.messageId,
+                thought: {
+                    content,
+                    delta: content,
+                },
+            });
+            return;
+        }
+        if (event.bridgeKind === 'status' || event.bridgeKind === 'permission') {
+            this.sendProgressChunk(this.progressText(event.bridgeKind, content), {
+                event: event.bridgeKind === 'permission' ? 'permission_required' : 'status',
+                kind: event.bridgeKind,
+                run_id: this.options.runId,
+                message_id: event.messageId,
+                content,
+                bridge_status: event.bridgeStatus,
+            });
+            return;
+        }
+        if (content) {
+            this.sendChunk({ content }, {
+                event: 'assistant_message',
+                kind: 'assistant',
+                run_id: this.options.runId,
+                message_id: event.messageId,
+            });
+        }
+    }
+    sendProgressChunk(content, agentdock) {
+        this.sendChunk(this.options.progressMode === 'content' && content ? { content } : {}, agentdock);
+    }
+    sendChunk(delta, agentdock, finishReason = null) {
+        if (this.closed) {
+            return;
+        }
+        this.options.response.write(createOpenAiSseData(this.baseChunk(delta, agentdock, finishReason)));
+    }
+    baseChunk(delta, agentdock, finishReason = null) {
+        return {
+            id: this.completionId,
+            object: 'chat.completion.chunk',
+            created: this.created,
+            model: this.options.model,
+            choices: [
+                {
+                    index: 0,
+                    delta,
+                    finish_reason: finishReason,
+                },
+            ],
+            agentdock,
+        };
+    }
+    progressText(kind, content) {
+        return content ? `\n\n[${kind}]\n${content}` : '';
+    }
+    formatToolProgressContent(event) {
+        const tool = event.toolCall;
+        const name = tool?.name || tool?.label || 'tool';
+        const status = tool?.status || '';
+        const output = tool?.output || tool?.detail || event.content || '';
+        return output ? `\n\n[tool:${name}${status ? ` ${status}` : ''}]\n${output}` : '';
+    }
+}
 function json(res, statusCode, data, ok = true, error) {
     res.statusCode = statusCode;
     res.setHeader('Content-Type', 'application/json; charset=utf-8');
     res.end(JSON.stringify(ok ? { ok: true, data } : { ok: false, error }));
 }
+function rawJson(res, statusCode, data) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify(data));
+}
+function openAiJsonError(res, statusCode, message, code = 'invalid_request_error') {
+    rawJson(res, statusCode, {
+        error: {
+            message,
+            type: code,
+            code,
+        },
+    });
+}
+function jsonError(res, statusCode, error) {
+    const info = (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error);
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+    res.end(JSON.stringify((0, local_core_errors_js_1.errorInfoToHttpBody)(info)));
+}
 async function readJsonBody(req) {
     const body = await readRawBody(req);
     if (!body.length) {
@@ -34,24 +311,174 @@ function setCorsHeaders(req, res) {
 function createSseEvent(name, payload) {
     return `event: ${name}\ndata: ${JSON.stringify(payload)}\n\n`;
 }
+function createOpenAiSseData(payload) {
+    return `data: ${JSON.stringify(payload)}\n\n`;
+}
+function createOpenAiDone() {
+    return 'data: [DONE]\n\n';
+}
+function sanitizeOpenAiId(value) {
+    return String(value || '')
+        .replace(/[^A-Za-z0-9_-]/g, '_')
+        .slice(0, 120) || 'run';
+}
+function diffAccumulatedText(previous, next) {
+    if (!next) {
+        return '';
+    }
+    if (!previous) {
+        return next;
+    }
+    if (next.startsWith(previous)) {
+        return next.slice(previous.length);
+    }
+    if (previous === next) {
+        return '';
+    }
+    return next;
+}
+function isTerminalAgentTaskStatus(status) {
+    return status === 'completed' || status === 'failed' || status === 'cancelled';
+}
+function extractMetadataValue(metadata, key) {
+    const value = metadata[key];
+    return String(value === undefined || value === null ? '' : value).trim();
+}
+function parseOpenAiChatCompletionRequest(input) {
+    const metadata = input.metadata && typeof input.metadata === 'object' && !Array.isArray(input.metadata)
+        ? input.metadata
+        : {};
+    const userId = extractMetadataValue(metadata, 'user_id') || String(input.user || '').trim();
+    const projectId = extractMetadataValue(metadata, 'project_id');
+    if (!userId) {
+        throw new Error('metadata.user_id is required.');
+    }
+    if (!projectId) {
+        throw new Error('metadata.project_id is required.');
+    }
+    const unsupported = [
+        input.tools !== undefined ? 'tools' : '',
+        input.tool_choice !== undefined ? 'tool_choice' : '',
+        input.response_format !== undefined ? 'response_format' : '',
+        input.audio !== undefined ? 'audio' : '',
+        input.logprobs !== undefined ? 'logprobs' : '',
+    ].filter(Boolean);
+    if (unsupported.length > 0) {
+        throw new Error(`Unsupported OpenAI chat field(s): ${unsupported.join(', ')}.`);
+    }
+    if (input.n !== undefined && Number(input.n) !== 1) {
+        throw new Error('Only n=1 is supported.');
+    }
+    const messages = Array.isArray(input.messages) ? input.messages : [];
+    if (messages.length === 0) {
+        throw new Error('messages must contain at least one text message.');
+    }
+    const prompt = messages
+        .map((message) => formatOpenAiMessage(message))
+        .filter(Boolean)
+        .join('\n\n');
+    if (!prompt.trim()) {
+        throw new Error('messages must contain text content.');
+    }
+    const progressMode = extractMetadataValue(metadata, 'agentdock_progress_mode') === 'content'
+        ? 'content'
+        : 'extension';
+    const model = String(input.model || extractMetadataValue(metadata, 'model') || '').trim();
+    const externalRun = {
+        user_id: userId,
+        external_project_id: projectId,
+        external_thread_id: extractMetadataValue(metadata, 'thread_id') || undefined,
+        display_name: extractMetadataValue(metadata, 'display_name') || undefined,
+        agent_type: extractMetadataValue(metadata, 'agent_type') || 'pi',
+        provider_id: extractMetadataValue(metadata, 'provider_id') || undefined,
+        model: model || undefined,
+        title: extractMetadataValue(metadata, 'title') || undefined,
+        metadata: {
+            ...metadata,
+            openai_compatible: true,
+        },
+        prompt,
+        permission_mode: 'bypassPermissions',
+        runtime_env: {
+            AGENTDOCK_OPENAI_COMPAT: '1',
+        },
+    };
+    return {
+        externalRun,
+        model: model || externalRun.agent_type || 'agentdock',
+        stream: Boolean(input.stream),
+        progressMode,
+    };
+}
+function formatOpenAiMessage(message) {
+    const role = String(message?.role || 'user').trim() || 'user';
+    const content = extractOpenAiMessageText(message?.content);
+    if (!content.trim()) {
+        return '';
+    }
+    if (role === 'user') {
+        return content;
+    }
+    return `[${role}]\n${content}`;
+}
+function extractOpenAiMessageText(content) {
+    if (typeof content === 'string') {
+        return content;
+    }
+    if (content === null || content === undefined) {
+        return '';
+    }
+    if (!Array.isArray(content)) {
+        throw new Error('Only text message content is supported.');
+    }
+    return content.map((part) => {
+        const type = String(part?.type || 'text');
+        if (type !== 'text') {
+            throw new Error(`Only text message parts are supported; received ${type}.`);
+        }
+        return String(part?.text || '');
+    }).join('');
+}
+function collectAssistantMessagesForRun(snapshot) {
+    const thread = snapshot.thread;
+    const startedAt = Date.parse(snapshot.task?.startedAt || snapshot.task?.createdAt || '');
+    if (!thread || !Number.isFinite(startedAt)) {
+        return [];
+    }
+    return (thread.messages || []).filter((message) => {
+        if (message.role !== 'assistant') {
+            return false;
+        }
+        const messageAt = Date.parse(message.timestamp || '');
+        return Number.isFinite(messageAt) && messageAt >= startedAt;
+    });
+}
 class LocalAiCoreServer {
     bindings;
     host;
     port;
     sseClients = new Set();
     heartbeatTimers = new Map();
+    externalReplayTimers = new Map();
+    externalRunSseClients = new Map();
+    openAiRunStreams = new Map();
     server = (0, node_http_1.createServer)((req, res) => {
         void this.handleRequest(req, res);
     });
     constructor(bindings, options = {}) {
         this.bindings = bindings;
         this.host = options.host || '127.0.0.1';
-        this.port = options.port || 9831;
+        this.port = options.port ?? 9831;
         this.bindings.on('runtime', (runtime) => {
             this.broadcast({ type: 'runtime.updated', runtime });
         });
         this.bindings.on('bridge', (bridge) => {
             this.broadcast({ type: 'stream.updated', stream: bridge });
+            if (bridge.replyCtx) {
+                const runId = String(bridge.replyCtx);
+                this.broadcastExternalRunStream(runId, bridge);
+                this.broadcastOpenAiRunStream(runId, bridge);
+            }
             if (bridge.sessionKey) {
                 const threadId = this.findThreadIdFromSessionKey(bridge.sessionKey);
                 this.broadcast({
@@ -99,6 +526,22 @@ class LocalAiCoreServer {
             clearInterval(timer);
         }
         this.heartbeatTimers.clear();
+        for (const timer of this.externalReplayTimers.values()) {
+            clearInterval(timer);
+        }
+        this.externalReplayTimers.clear();
+        for (const clients of this.externalRunSseClients.values()) {
+            for (const client of clients) {
+                client.end();
+            }
+        }
+        this.externalRunSseClients.clear();
+        for (const adapters of this.openAiRunStreams.values()) {
+            for (const adapter of adapters) {
+                adapter.finish('stop', { event: 'server_stopped', kind: 'status' });
+            }
+        }
+        this.openAiRunStreams.clear();
         await new Promise((resolve, reject) => {
             this.server.close((error) => {
                 if (error) {
@@ -124,10 +567,10 @@ class LocalAiCoreServer {
                 await this.handleParsedRoute(route, req, res, url);
                 return;
             }
-            json(res, 404, null, false, `Unknown route: ${path}`);
+            jsonError(res, 404, new Error(`Unknown route: ${path}`));
         }
         catch (error) {
-            json(res, 500, null, false, error instanceof Error ? error.message : String(error));
+            jsonError(res, 500, error);
         }
     }
     async handleParsedRoute(route, req, res, url) {
@@ -329,6 +772,38 @@ class LocalAiCoreServer {
             case 'workspace-registry.delete':
                 json(res, 200, await this.bindings.deleteWorkspaceRegistryEntry(route.workspaceId));
                 return;
+            case 'providers.list':
+                json(res, 200, await this.bindings.listModelProviders());
+                return;
+            case 'providers.create': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createModelProvider(body));
+                return;
+            }
+            case 'provider.update': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.updateModelProvider(route.providerId, body));
+                return;
+            }
+            case 'provider.delete':
+                json(res, 200, await this.bindings.deleteModelProvider(route.providerId));
+                return;
+            case 'external.project.ensure': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.ensureExternalProject(body));
+                return;
+            }
+            case 'external.run.create': {
+                const body = await readJsonBody(req);
+                json(res, 200, await this.bindings.createExternalRun(body));
+                return;
+            }
+            case 'external.run.events':
+                await this.attachExternalRunSseClient(route.runId, res);
+                return;
+            case 'openai.chat.completions':
+                await this.handleOpenAiChatCompletions(req, res);
+                return;
             case 'workspace-security.get':
                 json(res, 200, await this.bindings.getWorkspaceSecuritySettings(route.workspaceId));
                 return;
@@ -474,6 +949,15 @@ class LocalAiCoreServer {
             case 'capabilities.snapshot':
                 json(res, 200, await this.bindings.getCapabilitySnapshot());
                 return;
+            case 'diagnostics.errors':
+                json(res, 200, { errors: await this.bindings.listDiagnosticErrors() });
+                return;
+            case 'diagnostics.doctor':
+                json(res, 200, await this.bindings.runDiagnosticsDoctor());
+                return;
+            case 'diagnostics.deployment':
+                json(res, 200, await this.bindings.runDeploymentDiagnostics());
+                return;
             case 'plugins.diagnostics':
                 json(res, 200, await this.bindings.getPluginDiagnostics());
                 return;
@@ -499,7 +983,7 @@ class LocalAiCoreServer {
             case 'platform.qrcode.status': {
                 const ticket = String(url.searchParams.get('ticket') || '');
                 if (!ticket) {
-                    json(res, 400, null, false, 'Missing ticket parameter');
+                    jsonError(res, 400, new Error('Missing ticket parameter'));
                     return;
                 }
                 json(res, 200, await this.bindings.checkChannelQrCodeStatus(route.platform, route.workspaceId, ticket, this.channelInstanceId(url)));
@@ -560,12 +1044,232 @@ class LocalAiCoreServer {
             this.sseClients.delete(res);
         });
     }
+    async attachExternalRunSseClient(runId, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive',
+        });
+        res.write(': connected\n\n');
+        const clients = this.externalRunSseClients.get(runId) || new Set();
+        clients.add(res);
+        this.externalRunSseClients.set(runId, clients);
+        const replayedMessageIds = new Set();
+        const heartbeat = setInterval(() => {
+            res.write(': heartbeat\n\n');
+        }, 15000);
+        this.heartbeatTimers.set(res, heartbeat);
+        const replayTimer = setInterval(() => {
+            void this.bindings.getExternalRunSnapshot(runId)
+                .then((snapshot) => this.replayExternalRunMessages(res, runId, snapshot, replayedMessageIds))
+                .catch(() => undefined);
+        }, 1000);
+        this.externalReplayTimers.set(res, replayTimer);
+        res.on('close', () => {
+            clearInterval(heartbeat);
+            clearInterval(replayTimer);
+            this.heartbeatTimers.delete(res);
+            this.externalReplayTimers.delete(res);
+            clients.delete(res);
+            if (clients.size === 0) {
+                this.externalRunSseClients.delete(runId);
+            }
+        });
+        const snapshot = await this.bindings.getExternalRunSnapshot(runId);
+        res.write(createSseEvent('external.run.snapshot', {
+            type: 'external.run.snapshot',
+            snapshot,
+        }));
+        this.replayExternalRunMessages(res, runId, snapshot, replayedMessageIds);
+    }
+    async handleOpenAiChatCompletions(req, res) {
+        let parsed;
+        try {
+            parsed = parseOpenAiChatCompletionRequest(await readJsonBody(req));
+        }
+        catch (error) {
+            openAiJsonError(res, 400, error instanceof Error ? error.message : String(error));
+            return;
+        }
+        if (parsed.stream) {
+            await this.handleOpenAiStreamingChatCompletion(parsed, res);
+            return;
+        }
+        await this.handleOpenAiNonStreamingChatCompletion(parsed, res);
+    }
+    async handleOpenAiStreamingChatCompletion(parsed, res) {
+        try {
+            const created = await this.bindings.createExternalRun(parsed.externalRun);
+            const adapters = this.openAiRunStreams.get(created.run_id) || new Set();
+            const adapter = new OpenAiChatCompletionStreamAdapter({
+                runId: created.run_id,
+                model: parsed.model,
+                response: res,
+                progressMode: parsed.progressMode,
+                onClose: () => {
+                    adapters.delete(adapter);
+                    if (adapters.size === 0) {
+                        this.openAiRunStreams.delete(created.run_id);
+                    }
+                },
+            });
+            adapters.add(adapter);
+            this.openAiRunStreams.set(created.run_id, adapters);
+            adapter.start();
+            res.on('close', () => {
+                adapters.delete(adapter);
+                if (adapters.size === 0) {
+                    this.openAiRunStreams.delete(created.run_id);
+                }
+            });
+            const snapshot = await this.bindings.getExternalRunSnapshot(created.run_id);
+            this.replayOpenAiRunMessages(adapter, snapshot);
+            if (isTerminalAgentTaskStatus(snapshot.task?.status)) {
+                adapter.finish('stop', { event: 'run_finished', kind: 'status' });
+            }
+        }
+        catch (error) {
+            openAiJsonError(res, 500, error instanceof Error ? error.message : String(error), 'agentdock_run_error');
+        }
+    }
+    async handleOpenAiNonStreamingChatCompletion(parsed, res) {
+        let created;
+        try {
+            created = await this.bindings.createExternalRun(parsed.externalRun);
+        }
+        catch (error) {
+            openAiJsonError(res, 500, error instanceof Error ? error.message : String(error), 'agentdock_run_error');
+            return;
+        }
+        const started = Date.now();
+        const timeoutMs = 10 * 60 * 1000;
+        let snapshot = await this.bindings.getExternalRunSnapshot(created.run_id);
+        while (!isTerminalAgentTaskStatus(snapshot.task?.status) && Date.now() - started < timeoutMs) {
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            snapshot = await this.bindings.getExternalRunSnapshot(created.run_id);
+        }
+        if (!isTerminalAgentTaskStatus(snapshot.task?.status)) {
+            openAiJsonError(res, 504, 'OpenAI-compatible chat completion timed out waiting for the agent run.', 'run_timeout');
+            return;
+        }
+        if (snapshot.task?.status === 'failed') {
+            openAiJsonError(res, 500, snapshot.task.error || 'Agent run failed.', 'agentdock_run_failed');
+            return;
+        }
+        if (snapshot.task?.status === 'cancelled') {
+            openAiJsonError(res, 500, snapshot.task.error || 'Agent run was cancelled.', 'agentdock_run_cancelled');
+            return;
+        }
+        const messages = collectAssistantMessagesForRun(snapshot);
+        const finalContent = messages
+            .filter((message) => message.kind === 'final' || !message.bridgeKind || message.bridgeKind === 'assistant')
+            .map((message) => message.content)
+            .filter(Boolean)
+            .join('\n\n');
+        const response = {
+            id: `chatcmpl_${sanitizeOpenAiId(created.run_id)}`,
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: parsed.model,
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: finalContent,
+                    },
+                    finish_reason: 'stop',
+                },
+            ],
+            agentdock: {
+                run_id: created.run_id,
+                workspace_id: created.workspace_id,
+                thread_id: created.thread_id,
+                task_id: created.task_id,
+                events: messages
+                    .filter((message) => message.bridgeKind && message.bridgeKind !== 'assistant')
+                    .map((message) => ({
+                    event: `${message.bridgeKind}_update`,
+                    kind: message.bridgeKind,
+                    content: message.content,
+                    tool: message.toolCall,
+                })),
+            },
+        };
+        rawJson(res, 200, response);
+    }
     broadcast(event) {
         const payload = createSseEvent(event.type, event);
         for (const client of this.sseClients) {
             client.write(payload);
         }
     }
+    broadcastExternalRunStream(runId, stream) {
+        const clients = this.externalRunSseClients.get(runId);
+        if (!clients?.size) {
+            return;
+        }
+        const payload = createSseEvent('external.run.stream', {
+            type: 'external.run.stream',
+            runId,
+            stream,
+        });
+        for (const client of clients) {
+            client.write(payload);
+        }
+    }
+    broadcastOpenAiRunStream(runId, stream) {
+        const adapters = this.openAiRunStreams.get(runId);
+        if (!adapters?.size) {
+            return;
+        }
+        for (const adapter of adapters) {
+            adapter.handleBridgeEvent(stream);
+        }
+    }
+    replayOpenAiRunMessages(adapter, snapshot) {
+        for (const message of collectAssistantMessagesForRun(snapshot)) {
+            adapter.replayMessage({
+                id: message.id,
+                content: message.content,
+                bridgeKind: message.bridgeKind,
+                bridgeStatus: message.bridgeStatus,
+                toolCall: message.toolCall,
+            });
+        }
+    }
+    replayExternalRunMessages(res, runId, snapshot, replayedMessageIds) {
+        const thread = snapshot.thread;
+        const startedAt = Date.parse(snapshot.task?.startedAt || snapshot.task?.createdAt || '');
+        if (!thread || !Number.isFinite(startedAt)) {
+            return;
+        }
+        for (const message of thread.messages || []) {
+            if (message.role !== 'assistant') {
+                continue;
+            }
+            const messageAt = Date.parse(message.timestamp || '');
+            if (!Number.isFinite(messageAt) || messageAt < startedAt) {
+                continue;
+            }
+            if (replayedMessageIds.has(message.id)) {
+                continue;
+            }
+            replayedMessageIds.add(message.id);
+            res.write(createSseEvent('external.run.stream', {
+                type: 'external.run.stream',
+                runId,
+                stream: {
+                    type: message.kind === 'final' ? 'reply' : 'update_message',
+                    sessionKey: thread.bridgeSessionKey,
+                    replyCtx: runId,
+                    content: message.content,
+                    bridgeKind: message.bridgeKind,
+                    bridgeStatus: message.bridgeStatus,
+                },
+            }));
+        }
+    }
     async runtimeDetectionResponse() {
         return {
             runtimes: await this.bindings.listInstalledAgentRuntimes(),