@windrun-huaiin/backend-core 15.0.0 → 16.0.0

package/dist/services/ai/mock.js

@@ -0,0 +1,314 @@
+'use strict';
+
+var tslib = require('tslib');
+var ai = require('@windrun-huaiin/contracts/ai');
+
+const streamingHeaders = {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate, no-transform',
+    Connection: 'keep-alive',
+    Pragma: 'no-cache',
+    'X-Accel-Buffering': 'no',
+};
+function encodeEvent(event) {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}
+function createStreamResponse(events) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            for (const event of events) {
+                controller.enqueue(encoder.encode(encodeEvent(event)));
+            }
+            controller.close();
+        },
+    });
+    return new Response(stream, {
+        headers: streamingHeaders,
+    });
+}
+function createSimpleMockHandler(text) {
+    return (context) => {
+        const messageId = `mock-${context.requestId}`;
+        return createStreamResponse([
+            {
+                type: 'message_started',
+                messageId,
+                createdAt: Date.now(),
+            },
+            {
+                type: 'text_delta',
+                messageId,
+                text,
+            },
+            {
+                type: 'message_completed',
+                messageId,
+                createdAt: Date.now(),
+            },
+        ]);
+    };
+}
+function createErrorMockResponse(statusCode, message) {
+    return Response.json(ai.createAIErrorPayload({
+        message,
+        upstreamStatusCode: statusCode,
+    }), { status: statusCode });
+}
+function getMockScenario(mockType, mockTimeoutMs) {
+    switch (mockType) {
+        case 1:
+            return {
+                mode: 'text_stream',
+                initialDelayMs: mockTimeoutMs,
+            };
+        case 2:
+            return {
+                mode: 'text_stream',
+                immediateErrorType: 'timeout',
+            };
+        case 3:
+            return {
+                mode: 'text_stream',
+                streamFailureType: 'timeout',
+                streamFailureAfterChunks: 3,
+            };
+        case 4:
+            return {
+                mode: 'text_stream',
+                streamFailureType: 'request_aborted',
+                streamFailureAfterChunks: 3,
+            };
+        case 5:
+            return {
+                mode: 'text_stream',
+                streamFailureType: 'stream_error',
+                streamFailureAfterChunks: 3,
+            };
+        case 6:
+            return {
+                mode: 'event_sequence',
+            };
+        case 7:
+            return {
+                mode: 'event_sequence',
+            };
+        default:
+            return {
+                mode: 'text_stream',
+            };
+    }
+}
+function sleep(delayInMs) {
+    return tslib.__awaiter(this, void 0, void 0, function* () {
+        yield new Promise((resolve) => setTimeout(resolve, delayInMs));
+    });
+}
+function createMockErrorPayload(failureType) {
+    if (failureType === 'timeout') {
+        return ai.createAIErrorPayload({
+            message: 'Request timed out',
+            upstreamStatusCode: 408,
+        });
+    }
+    if (failureType === 'request_aborted') {
+        return ai.createAIErrorPayload({
+            message: 'Request aborted',
+            upstreamStatusCode: 499,
+        });
+    }
+    return ai.createAIErrorPayload({
+        message: 'Error communicating with AI',
+        upstreamStatusCode: 502,
+        failureReason: 'stream_error',
+    });
+}
+function createMockFailureResponse(failureType) {
+    var _a;
+    const payload = createMockErrorPayload(failureType);
+    return Response.json(payload, { status: (_a = payload.upstreamStatusCode) !== null && _a !== void 0 ? _a : 500 });
+}
+function chunkTextByWords(text, chunkSize) {
+    var _a;
+    const wordChunks = (_a = text.match(/\S+\s*/g)) !== null && _a !== void 0 ? _a : [text];
+    const normalizedChunkSize = Math.max(1, chunkSize);
+    const chunks = [];
+    for (let index = 0; index < wordChunks.length; index += normalizedChunkSize) {
+        chunks.push(wordChunks.slice(index, index + normalizedChunkSize).join(''));
+    }
+    return chunks;
+}
+function createConfigurableMockHandler(options) {
+    return (context) => tslib.__awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        if (((_a = options.initialDelayMs) !== null && _a !== void 0 ? _a : 0) > 0) {
+            yield sleep(options.initialDelayMs);
+        }
+        const messageId = `mock-${context.requestId}`;
+        const chunks = chunkTextByWords(options.text, (_b = options.chunkSize) !== null && _b !== void 0 ? _b : 4);
+        const chunkDelayMs = Math.max(0, (_c = options.chunkDelayMs) !== null && _c !== void 0 ? _c : 0);
+        const failureAfterChunks = (_d = options.streamFailureAfterChunks) !== null && _d !== void 0 ? _d : 0;
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                return tslib.__awaiter(this, void 0, void 0, function* () {
+                    controller.enqueue(encoder.encode(encodeEvent({
+                        type: 'message_started',
+                        messageId,
+                        createdAt: Date.now(),
+                    })));
+                    for (let index = 0; index < chunks.length; index += 1) {
+                        if (options.streamFailureType &&
+                            failureAfterChunks > 0 &&
+                            index >= failureAfterChunks) {
+                            controller.enqueue(encoder.encode(encodeEvent({
+                                type: 'error',
+                                error: createMockErrorPayload(options.streamFailureType),
+                            })));
+                            controller.close();
+                            return;
+                        }
+                        controller.enqueue(encoder.encode(encodeEvent({
+                            type: 'text_delta',
+                            messageId,
+                            text: chunks[index],
+                        })));
+                        if (chunkDelayMs > 0) {
+                            yield sleep(chunkDelayMs);
+                        }
+                    }
+                    controller.enqueue(encoder.encode(encodeEvent({
+                        type: 'message_completed',
+                        messageId,
+                        createdAt: Date.now(),
+                    })));
+                    controller.close();
+                });
+            },
+        });
+        return new Response(stream, {
+            headers: streamingHeaders,
+        });
+    });
+}
+function createEventSequenceMockHandler(events) {
+    return () => tslib.__awaiter(this, void 0, void 0, function* () { return createStreamResponse(events); });
+}
+function createMarkdownShowcaseEvents(messageId) {
+    return [
+        {
+            type: 'message_started',
+            messageId,
+            createdAt: Date.now(),
+        },
+        {
+            type: 'text_delta',
+            messageId,
+            text: [
+                '# Markdown Showcase',
+                '',
+                'This scenario verifies headings, lists, quotes, tables, code, and image rendering in the chat message body.',
+                '',
+                '## Bullet List',
+                '',
+                '- Bullet list item one',
+                '- Bullet list item two',
+                '',
+                '## Quote',
+                '',
+                '> Blockquote content for layout verification.',
+                '',
+                '## Table',
+                '',
+                '| Column | Value |',
+                '| --- | --- |',
+                '| Status | OK |',
+                '| Mode | Markdown |',
+                '',
+                '## Code',
+                '',
+                '```ts',
+                "const mode = 'markdown-showcase';",
+                'console.log(mode);',
+                '```',
+                '',
+                '## Image',
+                '',
+                '![Mock Image](https://r2.d8ger.com/default.webp)',
+            ].join('\n'),
+        },
+        {
+            type: 'message_completed',
+            messageId,
+            createdAt: Date.now(),
+        },
+    ];
+}
+function createTrophyCardShowcaseEvents(messageId) {
+    return [
+        {
+            type: 'message_started',
+            messageId,
+            createdAt: Date.now(),
+        },
+        {
+            type: 'text_delta',
+            messageId,
+            text: [
+                '# Trophy Card Showcase',
+                '',
+                'This scenario verifies a structured chat part rendered between normal markdown blocks.',
+                '',
+                'The card below is emitted as a dedicated `trophy_card` part, not as Markdown component syntax.',
+            ].join('\n'),
+        },
+        {
+            type: 'part',
+            messageId,
+            part: {
+                type: 'trophy_card',
+                title: 'Structured Trophy Card',
+                description: 'This is rendered from `MessagePart`, which is the recommended path for chat-specific rich blocks.\n\n- Reusable shared React component\n- Chat-specific structured part\n- Ready to extend to file, audio, and video cards',
+            },
+        },
+        {
+            type: 'text_delta',
+            messageId,
+            text: '\n\nUse this as the reference pattern for future file, audio, video, or tool result parts.',
+        },
+        {
+            type: 'message_completed',
+            messageId,
+            createdAt: Date.now(),
+        },
+    ];
+}
+function createScenarioMockHandler(params) {
+    const scenario = getMockScenario(params.mockType, params.mockTimeoutSeconds * 1000);
+    const messageId = `mock-scenario-${params.mockType}`;
+    if (scenario.immediateErrorType) {
+        return () => tslib.__awaiter(this, void 0, void 0, function* () { return createMockFailureResponse(scenario.immediateErrorType); });
+    }
+    if (scenario.mode === 'event_sequence') {
+        if (params.mockType === 6) {
+            return createEventSequenceMockHandler(createMarkdownShowcaseEvents(messageId));
+        }
+        if (params.mockType === 7) {
+            return createEventSequenceMockHandler(createTrophyCardShowcaseEvents(messageId));
+        }
+    }
+    return createConfigurableMockHandler({
+        text: params.text,
+        initialDelayMs: scenario.initialDelayMs,
+        chunkDelayMs: params.mockStreamChunkDelayMs,
+        chunkSize: params.mockStreamChunkSize,
+        streamFailureType: scenario.streamFailureType,
+        streamFailureAfterChunks: scenario.streamFailureAfterChunks,
+    });
+}
+
+exports.createConfigurableMockHandler = createConfigurableMockHandler;
+exports.createErrorMockResponse = createErrorMockResponse;
+exports.createScenarioMockHandler = createScenarioMockHandler;
+exports.createSimpleMockHandler = createSimpleMockHandler;
+exports.getMockScenario = getMockScenario;

