ysk-omni 1.0.0

package/dist/services/chat.service.js

@@ -0,0 +1,1088 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatService = exports.ChatService = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const database_1 = require("../config/database");
+const constants_1 = require("../config/constants");
+const exception_factory_1 = require("../exceptions/exception.factory");
+const model_allowlist_1 = require("../utils/model-allowlist");
+const http_exception_1 = require("../exceptions/http.exception");
+const id_1 = require("../utils/id");
+const fs_safe_1 = require("../utils/fs-safe");
+const prisma_bytes_1 = require("../utils/prisma-bytes");
+const openai_mapper_1 = require("../utils/openai-mapper");
+const stream_1 = require("../utils/stream");
+const logger_1 = require("../utils/logger");
+const audit_service_1 = require("./audit.service");
+const document_service_1 = require("./document.service");
+const encryption_service_1 = require("./encryption.service");
+const engine_slot_service_1 = require("./engine-slot.service");
+const echo_1 = require("./runtimes/echo");
+const engine_manager_1 = require("./runtimes/engine-manager");
+const llama_server_1 = require("./runtimes/llama-server");
+const vllm_1 = require("./runtimes/vllm");
+const registry_1 = require("./hf/registry");
+const engine_session_map_service_1 = require("./engine-session-map.service");
+const policy_service_1 = require("./policy.service");
+const settings_service_1 = require("./settings.service");
+const chat_queue_service_1 = require("./queue/chat-queue.service");
+const job_waiter_1 = require("./queue/job-waiter");
+const queue_policy_service_1 = require("./queue/queue-policy.service");
+const anthropic_mapper_1 = require("../utils/anthropic-mapper");
+const api_features_service_1 = require("./api-features.service");
+const chat_request_builder_service_1 = require("./chat-request-builder.service");
+const message_content_1 = require("../utils/message-content");
+const vision_remote_1 = require("../utils/vision-remote");
+function policyToRunOpts(policy, base) {
+    return {
+        ...(base.extra || {}),
+        prompt: base.prompt,
+        model: base.model,
+        stream: base.stream,
+        sessionId: base.sessionId,
+        promptJson: base.promptJson,
+        jsonSchema: base.jsonSchema,
+        toolsAllowlist: base.toolsAllowlist ?? policy.toolsAllowlist,
+        toolsDenylist: base.toolsDenylist ?? policy.toolsDenylist,
+        // Policy always wins — client extra must not override jail / approve.
+        cwd: policy.cwd,
+        timeoutMs: policy.timeoutMs,
+        alwaysApprove: policy.alwaysApprove,
+        maxTurns: policy.maxTurns,
+    };
+}
+class ChatService {
+    /**
+     * Public entry: enqueue when queue enabled, else run immediately.
+     */
+    async createCompletion(dto, ctx, res, options) {
+        if (options?.fromQueue) {
+            return this.executeCompletion(dto, ctx, res, options);
+        }
+        const qPolicy = await queue_policy_service_1.queuePolicyService.get();
+        if (qPolicy.enabled) {
+            return this.createCompletionQueued(dto, ctx, res, options?.source || 'v1', options?.idempotencyKey, options);
+        }
+        return this.executeCompletion(dto, ctx, res, options);
+    }
+    /** Enqueue + wait (stream holds SSE until worker finishes). */
+    async createCompletionQueued(dto, ctx, res, source = 'v1', idempotencyKey, options) {
+        const stream = Boolean(dto.stream);
+        const wireFormat = options?.wireFormat || 'openai';
+        const suppressQueue = options?.suppressQueueEvents || wireFormat !== 'openai';
+        const enq = await chat_queue_service_1.chatQueueService.enqueue({
+            dto,
+            ctx,
+            source,
+            idempotencyKey,
+            wireFormat,
+        });
+        const { jobId, position, policy } = enq;
+        if (enq.alreadyDone) {
+            // Idempotent replay: do not re-run. Stream clients get a terminal queue event.
+            if (stream && res) {
+                if (!res.headersSent)
+                    (0, stream_1.initSse)(res);
+                if (!suppressQueue) {
+                    (0, stream_1.writeSseData)(res, {
+                        object: 'gog.queue',
+                        status: 'succeeded',
+                        job_id: jobId,
+                        result_chat_request_id: enq.resultChatRequestId ?? null,
+                        message: 'Idempotent replay: job already completed',
+                    });
+                    (0, stream_1.writeSseDone)(res);
+                }
+                else {
+                    // Protocol-native clients cannot consume gog.queue — fail clearly
+                    (0, stream_1.writeSseEvent)(res, 'error', {
+                        type: 'error',
+                        error: {
+                            type: 'invalid_request_error',
+                            message: 'Idempotent request already completed; omit Idempotency-Key to start a new job',
+                        },
+                    });
+                }
+                res.end();
+                return;
+            }
+            throw exception_factory_1.ExceptionFactory.validation('Idempotent request already completed; omit Idempotency-Key to start a new job');
+        }
+        const ee = job_waiter_1.jobWaiterRegistry.register(jobId, res);
+        if (stream) {
+            if (!res)
+                throw exception_factory_1.ExceptionFactory.internal('Streaming requires Response');
+            if (!res.headersSent) {
+                (0, stream_1.initSse)(res);
+            }
+            if (!suppressQueue) {
+                (0, stream_1.writeSseData)(res, {
+                    object: 'gog.queue',
+                    status: 'queued',
+                    job_id: jobId,
+                    position,
+                    message: `Queued (position ${position})`,
+                });
+                ee.on('queue', (ev) => {
+                    if (!res.writableEnded) {
+                        (0, stream_1.writeSseData)(res, {
+                            object: 'gog.queue',
+                            status: 'queued',
+                            job_id: jobId,
+                            position: ev.position,
+                        });
+                    }
+                });
+            }
+        }
+        // Position updates while waiting
+        const posTimer = setInterval(() => {
+            void chat_queue_service_1.chatQueueService.estimatePosition(jobId).then((p) => {
+                if (p > 0)
+                    job_waiter_1.jobWaiterRegistry.emitQueue(jobId, p);
+            });
+        }, 2000);
+        const maxWait = policy.maxWaitMs;
+        try {
+            const result = await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    reject(exception_factory_1.ExceptionFactory.queueTimeout());
+                }, maxWait);
+                const onAbort = () => {
+                    void chat_queue_service_1.chatQueueService.requestCancel(jobId);
+                };
+                res?.on('close', onAbort);
+                ee.once('done', (ev) => {
+                    clearTimeout(timer);
+                    res?.off('close', onAbort);
+                    resolve(ev.result);
+                });
+                ee.once('error', (ev) => {
+                    clearTimeout(timer);
+                    res?.off('close', onAbort);
+                    reject(ev.error);
+                });
+            });
+            return result;
+        }
+        catch (err) {
+            if (stream && res && !res.writableEnded) {
+                const message = err instanceof Error ? err.message : 'Queue error';
+                (0, stream_1.writeSseData)(res, {
+                    error: {
+                        message,
+                        type: 'server_error',
+                        code: err instanceof http_exception_1.HttpException ? err.code : 'queue_error',
+                    },
+                });
+                (0, stream_1.writeSseDone)(res);
+                res.end();
+            }
+            throw err;
+        }
+        finally {
+            clearInterval(posTimer);
+            job_waiter_1.jobWaiterRegistry.cleanup(jobId);
+        }
+    }
+    /**
+     * Run completion (worker or direct). Does not enqueue.
+     */
+    async executeCompletion(dto, ctx, res, options) {
+        const settings = await settings_service_1.settingsService.getAll();
+        const features = await api_features_service_1.apiFeaturesService.get();
+        const model = dto.model || settings.defaultModel || echo_1.ECHO_MODEL_ID;
+        (0, model_allowlist_1.assertModelAllowed)(ctx.apiKey, model);
+        const stream = Boolean(dto.stream);
+        if ((0, echo_1.isEchoModel)(model)) {
+            return this.executeEchoCompletion(dto, ctx, res, model, stream);
+        }
+        const gguf = (0, registry_1.findEntry)(model);
+        const wantsLlama = Boolean(gguf?.path?.toLowerCase().endsWith('.gguf')) ||
+            gguf?.runtime === 'llamacpp';
+        const wantsVllm = gguf?.runtime === 'vllm' || (Boolean(gguf) && !wantsLlama);
+        if (wantsLlama || wantsVllm) {
+            if (wantsLlama && !(0, llama_server_1.llamaServerBin)()) {
+                throw exception_factory_1.ExceptionFactory.engineUnconfigured(`llama-server is not on PATH; cannot serve ${model}. Install llama.cpp or use model=echo`);
+            }
+            if (wantsVllm && !wantsLlama && !(0, vllm_1.vllmAvailable)()) {
+                throw exception_factory_1.ExceptionFactory.engineUnconfigured(`vllm is not on PATH; cannot serve ${model}. Install vLLM or use model=echo`);
+            }
+            if (stream && res) {
+                return this.executeLlamaStream(dto, ctx, res, model);
+            }
+            const completion = await engine_manager_1.engineManager.chatJson(model, dto.messages || []);
+            return this.executeLocalCompletion(dto, ctx, res, model, stream, completion);
+        }
+        // OTP sessions use synthetic ids — ChatRequest.apiKeyId requires a real key row
+        const { toPersistentApiKeyId } = await Promise.resolve().then(() => __importStar(require('../utils/api-key-id')));
+        const ownerApiKeyId = await toPersistentApiKeyId(ctx.apiKey.id);
+        const includeReasoning = dto.include_reasoning !== false;
+        const policy = await policy_service_1.policyService.resolve(ctx.apiKey, dto.cwd);
+        // Feature gates + feature mapping (tools, vision, schema, effort, …)
+        const hasRemoteImages = dto.messages.some((m) => (0, message_content_1.messageHasImageParts)(m.content));
+        if (hasRemoteImages && features.vision) {
+            dto.messages = await (0, vision_remote_1.inlineRemoteImageUrls)(dto.messages);
+        }
+        const builtReq = (0, chat_request_builder_service_1.buildEngineRequestFromChatDto)(dto, policy, features);
+        const documentIds = [
+            ...new Set((dto.document_ids ?? []).filter((id) => typeof id === 'string' && id)),
+        ];
+        // Materialize under policy.cwd/attachments so tools use relative paths only
+        // (avoids absolute host paths in the prompt). Cleaned up after the request.
+        const requestSlug = (ctx.requestId || (0, id_1.createId)()).replace(/[^a-zA-Z0-9_-]/g, '');
+        const attachRel = node_path_1.default.join('attachments', requestSlug);
+        const visionFiles = builtReq.visionFiles ?? [];
+        const attachDir = documentIds.length > 0 || visionFiles.length > 0
+            ? node_path_1.default.join(policy.cwd, attachRel)
+            : '';
+        let docContext = '';
+        let materializedCount = 0;
+        try {
+            if (documentIds.length > 0) {
+                await (0, fs_safe_1.ensureDir)(attachDir);
+                // Use persistent owner id (same mapping as upload) so OTP session
+                // synthetic ids can still attach documents they just uploaded.
+                const built = await document_service_1.documentService.buildContextFromDocuments(ownerApiKeyId, documentIds, constants_1.MAX_DOCUMENT_CONTEXT_CHARS, {
+                    materializeDir: attachDir,
+                    pathPrefix: attachRel,
+                });
+                docContext = built.context;
+                materializedCount = built.files.length;
+                logger_1.logger.info({
+                    requestId: ctx.requestId,
+                    apiKeyId: ctx.apiKey.id,
+                    documentCount: documentIds.length,
+                    materializedCount,
+                    contextChars: docContext.length,
+                    attachDir: attachRel,
+                }, 'Document context prepared for local engine');
+            }
+            if (visionFiles.length > 0) {
+                await (0, fs_safe_1.ensureDir)(attachDir);
+                for (const file of visionFiles) {
+                    await node_fs_1.promises.writeFile(node_path_1.default.join(attachDir, file.filename), file.bytes, {
+                        mode: 0o600,
+                    });
+                }
+            }
+            let prompt = builtReq.prompt;
+            if (docContext) {
+                prompt =
+                    `The user has attached the following documents for this request. ` +
+                        `Use their contents (and on-disk paths when tools allow) when answering.\n\n${docContext}\n\n` +
+                        prompt;
+            }
+            if (visionFiles.length > 0 && !builtReq.promptJson) {
+                const listed = visionFiles
+                    .map((f) => `${attachRel}/${f.filename}`)
+                    .join(', ');
+                prompt =
+                    `The user attached image file(s) at: ${listed}. Read those files when answering.\n\n` +
+                        prompt;
+            }
+            if (prompt.length > constants_1.MAX_TOTAL_PROMPT_CHARS) {
+                throw exception_factory_1.ExceptionFactory.validation(`Total prompt exceeds ${constants_1.MAX_TOTAL_PROMPT_CHARS} characters`);
+            }
+            const extra = { ...builtReq.extra };
+            // Never pass raw client resume / OS-global --continue (cross-tenant).
+            extra.continueSession = false;
+            const sessionHint = dto.session_id?.trim() || extra.resumeSessionId || '';
+            extra.resumeSessionId = undefined;
+            extra.sessionId = extra.sessionId;
+            extra.forkSession = Boolean(extra.forkSession && sessionHint);
+            if (sessionHint) {
+                const binding = await engine_session_map_service_1.engineSessionMapService.resolve(ctx.apiKey.id, sessionHint);
+                if (binding.mode === 'resume') {
+                    extra.resumeSessionId = binding.engineSessionId;
+                    extra.sessionId = undefined;
+                }
+                else {
+                    extra.sessionId = binding.engineSessionId;
+                }
+            }
+            const runBase = {
+                prompt,
+                model,
+                stream: true,
+                sessionId: extra.sessionId,
+                apiKeyId: ctx.apiKey.id,
+                toolsAllowlist: builtReq.toolsAllowlist,
+                toolsDenylist: builtReq.toolsDenylist,
+                promptJson: builtReq.promptJson,
+                jsonSchema: builtReq.jsonSchema,
+                extra,
+            };
+            // Queue worker already limits concurrency; direct mode still uses in-process slots
+            const fromQueue = Boolean(options?.fromQueue);
+            if (!fromQueue && !engine_slot_service_1.engineSlotService.tryAcquire()) {
+                throw exception_factory_1.ExceptionFactory.concurrencyLimit();
+            }
+            if (fromQueue) {
+                // Soft acquire so stats still reflect load (best-effort)
+                engine_slot_service_1.engineSlotService.tryAcquire();
+            }
+            const chatRequestDbId = (0, id_1.createId)();
+            const completionId = (0, id_1.createChatCompletionId)();
+            const promptEnc = encryption_service_1.encryptionService.encrypt(prompt);
+            const started = Date.now();
+            await database_1.prisma.chatRequest.create({
+                data: {
+                    id: chatRequestDbId,
+                    requestId: ctx.requestId,
+                    apiKeyId: ownerApiKeyId,
+                    model,
+                    stream,
+                    status: constants_1.CHAT_STATUS.PENDING,
+                    promptCiphertext: (0, prisma_bytes_1.toBytes)(promptEnc.ciphertext),
+                    promptIv: (0, prisma_bytes_1.toBytes)(promptEnc.iv),
+                    promptTag: (0, prisma_bytes_1.toBytes)(promptEnc.tag),
+                    ip: ctx.ip,
+                    userAgent: ctx.userAgent,
+                    policyMode: policy.mode,
+                    documents: {
+                        create: documentIds.map((documentId) => ({ documentId })),
+                    },
+                },
+            });
+            try {
+                // Stream only when we still have a live HTTP Response (client connected).
+                // Queue workers often lose `res` after client disconnect, process restart,
+                // or multi-instance reclaim — never DLQ those; complete offline instead.
+                const canStreamToClient = Boolean(stream && res && !res.writableEnded && !res.destroyed);
+                if (stream && !canStreamToClient) {
+                    if (!options?.fromQueue && !res) {
+                        throw exception_factory_1.ExceptionFactory.internal('Streaming requires Response');
+                    }
+                    logger_1.logger.warn({
+                        requestId: ctx.requestId,
+                        jobId: options?.jobId,
+                        fromQueue: Boolean(options?.fromQueue),
+                        hasRes: Boolean(res),
+                        writableEnded: res?.writableEnded,
+                        destroyed: res?.destroyed,
+                    }, 'Stream completion without live Response — collecting offline');
+                }
+                if (canStreamToClient && res) {
+                    await this.runStream({
+                        dto,
+                        ctx,
+                        res,
+                        model,
+                        policy,
+                        prompt,
+                        completionId,
+                        chatRequestDbId,
+                        started,
+                        includeReasoning,
+                        skipRoleChunk: Boolean(options?.sseAlreadyInit),
+                        jobId: options?.jobId,
+                        wireFormat: options?.wireFormat || 'openai',
+                        suppressQueueEvents: Boolean(options?.suppressQueueEvents),
+                        runOpts: policyToRunOpts(policy, runBase),
+                        usageEstimate: features.usageEstimate,
+                        estimatedPromptTokens: builtReq.estimatedPromptTokens,
+                    });
+                    return;
+                }
+                const collected = await this.collectFromEngineStream(policyToRunOpts(policy, runBase));
+                await this.rememberEngineSession(ctx.apiKey.id, dto.session_id, collected.sessionId);
+                const auditPayload = this.buildAuditPayload(collected, includeReasoning);
+                const responseEnc = encryption_service_1.encryptionService.encrypt(auditPayload);
+                const durationMs = Date.now() - started;
+                await database_1.prisma.chatRequest.update({
+                    where: { id: chatRequestDbId },
+                    data: {
+                        status: constants_1.CHAT_STATUS.SUCCESS,
+                        durationMs,
+                        engineSessionId: collected.sessionId ?? null,
+                        responseCiphertext: (0, prisma_bytes_1.toBytes)(responseEnc.ciphertext),
+                        responseIv: (0, prisma_bytes_1.toBytes)(responseEnc.iv),
+                        responseTag: (0, prisma_bytes_1.toBytes)(responseEnc.tag),
+                    },
+                });
+                await audit_service_1.auditService.log({
+                    apiKeyId: ctx.apiKey.id,
+                    action: constants_1.AUDIT_ACTIONS.CHAT_CREATE,
+                    resource: 'chat_request',
+                    resourceId: chatRequestDbId,
+                    meta: {
+                        requestId: ctx.requestId,
+                        model,
+                        stream: false,
+                        durationMs,
+                        documentCount: documentIds.length,
+                        includeReasoning,
+                        hasReasoning: collected.reasoning.length > 0,
+                        policyMode: policy.mode,
+                    },
+                    ip: ctx.ip,
+                });
+                const { usageToOpenAi, engineUsageToMetaCost } = await Promise.resolve().then(() => __importStar(require('../utils/engine-event-parse')));
+                let usage = usageToOpenAi(collected.usage);
+                let usageEstimated = false;
+                if (!collected.usage &&
+                    features.usageEstimate) {
+                    const outTok = (0, chat_request_builder_service_1.estimateCompletionTokens)(collected.text);
+                    usage = {
+                        prompt_tokens: builtReq.estimatedPromptTokens,
+                        completion_tokens: outTok,
+                        total_tokens: builtReq.estimatedPromptTokens + outTok,
+                    };
+                    usageEstimated = true;
+                }
+                const completion = (0, openai_mapper_1.mapEngineToChatCompletion)(model, {
+                    text: collected.text,
+                    stopReason: collected.stopReason,
+                    sessionId: collected.sessionId,
+                    requestId: collected.requestId,
+                }, {
+                    completionId,
+                    reasoningContent: collected.reasoning || null,
+                    includeReasoning,
+                    usage,
+                    toolCalls: collected.toolCalls,
+                    omni: {
+                        sessionId: collected.sessionId,
+                        stopReason: collected.stopReason,
+                        requestId: collected.requestId,
+                        numTurns: collected.numTurns,
+                        cost: engineUsageToMetaCost(collected.usage),
+                    },
+                });
+                if (usageEstimated) {
+                    completion.usage_estimated = true;
+                }
+                return completion;
+            }
+            catch (err) {
+                await this.markFailed(chatRequestDbId, started, err);
+                throw err;
+            }
+            finally {
+                engine_slot_service_1.engineSlotService.release();
+            }
+        }
+        finally {
+            if (attachDir) {
+                await (0, fs_safe_1.rmSafe)(attachDir);
+            }
+        }
+    }
+    async executeEchoCompletion(dto, ctx, res, model, stream) {
+        return this.executeLocalCompletion(dto, ctx, res, model, stream, (0, echo_1.echoCompletion)(model, dto.messages || []));
+    }
+    async executeLocalCompletion(dto, ctx, res, model, stream, completion) {
+        const { toPersistentApiKeyId } = await Promise.resolve().then(() => __importStar(require('../utils/api-key-id')));
+        const ownerApiKeyId = await toPersistentApiKeyId(ctx.apiKey.id);
+        const chatRequestDbId = (0, id_1.createId)();
+        const started = Date.now();
+        const promptEnc = encryption_service_1.encryptionService.encrypt(JSON.stringify(dto.messages || []));
+        await database_1.prisma.chatRequest.create({
+            data: {
+                id: chatRequestDbId,
+                requestId: ctx.requestId,
+                apiKeyId: ownerApiKeyId,
+                model,
+                stream,
+                status: constants_1.CHAT_STATUS.PENDING,
+                promptCiphertext: (0, prisma_bytes_1.toBytes)(promptEnc.ciphertext),
+                promptIv: (0, prisma_bytes_1.toBytes)(promptEnc.iv),
+                promptTag: (0, prisma_bytes_1.toBytes)(promptEnc.tag),
+                ip: ctx.ip,
+                userAgent: ctx.userAgent,
+                policyMode: 'safe',
+            },
+        });
+        const responseEnc = encryption_service_1.encryptionService.encrypt(completion.choices[0]?.message?.content || '');
+        await database_1.prisma.chatRequest.update({
+            where: { id: chatRequestDbId },
+            data: {
+                status: constants_1.CHAT_STATUS.SUCCESS,
+                durationMs: Date.now() - started,
+                responseCiphertext: (0, prisma_bytes_1.toBytes)(responseEnc.ciphertext),
+                responseIv: (0, prisma_bytes_1.toBytes)(responseEnc.iv),
+                responseTag: (0, prisma_bytes_1.toBytes)(responseEnc.tag),
+            },
+        });
+        if (stream && res) {
+            (0, stream_1.initSse)(res);
+            const text = String(completion.choices[0]?.message?.content || '');
+            const id = completion.id;
+            const created = completion.created;
+            (0, stream_1.writeSseData)(res, (0, openai_mapper_1.mapRoleChunk)(model, id, created));
+            (0, stream_1.writeSseData)(res, (0, openai_mapper_1.mapTextDeltaChunk)(model, text, id, created));
+            (0, stream_1.writeSseDone)(res);
+            res.end();
+            return;
+        }
+        return completion;
+    }
+    async executeLlamaStream(dto, ctx, res, model) {
+        const { toPersistentApiKeyId } = await Promise.resolve().then(() => __importStar(require('../utils/api-key-id')));
+        const ownerApiKeyId = await toPersistentApiKeyId(ctx.apiKey.id);
+        const chatRequestDbId = (0, id_1.createId)();
+        const promptEnc = encryption_service_1.encryptionService.encrypt(JSON.stringify(dto.messages || []));
+        await database_1.prisma.chatRequest.create({
+            data: {
+                id: chatRequestDbId,
+                requestId: ctx.requestId,
+                apiKeyId: ownerApiKeyId,
+                model,
+                stream: true,
+                status: constants_1.CHAT_STATUS.PENDING,
+                promptCiphertext: (0, prisma_bytes_1.toBytes)(promptEnc.ciphertext),
+                promptIv: (0, prisma_bytes_1.toBytes)(promptEnc.iv),
+                promptTag: (0, prisma_bytes_1.toBytes)(promptEnc.tag),
+                ip: ctx.ip,
+                userAgent: ctx.userAgent,
+                policyMode: 'safe',
+            },
+        });
+        const upstream = await engine_manager_1.engineManager.chatStream(model, dto.messages || []);
+        if (!res.headersSent)
+            (0, stream_1.initSse)(res);
+        const reader = upstream.body?.getReader();
+        if (!reader) {
+            throw exception_factory_1.ExceptionFactory.engineUnconfigured('llama-server returned an empty stream');
+        }
+        const decoder = new TextDecoder();
+        let raw = '';
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const chunk = typeof value === 'string' ? value : decoder.decode(value, { stream: true });
+            raw += chunk;
+            res.write(chunk);
+        }
+        if (!res.writableEnded)
+            res.end();
+        const responseEnc = encryption_service_1.encryptionService.encrypt(raw.slice(0, 8000));
+        await database_1.prisma.chatRequest.update({
+            where: { id: chatRequestDbId },
+            data: {
+                status: constants_1.CHAT_STATUS.SUCCESS,
+                durationMs: 0,
+                responseCiphertext: (0, prisma_bytes_1.toBytes)(responseEnc.ciphertext),
+                responseIv: (0, prisma_bytes_1.toBytes)(responseEnc.iv),
+                responseTag: (0, prisma_bytes_1.toBytes)(responseEnc.tag),
+            },
+        });
+    }
+    async rememberEngineSession(apiKeyId, clientSessionId, engineSessionId) {
+        if (!clientSessionId?.trim() || !engineSessionId)
+            return;
+        try {
+            await engine_session_map_service_1.engineSessionMapService.remember(apiKeyId, clientSessionId, engineSessionId);
+        }
+        catch (err) {
+            logger_1.logger.warn({ err, apiKeyId }, 'Failed to persist engine session alias');
+        }
+    }
+    async collectFromEngineStream(options) {
+        const textParts = [];
+        const reasoningParts = [];
+        const toolCalls = [];
+        let sessionId;
+        let stopReason;
+        let requestId;
+        let usage;
+        let numTurns;
+        const { parseEngineUsage, parseEngineToolCallEvent } = await Promise.resolve().then(() => __importStar(require('../utils/engine-event-parse')));
+        for await (const event of engine_slot_service_1.engineSlotService.stream({ ...options, stream: true })) {
+            if (event.type === 'thought' && typeof event.data === 'string') {
+                reasoningParts.push(event.data);
+            }
+            else if (event.type === 'text' && typeof event.data === 'string') {
+                textParts.push(event.data);
+            }
+            else if (event.type === 'end') {
+                if (typeof event.stopReason === 'string')
+                    stopReason = event.stopReason;
+                if (typeof event.sessionId === 'string')
+                    sessionId = event.sessionId;
+                if (typeof event.requestId === 'string')
+                    requestId = event.requestId;
+                if (event.usage)
+                    usage = parseEngineUsage(event.usage);
+                if (typeof event.num_turns === 'number')
+                    numTurns = event.num_turns;
+            }
+            else {
+                toolCalls.push(...parseEngineToolCallEvent(event));
+            }
+        }
+        return {
+            text: textParts.join(''),
+            reasoning: reasoningParts.join(''),
+            sessionId,
+            stopReason,
+            requestId,
+            usage,
+            numTurns,
+            toolCalls: toolCalls.length ? toolCalls : undefined,
+        };
+    }
+    buildAuditPayload(collected, includeReasoning) {
+        if (!includeReasoning || !collected.reasoning) {
+            return collected.text;
+        }
+        return JSON.stringify({
+            content: collected.text,
+            reasoning_content: collected.reasoning,
+        });
+    }
+    async runStream(args) {
+        const { dto, ctx, res, model, policy, prompt, completionId, chatRequestDbId, started, includeReasoning, skipRoleChunk, jobId, wireFormat = 'openai', suppressQueueEvents = false, runOpts, } = args;
+        const created = Math.floor(Date.now() / 1000);
+        const textParts = [];
+        const reasoningParts = [];
+        const toolCalls = [];
+        let engineSessionId;
+        let stopReason;
+        let engineRequestId;
+        let streamUsage;
+        let clientClosed = false;
+        const msgId = (0, id_1.createMessageId)();
+        const respId = (0, id_1.createResponseId)();
+        const outputItemId = `msg_${(0, id_1.createId)().replace(/-/g, '').slice(0, 20)}`;
+        const { parseEngineUsage, parseEngineToolCallEvent, usageToOpenAi, engineUsageToMetaCost, } = await Promise.resolve().then(() => __importStar(require('../utils/engine-event-parse')));
+        res.on('close', () => {
+            clientClosed = true;
+            if (jobId)
+                void chat_queue_service_1.chatQueueService.requestCancel(jobId);
+        });
+        if (!res.headersSent) {
+            (0, stream_1.initSse)(res);
+        }
+        if (wireFormat === 'openai') {
+            if (!skipRoleChunk) {
+                (0, stream_1.writeSseData)(res, (0, openai_mapper_1.mapRoleChunk)(model, completionId, created));
+            }
+            else {
+                (0, stream_1.writeSseData)(res, (0, openai_mapper_1.mapRoleChunk)(model, completionId, created));
+                if (!suppressQueueEvents) {
+                    (0, stream_1.writeSseData)(res, {
+                        object: 'gog.queue',
+                        status: 'running',
+                        job_id: jobId,
+                    });
+                }
+            }
+        }
+        else if (wireFormat === 'anthropic') {
+            (0, stream_1.writeSseEvent)(res, 'message_start', {
+                type: 'message_start',
+                message: {
+                    id: msgId,
+                    type: 'message',
+                    role: 'assistant',
+                    content: [],
+                    model,
+                    stop_reason: null,
+                    stop_sequence: null,
+                    usage: { input_tokens: 0, output_tokens: 0 },
+                },
+            });
+            (0, stream_1.writeSseEvent)(res, 'content_block_start', {
+                type: 'content_block_start',
+                index: 0,
+                content_block: { type: 'text', text: '' },
+            });
+        }
+        else if (wireFormat === 'responses') {
+            (0, stream_1.writeSseEvent)(res, 'response.created', {
+                type: 'response.created',
+                response: {
+                    id: respId,
+                    object: 'response',
+                    created_at: created,
+                    status: 'in_progress',
+                    model,
+                    output: [],
+                },
+            });
+            (0, stream_1.writeSseEvent)(res, 'response.output_item.added', {
+                type: 'response.output_item.added',
+                output_index: 0,
+                item: {
+                    type: 'message',
+                    id: outputItemId,
+                    status: 'in_progress',
+                    role: 'assistant',
+                    content: [],
+                },
+            });
+            (0, stream_1.writeSseEvent)(res, 'response.content_part.added', {
+                type: 'response.content_part.added',
+                output_index: 0,
+                content_index: 0,
+                part: { type: 'output_text', text: '', annotations: [] },
+            });
+        }
+        const streamOpts = runOpts ||
+            policyToRunOpts(policy, {
+                prompt,
+                model,
+                stream: true,
+                sessionId: dto.session_id,
+                apiKeyId: ctx.apiKey.id,
+            });
+        try {
+            for await (const event of engine_slot_service_1.engineSlotService.stream(streamOpts)) {
+                if (clientClosed)
+                    break;
+                if (event.type === 'thought' && typeof event.data === 'string') {
+                    reasoningParts.push(event.data);
+                    if (includeReasoning && wireFormat === 'openai') {
+                        (0, stream_1.writeSseData)(res, (0, openai_mapper_1.mapReasoningDeltaChunk)(model, event.data, completionId, created, true));
+                    }
+                }
+                else if (event.type === 'text' && typeof event.data === 'string') {
+                    textParts.push(event.data);
+                    if (wireFormat === 'openai') {
+                        (0, stream_1.writeSseData)(res, (0, openai_mapper_1.mapTextDeltaChunk)(model, event.data, completionId, created));
+                    }
+                    else if (wireFormat === 'anthropic') {
+                        (0, stream_1.writeSseEvent)(res, 'content_block_delta', {
+                            type: 'content_block_delta',
+                            index: 0,
+                            delta: { type: 'text_delta', text: event.data },
+                        });
+                    }
+                    else if (wireFormat === 'responses') {
+                        (0, stream_1.writeSseEvent)(res, 'response.output_text.delta', {
+                            type: 'response.output_text.delta',
+                            output_index: 0,
+                            content_index: 0,
+                            delta: event.data,
+                        });
+                    }
+                }
+                else if (event.type === 'end') {
+                    if (typeof event.stopReason === 'string')
+                        stopReason = event.stopReason;
+                    if (typeof event.sessionId === 'string')
+                        engineSessionId = event.sessionId;
+                    if (typeof event.requestId === 'string')
+                        engineRequestId = event.requestId;
+                    if (event.usage)
+                        streamUsage = parseEngineUsage(event.usage);
+                }
+                else {
+                    const evType = String(event.type || '');
+                    if (wireFormat === 'openai' &&
+                        (evType === 'tool_call' ||
+                            evType === 'tool_call_update' ||
+                            evType === 'plan')) {
+                        const rec = event;
+                        (0, stream_1.writeSseData)(res, {
+                            id: completionId,
+                            object: 'chat.completion.chunk',
+                            created,
+                            model,
+                            choices: [{ index: 0, delta: {}, finish_reason: null }],
+                            omni_event: {
+                                type: evType,
+                                toolCallId: typeof rec.toolCallId === 'string'
+                                    ? rec.toolCallId
+                                    : undefined,
+                                toolName: typeof rec.toolName === 'string' ? rec.toolName : undefined,
+                                status: typeof rec.status === 'string' ? rec.status : undefined,
+                                kind: typeof rec.kind === 'string' ? rec.kind : undefined,
+                                title: typeof rec.title === 'string' ? rec.title : undefined,
+                                rawInput: rec.rawInput,
+                                entries: rec.entries,
+                            },
+                        });
+                    }
+                    const tcs = parseEngineToolCallEvent(event);
+                    if (tcs.length && wireFormat === 'openai') {
+                        for (let i = 0; i < tcs.length; i++) {
+                            const tc = tcs[i];
+                            toolCalls.push(tc);
+                            (0, stream_1.writeSseData)(res, {
+                                id: completionId,
+                                object: 'chat.completion.chunk',
+                                created,
+                                model,
+                                choices: [
+                                    {
+                                        index: 0,
+                                        delta: {
+                                            tool_calls: [
+                                                {
+                                                    index: toolCalls.length - 1,
+                                                    id: tc.id,
+                                                    type: 'function',
+                                                    function: {
+                                                        name: tc.function.name,
+                                                        arguments: tc.function.arguments,
+                                                    },
+                                                },
+                                            ],
+                                        },
+                                        finish_reason: null,
+                                    },
+                                ],
+                            });
+                        }
+                    }
+                    else {
+                        toolCalls.push(...tcs);
+                    }
+                }
+            }
+            if (!clientClosed) {
+                if (wireFormat === 'openai') {
+                    const engineMeta = {
+                        sessionId: engineSessionId,
+                        stopReason,
+                        requestId: engineRequestId,
+                        cost: engineUsageToMetaCost(streamUsage),
+                    };
+                    const finishChunk = (0, openai_mapper_1.mapFinishChunk)(model, completionId, created, toolCalls.length && !textParts.join('').trim()
+                        ? 'tool_calls'
+                        : stopReason, engineMeta);
+                    if (streamUsage || args.usageEstimate) {
+                        finishChunk.usage = streamUsage
+                            ? usageToOpenAi(streamUsage)
+                            : {
+                                prompt_tokens: args.estimatedPromptTokens || 0,
+                                completion_tokens: (0, chat_request_builder_service_1.estimateCompletionTokens)(textParts.join('')),
+                                total_tokens: (args.estimatedPromptTokens || 0) +
+                                    (0, chat_request_builder_service_1.estimateCompletionTokens)(textParts.join('')),
+                            };
+                    }
+                    (0, stream_1.writeSseData)(res, finishChunk);
+                    (0, stream_1.writeSseDone)(res);
+                }
+                else if (wireFormat === 'anthropic') {
+                    (0, stream_1.writeSseEvent)(res, 'content_block_stop', {
+                        type: 'content_block_stop',
+                        index: 0,
+                    });
+                    // Emit tool_use content blocks when the engine surfaced tool calls
+                    let blockIndex = 1;
+                    for (const tc of toolCalls) {
+                        let input = {};
+                        try {
+                            input = JSON.parse(tc.function.arguments || '{}');
+                        }
+                        catch {
+                            input = { raw: tc.function.arguments };
+                        }
+                        (0, stream_1.writeSseEvent)(res, 'content_block_start', {
+                            type: 'content_block_start',
+                            index: blockIndex,
+                            content_block: {
+                                type: 'tool_use',
+                                id: tc.id,
+                                name: tc.function.name,
+                                input: {},
+                            },
+                        });
+                        (0, stream_1.writeSseEvent)(res, 'content_block_delta', {
+                            type: 'content_block_delta',
+                            index: blockIndex,
+                            delta: {
+                                type: 'input_json_delta',
+                                partial_json: tc.function.arguments || '{}',
+                            },
+                        });
+                        (0, stream_1.writeSseEvent)(res, 'content_block_stop', {
+                            type: 'content_block_stop',
+                            index: blockIndex,
+                        });
+                        void input;
+                        blockIndex += 1;
+                    }
+                    const anthropicStop = toolCalls.length && !textParts.join('').trim()
+                        ? 'tool_use'
+                        : (0, anthropic_mapper_1.mapAnthropicStopReason)(stopReason);
+                    (0, stream_1.writeSseEvent)(res, 'message_delta', {
+                        type: 'message_delta',
+                        delta: {
+                            stop_reason: anthropicStop,
+                            stop_sequence: null,
+                        },
+                        usage: {
+                            output_tokens: (0, chat_request_builder_service_1.estimateCompletionTokens)(textParts.join('')),
+                        },
+                    });
+                    (0, stream_1.writeSseEvent)(res, 'message_stop', { type: 'message_stop' });
+                }
+                else if (wireFormat === 'responses') {
+                    const fullText = textParts.join('');
+                    (0, stream_1.writeSseEvent)(res, 'response.output_text.done', {
+                        type: 'response.output_text.done',
+                        output_index: 0,
+                        content_index: 0,
+                        text: fullText,
+                    });
+                    (0, stream_1.writeSseEvent)(res, 'response.content_part.done', {
+                        type: 'response.content_part.done',
+                        output_index: 0,
+                        content_index: 0,
+                        part: { type: 'output_text', text: fullText, annotations: [] },
+                    });
+                    (0, stream_1.writeSseEvent)(res, 'response.output_item.done', {
+                        type: 'response.output_item.done',
+                        output_index: 0,
+                        item: {
+                            type: 'message',
+                            id: outputItemId,
+                            status: 'completed',
+                            role: 'assistant',
+                            content: [
+                                { type: 'output_text', text: fullText, annotations: [] },
+                            ],
+                        },
+                    });
+                    (0, stream_1.writeSseEvent)(res, 'response.completed', {
+                        type: 'response.completed',
+                        response: {
+                            id: respId,
+                            object: 'response',
+                            created_at: created,
+                            status: 'completed',
+                            model,
+                            output: [
+                                {
+                                    type: 'message',
+                                    id: outputItemId,
+                                    status: 'completed',
+                                    role: 'assistant',
+                                    content: [
+                                        { type: 'output_text', text: fullText, annotations: [] },
+                                    ],
+                                },
+                            ],
+                            usage: {
+                                input_tokens: 0,
+                                output_tokens: 0,
+                                total_tokens: 0,
+                            },
+                        },
+                    });
+                }
+                res.end();
+            }
+            const collected = {
+                text: textParts.join(''),
+                reasoning: reasoningParts.join(''),
+                sessionId: engineSessionId,
+                stopReason,
+                requestId: engineRequestId,
+            };
+            await this.rememberEngineSession(ctx.apiKey.id, dto.session_id, engineSessionId);
+            const auditPayload = this.buildAuditPayload(collected, includeReasoning);
+            const responseEnc = encryption_service_1.encryptionService.encrypt(auditPayload);
+            const durationMs = Date.now() - started;
+            await database_1.prisma.chatRequest.update({
+                where: { id: chatRequestDbId },
+                data: {
+                    status: clientClosed ? constants_1.CHAT_STATUS.CANCELLED : constants_1.CHAT_STATUS.SUCCESS,
+                    durationMs,
+                    engineSessionId: engineSessionId ?? null,
+                    responseCiphertext: (0, prisma_bytes_1.toBytes)(responseEnc.ciphertext),
+                    responseIv: (0, prisma_bytes_1.toBytes)(responseEnc.iv),
+                    responseTag: (0, prisma_bytes_1.toBytes)(responseEnc.tag),
+                    errorMessage: clientClosed ? 'Client disconnected' : null,
+                },
+            });
+            await audit_service_1.auditService.log({
+                apiKeyId: ctx.apiKey.id,
+                action: constants_1.AUDIT_ACTIONS.CHAT_CREATE,
+                resource: 'chat_request',
+                resourceId: chatRequestDbId,
+                meta: {
+                    requestId: ctx.requestId,
+                    model,
+                    stream: true,
+                    durationMs,
+                    documentCount: (dto.document_ids ?? []).length,
+                    includeReasoning,
+                    hasReasoning: reasoningParts.length > 0,
+                    policyMode: policy.mode,
+                    cancelled: clientClosed,
+                },
+                ip: ctx.ip,
+            });
+        }
+        catch (err) {
+            if (!clientClosed && !res.writableEnded) {
+                const message = err instanceof Error ? err.message : 'Stream error';
+                (0, stream_1.writeSseData)(res, {
+                    error: {
+                        message,
+                        type: 'server_error',
+                        code: err instanceof http_exception_1.HttpException ? err.code : 'internal_error',
+                    },
+                });
+                (0, stream_1.writeSseDone)(res);
+                res.end();
+            }
+            throw err;
+        }
+    }
+    async markFailed(chatRequestDbId, started, err) {
+        const durationMs = Date.now() - started;
+        const message = err instanceof Error ? err.message : 'Unknown error';
+        const isTimeout = err instanceof http_exception_1.HttpException && err.code === 'engine_timeout';
+        try {
+            await database_1.prisma.chatRequest.update({
+                where: { id: chatRequestDbId },
+                data: {
+                    status: isTimeout ? constants_1.CHAT_STATUS.TIMEOUT : constants_1.CHAT_STATUS.ERROR,
+                    durationMs,
+                    errorMessage: message.slice(0, 4000),
+                },
+            });
+        }
+        catch (updateErr) {
+            logger_1.logger.error({ updateErr }, 'Failed to mark chat request as failed');
+        }
+    }
+}
+exports.ChatService = ChatService;
+exports.chatService = new ChatService();
+//# sourceMappingURL=chat.service.js.map