package/dist/services/ai/mock.mjs

@@ -0,0 +1,308 @@
+import { __awaiter } from 'tslib';
+import { createAIErrorPayload } from '@windrun-huaiin/contracts/ai';
+
+const streamingHeaders = {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate, no-transform',
+    Connection: 'keep-alive',
+    Pragma: 'no-cache',
+    'X-Accel-Buffering': 'no',
+};
+function encodeEvent(event) {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}
+function createStreamResponse(events) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        start(controller) {
+            for (const event of events) {
+                controller.enqueue(encoder.encode(encodeEvent(event)));
+            }
+            controller.close();
+        },
+    });
+    return new Response(stream, {
+        headers: streamingHeaders,
+    });
+}
+function createSimpleMockHandler(text) {
+    return (context) => {
+        const messageId = `mock-${context.requestId}`;
+        return createStreamResponse([
+            {
+                type: 'message_started',
+                messageId,
+                createdAt: Date.now(),
+            },
+            {
+                type: 'text_delta',
+                messageId,
+                text,
+            },
+            {
+                type: 'message_completed',
+                messageId,
+                createdAt: Date.now(),
+            },
+        ]);
+    };
+}
+function createErrorMockResponse(statusCode, message) {
+    return Response.json(createAIErrorPayload({
+        message,
+        upstreamStatusCode: statusCode,
+    }), { status: statusCode });
+}
+function getMockScenario(mockType, mockTimeoutMs) {
+    switch (mockType) {
+        case 1:
+            return {
+                mode: 'text_stream',
+                initialDelayMs: mockTimeoutMs,
+            };
+        case 2:
+            return {
+                mode: 'text_stream',
+                immediateErrorType: 'timeout',
+            };
+        case 3:
+            return {
+                mode: 'text_stream',
+                streamFailureType: 'timeout',
+                streamFailureAfterChunks: 3,
+            };
+        case 4:
+            return {
+                mode: 'text_stream',
+                streamFailureType: 'request_aborted',
+                streamFailureAfterChunks: 3,
+            };
+        case 5:
+            return {
+                mode: 'text_stream',
+                streamFailureType: 'stream_error',
+                streamFailureAfterChunks: 3,
+            };
+        case 6:
+            return {
+                mode: 'event_sequence',
+            };
+        case 7:
+            return {
+                mode: 'event_sequence',
+            };
+        default:
+            return {
+                mode: 'text_stream',
+            };
+    }
+}
+function sleep(delayInMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield new Promise((resolve) => setTimeout(resolve, delayInMs));
+    });
+}
+function createMockErrorPayload(failureType) {
+    if (failureType === 'timeout') {
+        return createAIErrorPayload({
+            message: 'Request timed out',
+            upstreamStatusCode: 408,
+        });
+    }
+    if (failureType === 'request_aborted') {
+        return createAIErrorPayload({
+            message: 'Request aborted',
+            upstreamStatusCode: 499,
+        });
+    }
+    return createAIErrorPayload({
+        message: 'Error communicating with AI',
+        upstreamStatusCode: 502,
+        failureReason: 'stream_error',
+    });
+}
+function createMockFailureResponse(failureType) {
+    var _a;
+    const payload = createMockErrorPayload(failureType);
+    return Response.json(payload, { status: (_a = payload.upstreamStatusCode) !== null && _a !== void 0 ? _a : 500 });
+}
+function chunkTextByWords(text, chunkSize) {
+    var _a;
+    const wordChunks = (_a = text.match(/\S+\s*/g)) !== null && _a !== void 0 ? _a : [text];
+    const normalizedChunkSize = Math.max(1, chunkSize);
+    const chunks = [];
+    for (let index = 0; index < wordChunks.length; index += normalizedChunkSize) {
+        chunks.push(wordChunks.slice(index, index + normalizedChunkSize).join(''));
+    }
+    return chunks;
+}
+function createConfigurableMockHandler(options) {
+    return (context) => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        if (((_a = options.initialDelayMs) !== null && _a !== void 0 ? _a : 0) > 0) {
+            yield sleep(options.initialDelayMs);
+        }
+        const messageId = `mock-${context.requestId}`;
+        const chunks = chunkTextByWords(options.text, (_b = options.chunkSize) !== null && _b !== void 0 ? _b : 4);
+        const chunkDelayMs = Math.max(0, (_c = options.chunkDelayMs) !== null && _c !== void 0 ? _c : 0);
+        const failureAfterChunks = (_d = options.streamFailureAfterChunks) !== null && _d !== void 0 ? _d : 0;
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream({
+            start(controller) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    controller.enqueue(encoder.encode(encodeEvent({
+                        type: 'message_started',
+                        messageId,
+                        createdAt: Date.now(),
+                    })));
+                    for (let index = 0; index < chunks.length; index += 1) {
+                        if (options.streamFailureType &&
+                            failureAfterChunks > 0 &&
+                            index >= failureAfterChunks) {
+                            controller.enqueue(encoder.encode(encodeEvent({
+                                type: 'error',
+                                error: createMockErrorPayload(options.streamFailureType),
+                            })));
+                            controller.close();
+                            return;
+                        }
+                        controller.enqueue(encoder.encode(encodeEvent({
+                            type: 'text_delta',
+                            messageId,
+                            text: chunks[index],
+                        })));
+                        if (chunkDelayMs > 0) {
+                            yield sleep(chunkDelayMs);
+                        }
+                    }
+                    controller.enqueue(encoder.encode(encodeEvent({
+                        type: 'message_completed',
+                        messageId,
+                        createdAt: Date.now(),
+                    })));
+                    controller.close();
+                });
+            },
+        });
+        return new Response(stream, {
+            headers: streamingHeaders,
+        });
+    });
+}
+function createEventSequenceMockHandler(events) {
+    return () => __awaiter(this, void 0, void 0, function* () { return createStreamResponse(events); });
+}
+function createMarkdownShowcaseEvents(messageId) {
+    return [
+        {
+            type: 'message_started',
+            messageId,
+            createdAt: Date.now(),
+        },
+        {
+            type: 'text_delta',
+            messageId,
+            text: [
+                '# Markdown Showcase',
+                '',
+                'This scenario verifies headings, lists, quotes, tables, code, and image rendering in the chat message body.',
+                '',
+                '## Bullet List',
+                '',
+                '- Bullet list item one',
+                '- Bullet list item two',
+                '',
+                '## Quote',
+                '',
+                '> Blockquote content for layout verification.',
+                '',
+                '## Table',
+                '',
+                '| Column | Value |',
+                '| --- | --- |',
+                '| Status | OK |',
+                '| Mode | Markdown |',
+                '',
+                '## Code',
+                '',
+                '```ts',
+                "const mode = 'markdown-showcase';",
+                'console.log(mode);',
+                '```',
+                '',
+                '## Image',
+                '',
+                '![Mock Image](https://r2.d8ger.com/default.webp)',
+            ].join('\n'),
+        },
+        {
+            type: 'message_completed',
+            messageId,
+            createdAt: Date.now(),
+        },
+    ];
+}
+function createTrophyCardShowcaseEvents(messageId) {
+    return [
+        {
+            type: 'message_started',
+            messageId,
+            createdAt: Date.now(),
+        },
+        {
+            type: 'text_delta',
+            messageId,
+            text: [
+                '# Trophy Card Showcase',
+                '',
+                'This scenario verifies a structured chat part rendered between normal markdown blocks.',
+                '',
+                'The card below is emitted as a dedicated `trophy_card` part, not as Markdown component syntax.',
+            ].join('\n'),
+        },
+        {
+            type: 'part',
+            messageId,
+            part: {
+                type: 'trophy_card',
+                title: 'Structured Trophy Card',
+                description: 'This is rendered from `MessagePart`, which is the recommended path for chat-specific rich blocks.\n\n- Reusable shared React component\n- Chat-specific structured part\n- Ready to extend to file, audio, and video cards',
+            },
+        },
+        {
+            type: 'text_delta',
+            messageId,
+            text: '\n\nUse this as the reference pattern for future file, audio, video, or tool result parts.',
+        },
+        {
+            type: 'message_completed',
+            messageId,
+            createdAt: Date.now(),
+        },
+    ];
+}
+function createScenarioMockHandler(params) {
+    const scenario = getMockScenario(params.mockType, params.mockTimeoutSeconds * 1000);
+    const messageId = `mock-scenario-${params.mockType}`;
+    if (scenario.immediateErrorType) {
+        return () => __awaiter(this, void 0, void 0, function* () { return createMockFailureResponse(scenario.immediateErrorType); });
+    }
+    if (scenario.mode === 'event_sequence') {
+        if (params.mockType === 6) {
+            return createEventSequenceMockHandler(createMarkdownShowcaseEvents(messageId));
+        }
+        if (params.mockType === 7) {
+            return createEventSequenceMockHandler(createTrophyCardShowcaseEvents(messageId));
+        }
+    }
+    return createConfigurableMockHandler({
+        text: params.text,
+        initialDelayMs: scenario.initialDelayMs,
+        chunkDelayMs: params.mockStreamChunkDelayMs,
+        chunkSize: params.mockStreamChunkSize,
+        streamFailureType: scenario.streamFailureType,
+        streamFailureAfterChunks: scenario.streamFailureAfterChunks,
+    });
+}
+
+export { createConfigurableMockHandler, createErrorMockResponse, createScenarioMockHandler, createSimpleMockHandler, getMockScenario };

package/dist/services/ai/openrouter-client.d.ts

@@ -0,0 +1,12 @@
+import type { OpenRouterClientConfig, OpenRouterRequestBody, OpenRouterStreamResult } from './types';
+export declare function callOpenRouterStream(config: OpenRouterClientConfig, body: OpenRouterRequestBody, signal: AbortSignal): Promise<OpenRouterStreamResult>;
+export declare function guardedOpenRouterStreamStart(response: Response): Promise<{
+    ok: false;
+    error: import("@windrun-huaiin/contracts/ai").AIErrorPayload;
+    stream?: undefined;
+} | {
+    ok: true;
+    stream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+    error?: undefined;
+}>;
+//# sourceMappingURL=openrouter-client.d.ts.map

package/dist/services/ai/openrouter-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openrouter-client.d.ts","sourceRoot":"","sources":["../../../src/services/ai/openrouter-client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAIjB,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,sBAAsB,EAC9B,IAAI,EAAE,qBAAqB,EAC3B,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,sBAAsB,CAAC,CAiCjC;AAED,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,QAAQ;;;;;;;;GA4CnB"}