@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/scripts/__tests__/cli.spec.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const cli_1 = require("../cli");
+(0, vitest_1.describe)('scripts cli', () => {
+    (0, vitest_1.it)('dispatches adapter e2e run through the shared suite', async () => {
+        const runAdapterSuite = vitest_1.vi.fn(async () => []);
+        const cli = (0, cli_1.createScriptsCli)({
+            runAdapterSuite,
+            runAdapterVitest: vitest_1.vi.fn(async () => { }),
+            runPublishPlan: vitest_1.vi.fn(async () => ({}))
+        });
+        await cli.parseAsync(['node', 'vf-dev', 'adapter-e2e', 'run', 'codex', '--quiet']);
+        (0, vitest_1.expect)(runAdapterSuite).toHaveBeenCalledWith('codex', {
+            passthroughStdIO: false,
+            printSummary: true
+        });
+    });
+    (0, vitest_1.it)('dispatches adapter e2e test with verbose mode', async () => {
+        const runAdapterVitest = vitest_1.vi.fn(async () => { });
+        const cli = (0, cli_1.createScriptsCli)({
+            runAdapterSuite: vitest_1.vi.fn(async () => []),
+            runAdapterVitest,
+            runPublishPlan: vitest_1.vi.fn(async () => ({}))
+        });
+        await cli.parseAsync([
+            'node',
+            'vf-dev',
+            'adapter-e2e',
+            'test',
+            'codex-read-once',
+            '--verbose',
+            '--update'
+        ]);
+        (0, vitest_1.expect)(runAdapterVitest).toHaveBeenCalledWith({
+            selection: 'codex-read-once',
+            updateSnapshots: true,
+            verbose: true
+        });
+    });
+    (0, vitest_1.it)('passes through publish plan arguments after --', async () => {
+        const runPublishPlan = vitest_1.vi.fn(async () => ({}));
+        const cli = (0, cli_1.createScriptsCli)({
+            runAdapterSuite: vitest_1.vi.fn(async () => []),
+            runAdapterVitest: vitest_1.vi.fn(async () => { }),
+            runPublishPlan
+        });
+        await cli.parseAsync(['node', 'vf-dev', 'publish-plan', '--', '--publish', '--tag', 'next']);
+        (0, vitest_1.expect)(runPublishPlan).toHaveBeenCalledWith(['--publish', '--tag', 'next']);
+    });
+});

package/dist/scripts/__tests__/publish-plan.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/__tests__/publish-plan.spec.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const publish_plan_core_mjs_1 = require("../publish-plan-core.mjs");
+const createPackage = (name, version, deps = {}, extra = {}) => ({
+    name,
+    dir: `/repo/${name}`,
+    private: Boolean(extra.private),
+    json: {
+        name,
+        version,
+        ...(Object.keys(deps).length > 0 ? { dependencies: deps } : {}),
+        ...extra
+    }
+});
+(0, vitest_1.describe)('publish-plan', () => {
+    (0, vitest_1.it)('parses CLI arguments and deduplicates packages', () => {
+        const options = (0, publish_plan_core_mjs_1.parseArgs)([
+            '--packages',
+            '@scope/a,@scope/b',
+            '--package',
+            '@scope/b',
+            '--publish',
+            '--tag',
+            'next',
+            '--bump',
+            'patch',
+            '--dry-run',
+            '--no-git-checks',
+            '--no-confirm-retry',
+            '--json'
+        ]);
+        (0, vitest_1.expect)(options).toMatchObject({
+            packages: ['@scope/a', '@scope/b'],
+            publish: true,
+            tag: 'next',
+            bump: 'patch',
+            dryRun: true,
+            noGitChecks: true,
+            confirmRetry: false,
+            json: true
+        });
+    });
+    (0, vitest_1.it)('keeps explicit selection narrow and only uses dependencies for analysis', () => {
+        const packages = new Map([
+            ['@vibe-forge/core', createPackage('@vibe-forge/core', '1.0.0')],
+            [
+                '@vibe-forge/adapter',
+                createPackage('@vibe-forge/adapter', '1.0.0', {
+                    '@vibe-forge/core': 'workspace:^'
+                })
+            ],
+            [
+                '@vibe-forge/client',
+                createPackage('@vibe-forge/client', '1.0.0', {
+                    '@vibe-forge/adapter': 'workspace:^'
+                })
+            ]
+        ]);
+        const plan = (0, publish_plan_core_mjs_1.createPublishPlan)(packages, {
+            packages: ['@vibe-forge/client'],
+            publish: false,
+            access: 'public',
+            tag: '',
+            dryRun: false,
+            noGitChecks: false,
+            bump: '',
+            confirmRetry: true,
+            json: false,
+            includePrivate: false,
+            help: false
+        });
+        (0, vitest_1.expect)(plan.items.map((item) => item.name)).toEqual([
+            '@vibe-forge/client'
+        ]);
+        (0, vitest_1.expect)(plan.items[0]?.internalDependencies).toEqual(['@vibe-forge/adapter']);
+    });
+    (0, vitest_1.it)('does not require dependent releases for compatible dependency bumps', () => {
+        const packages = new Map([
+            ['b', createPackage('b', '0.1.0')],
+            ['a', createPackage('a', '1.0.0', { b: 'workspace:^0.1.0' })]
+        ]);
+        const plan = (0, publish_plan_core_mjs_1.createPublishPlan)(packages, {
+            packages: ['b'],
+            publish: false,
+            access: 'public',
+            tag: '',
+            dryRun: false,
+            noGitChecks: false,
+            bump: 'patch',
+            confirmRetry: true,
+            json: false,
+            includePrivate: false,
+            help: false
+        });
+        (0, vitest_1.expect)(plan.items.map((item) => item.name)).toEqual(['b']);
+        (0, vitest_1.expect)(plan.items[0]?.nextVersion).toBe('0.1.1');
+        (0, vitest_1.expect)(plan.items[0]?.impactedDependents).toEqual([]);
+    });
+    (0, vitest_1.it)('marks dependents when a zero-major caret range is no longer compatible', () => {
+        const packages = new Map([
+            ['b', createPackage('b', '0.1.0')],
+            ['a', createPackage('a', '1.0.0', { b: 'workspace:^0.1.0' })]
+        ]);
+        const plan = (0, publish_plan_core_mjs_1.createPublishPlan)(packages, {
+            packages: ['b'],
+            publish: false,
+            access: 'public',
+            tag: '',
+            dryRun: false,
+            noGitChecks: false,
+            bump: 'minor',
+            confirmRetry: true,
+            json: false,
+            includePrivate: false,
+            help: false
+        });
+        (0, vitest_1.expect)(plan.items.map((item) => item.name)).toEqual(['b']);
+        (0, vitest_1.expect)(plan.items[0]?.nextVersion).toBe('0.2.0');
+        (0, vitest_1.expect)(plan.items[0]?.impactedDependents).toEqual([
+            {
+                name: 'a',
+                range: 'workspace:^0.1.0',
+                field: 'dependencies',
+                requiresRangeUpdate: true
+            }
+        ]);
+    });
+    (0, vitest_1.it)('rejects plans that depend on a private workspace package', () => {
+        const packages = new Map([
+            ['@vibe-forge/private-core', createPackage('@vibe-forge/private-core', '1.0.0', {}, { private: true })],
+            [
+                '@vibe-forge/client',
+                createPackage('@vibe-forge/client', '1.0.0', {
+                    '@vibe-forge/private-core': 'workspace:^'
+                })
+            ]
+        ]);
+        (0, vitest_1.expect)(() => (0, publish_plan_core_mjs_1.createPublishPlan)(packages, {
+            packages: ['@vibe-forge/client'],
+            publish: false,
+            access: 'public',
+            tag: '',
+            dryRun: false,
+            noGitChecks: false,
+            bump: '',
+            confirmRetry: true,
+            json: false,
+            includePrivate: false,
+            help: false
+        })).toThrow('依赖 private 包');
+    });
+    (0, vitest_1.it)('bumps versions for every package in the plan', async () => {
+        const packages = new Map([
+            ['@vibe-forge/core', createPackage('@vibe-forge/core', '1.2.3')],
+            ['@vibe-forge/client', createPackage('@vibe-forge/client', '2.0.0')]
+        ]);
+        const plan = {
+            items: [
+                { name: '@vibe-forge/core' },
+                { name: '@vibe-forge/client' }
+            ]
+        };
+        const writes = [];
+        const updates = await (0, publish_plan_core_mjs_1.applyVersionBump)(plan, packages, 'minor', {
+            readText: vitest_1.vi.fn(),
+            readdir: vitest_1.vi.fn(),
+            stat: vitest_1.vi.fn(),
+            writeText: vitest_1.vi.fn(async (filePath, content) => {
+                writes.push({ filePath, content });
+            })
+        });
+        (0, vitest_1.expect)(updates).toEqual([
+            { name: '@vibe-forge/core', version: '1.3.0' },
+            { name: '@vibe-forge/client', version: '2.1.0' }
+        ]);
+        (0, vitest_1.expect)(writes.map((entry) => entry.filePath)).toEqual([
+            '/repo/@vibe-forge/core/package.json',
+            '/repo/@vibe-forge/client/package.json'
+        ]);
+        (0, vitest_1.expect)(JSON.parse(writes[0].content).version).toBe('1.3.0');
+    });
+    (0, vitest_1.it)('builds pnpm publish arguments from publish flags', () => {
+        (0, vitest_1.expect)((0, publish_plan_core_mjs_1.buildPublishArgs)({
+            access: 'public',
+            tag: 'beta',
+            dryRun: true,
+            noGitChecks: true
+        })).toEqual([
+            'publish',
+            '--access',
+            'public',
+            '--tag',
+            'beta',
+            '--dry-run',
+            '--no-git-checks'
+        ]);
+    });
+    (0, vitest_1.it)('loads workspace packages from pnpm-workspace patterns', async () => {
+        const dirs = new Map([
+            ['/repo/apps', ['cli', 'server']]
+        ]);
+        const files = new Map([
+            ['/repo/pnpm-workspace.yaml', 'packages:\n  - apps/*\n'],
+            ['/repo/apps/cli/package.json', JSON.stringify({ name: '@vibe-forge/cli', version: '1.0.0' })],
+            ['/repo/apps/server/package.json', JSON.stringify({ name: '@vibe-forge/server', version: '1.0.0' })]
+        ]);
+        const packages = await (0, publish_plan_core_mjs_1.loadWorkspacePackages)('/repo', {
+            async readText(filePath) {
+                const content = files.get(filePath);
+                if (!content) {
+                    throw new Error(`missing file: ${filePath}`);
+                }
+                return content;
+            },
+            async readdir(dirPath) {
+                return dirs.get(dirPath) ?? [];
+            },
+            async stat(filePath) {
+                return {
+                    isDirectory: () => !filePath.endsWith('package.json')
+                };
+            },
+            async writeText() { }
+        });
+        (0, vitest_1.expect)(Array.from(packages.keys())).toEqual([
+            '@vibe-forge/cli',
+            '@vibe-forge/server'
+        ]);
+    });
+    (0, vitest_1.it)('prints help without touching the workspace', async () => {
+        const output = [];
+        const result = await (0, publish_plan_core_mjs_1.runPublishPlanCli)(['--help'], {
+            repoRoot: '/repo',
+            stdout: {
+                write(value) {
+                    output.push(value);
+                }
+            },
+            fsOps: {
+                readText: vitest_1.vi.fn(async () => ''),
+                readdir: vitest_1.vi.fn(async () => []),
+                stat: vitest_1.vi.fn(async () => ({ isDirectory: () => false })),
+                writeText: vitest_1.vi.fn(async () => { })
+            }
+        });
+        (0, vitest_1.expect)(result.kind).toBe('help');
+        (0, vitest_1.expect)(output.join('')).toContain('pnpm tools publish-plan');
+    });
+    (0, vitest_1.it)('bumps semantic versions by kind', () => {
+        (0, vitest_1.expect)((0, publish_plan_core_mjs_1.bumpVersion)('1.2.3', 'patch')).toBe('1.2.4');
+        (0, vitest_1.expect)((0, publish_plan_core_mjs_1.bumpVersion)('1.2.3', 'minor')).toBe('1.3.0');
+        (0, vitest_1.expect)((0, publish_plan_core_mjs_1.bumpVersion)('1.2.3', 'major')).toBe('2.0.0');
+    });
+});

package/dist/scripts/adapter-e2e/harness.d.ts

@@ -0,0 +1,23 @@
+import type { AdapterE2ECase, AdapterE2EHarnessOptions, AdapterE2EResult, MockLlmTraceEntry, ResolvedAdapterE2ECase } from './types';
+export declare const createAdapterE2EHarness: (options?: AdapterE2EHarnessOptions) => Promise<{
+    mockServerPort: number;
+    cases: AdapterE2ECase[];
+    runCase: (testCase: AdapterE2ECase) => Promise<{
+        mockTrace: MockLlmTraceEntry[];
+        caseId: string;
+        adapter: import("./types").AdapterE2ETarget;
+        ctxId: string;
+        sessionId: string;
+        logPath: string;
+        logContent: string;
+        managedArtifacts: import("./types").VerifiedManagedArtifact[];
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        transport: import("./types").AdapterTransport;
+    }>;
+    runSuite(selection?: string | undefined): Promise<AdapterE2EResult[]>;
+    close(): Promise<void>;
+}>;
+export declare const collectCaseMockTrace: (trace: MockLlmTraceEntry[], traceStartIndex: number, testCase: ResolvedAdapterE2ECase) => MockLlmTraceEntry[];
+export declare const runAdapterE2ESuite: (requested?: string | undefined, options?: AdapterE2EHarnessOptions) => Promise<AdapterE2EResult[]>;

package/dist/scripts/adapter-e2e/harness.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAdapterE2ESuite = exports.collectCaseMockTrace = exports.createAdapterE2EHarness = void 0;
+const cases_1 = require("../__tests__/adapter-e2e/cases");
+const server_1 = require("./mock-llm/server");
+const runners_1 = require("./runners");
+const printScenarioResult = (result) => {
+    const suffix = result.transport === 'upstream-fallback' ? ':upstream' : '';
+    console.log(`\n[e2e:${result.caseId}:${result.adapter}${suffix}] ok`);
+    console.log(`ctxId=${result.ctxId}`);
+    console.log(`sessionId=${result.sessionId}`);
+    console.log(`log=${result.logPath}`);
+};
+const createAdapterE2EHarness = async (options = {}) => {
+    const cases = options.cases ?? cases_1.ADAPTER_E2E_CASES;
+    const mockServer = await (0, server_1.startMockLlmServer)({
+        ...options.mockServerOptions,
+        scenarios: [
+            ...(options.mockServerOptions?.scenarios ?? []),
+            ...(0, cases_1.collectCaseMockScenarios)(cases)
+        ]
+    });
+    const runCase = async (testCase) => {
+        const resolvedCase = (0, cases_1.resolveAdapterE2ECase)(testCase);
+        const traceStartIndex = mockServer.getTrace().length;
+        let result;
+        if (resolvedCase.adapter === 'codex' || resolvedCase.adapter === 'claude-code') {
+            result = await (0, runners_1.runWrappedAdapter)(resolvedCase, mockServer.port, options);
+        }
+        else if (resolvedCase.adapter === 'opencode') {
+            result = await (0, runners_1.runOpenCode)(resolvedCase, mockServer.port, options);
+        }
+        else {
+            throw new Error(`Unsupported adapter e2e target: ${resolvedCase.adapter}`);
+        }
+        return {
+            ...result,
+            mockTrace: (0, exports.collectCaseMockTrace)(mockServer.getTrace(), traceStartIndex, resolvedCase)
+        };
+    };
+    return {
+        mockServerPort: mockServer.port,
+        cases,
+        runCase,
+        async runSuite(selection = 'all') {
+            const results = [];
+            for (const testCase of (0, cases_1.resolveSelectedAdapterE2ECases)(selection, cases)) {
+                results.push(await runCase(testCase));
+            }
+            return results;
+        },
+        async close() {
+            await mockServer.close();
+        }
+    };
+};
+exports.createAdapterE2EHarness = createAdapterE2EHarness;
+const matchesResolvedCaseModel = (entry, testCase) => {
+    const candidates = [testCase.id, testCase.model].filter(Boolean);
+    return candidates.some(candidate => (entry.model === candidate ||
+        entry.model.includes(candidate) ||
+        candidate.includes(entry.model)));
+};
+const collectCaseMockTrace = (trace, traceStartIndex, testCase) => {
+    const nextTrace = trace.slice(traceStartIndex);
+    const matchedTrace = nextTrace.filter(entry => matchesResolvedCaseModel(entry, testCase));
+    return matchedTrace.length > 0 ? matchedTrace : nextTrace;
+};
+exports.collectCaseMockTrace = collectCaseMockTrace;
+const runAdapterE2ESuite = async (requested = 'all', options = {}) => {
+    const harness = await (0, exports.createAdapterE2EHarness)(options);
+    try {
+        const results = await harness.runSuite(requested);
+        if (options.printSummary ?? true) {
+            for (const result of results) {
+                printScenarioResult(result);
+            }
+        }
+        return results;
+    }
+    finally {
+        await harness.close();
+    }
+};
+exports.runAdapterE2ESuite = runAdapterE2ESuite;

package/dist/scripts/adapter-e2e/log.d.ts

@@ -0,0 +1,9 @@
+export interface ParsedHookLogEntry {
+    eventName: string;
+    headerText?: string;
+    payload: Record<string, unknown>;
+    rawPayload: string;
+    textBlock?: string;
+}
+export declare const parseHookLogEntries: (content: string) => ParsedHookLogEntry[];
+export declare const countHookLogEvents: (entries: ParsedHookLogEntry[]) => Map<string, number>;

package/dist/scripts/adapter-e2e/log.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countHookLogEvents = exports.parseHookLogEntries = void 0;
+const parseHeaderLine = (line) => {
+    if (!line.startsWith('# ') || !line.includes('[plugin.logger]')) {
+        return undefined;
+    }
+    const eventStart = line.indexOf('[', line.indexOf('__'));
+    if (eventStart === -1)
+        return undefined;
+    const eventEnd = line.indexOf(']', eventStart + 1);
+    if (eventEnd === -1)
+        return undefined;
+    const loggerTag = '[plugin.logger]';
+    const loggerIndex = line.indexOf(loggerTag, eventEnd + 1);
+    if (loggerIndex === -1)
+        return undefined;
+    return {
+        eventName: line.slice(eventStart + 1, eventEnd).trim(),
+        headerText: line.slice(loggerIndex + loggerTag.length).trim() || undefined
+    };
+};
+const parsePayload = (rawPayload) => {
+    const normalized = rawPayload.trim();
+    if (normalized === '' || normalized === 'undefined') {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(normalized);
+        return parsed != null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+};
+const parseHookLogEntries = (content) => {
+    const entries = [];
+    const lines = content.split('\n');
+    for (let index = 0; index < lines.length; index += 1) {
+        const headerLine = lines[index] ?? '';
+        const header = parseHeaderLine(headerLine);
+        if (header == null)
+            continue;
+        if ((lines[index + 1] ?? '').trim() !== '```json')
+            continue;
+        index += 2;
+        const jsonLines = [];
+        while (index < lines.length && (lines[index] ?? '').trim() !== '```') {
+            jsonLines.push(lines[index] ?? '');
+            index += 1;
+        }
+        const textBlock = (() => {
+            if ((lines[index + 1] ?? '').trim() !== '```text')
+                return undefined;
+            const textLines = [];
+            index += 2;
+            while (index < lines.length && (lines[index] ?? '').trim() !== '```') {
+                textLines.push(lines[index] ?? '');
+                index += 1;
+            }
+            return textLines.join('\n').trim() || undefined;
+        })();
+        const rawPayload = jsonLines.join('\n');
+        entries.push({
+            eventName: header.eventName,
+            headerText: header.headerText,
+            payload: parsePayload(rawPayload),
+            rawPayload,
+            textBlock
+        });
+    }
+    return entries;
+};
+exports.parseHookLogEntries = parseHookLogEntries;
+const countHookLogEvents = (entries) => {
+    const counts = new Map();
+    for (const entry of entries) {
+        counts.set(entry.eventName, (counts.get(entry.eventName) ?? 0) + 1);
+    }
+    return counts;
+};
+exports.countHookLogEvents = countHookLogEvents;

package/dist/scripts/adapter-e2e/mock-llm/chat-completions.d.ts

@@ -0,0 +1,8 @@
+import type { ServerResponse } from 'node:http';
+import type { MockToolCall } from '../types';
+export declare const writeChatCompletionResult: (res: ServerResponse, payload: {
+    model: string;
+    text?: string;
+    tool?: MockToolCall;
+    stream?: boolean;
+}) => void;

package/dist/scripts/adapter-e2e/mock-llm/chat-completions.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeChatCompletionResult = void 0;
+const node_crypto_1 = require("node:crypto");
+const http_1 = require("./http");
+const responses_1 = require("./responses");
+const writeChatCompletionResult = (res, payload) => {
+    const toolCall = payload.tool == null ? undefined : (0, responses_1.buildResponsesToolCall)(payload.tool);
+    const response = {
+        id: `chatcmpl_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: payload.model,
+        choices: [
+            {
+                index: 0,
+                message: {
+                    role: 'assistant',
+                    content: toolCall == null ? payload.text ?? null : null,
+                    ...(toolCall == null
+                        ? {}
+                        : {
+                            tool_calls: [
+                                {
+                                    id: toolCall.call_id,
+                                    type: 'function',
+                                    function: {
+                                        name: toolCall.name,
+                                        arguments: toolCall.arguments
+                                    }
+                                }
+                            ]
+                        })
+                },
+                finish_reason: toolCall == null ? 'stop' : 'tool_calls'
+            }
+        ],
+        usage: {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0
+        }
+    };
+    if (payload.stream !== true) {
+        (0, http_1.writeJson)(res, 200, response);
+        return;
+    }
+    res.writeHead(200, {
+        'content-type': 'text/event-stream; charset=utf-8',
+        'cache-control': 'no-cache, no-transform',
+        connection: 'keep-alive'
+    });
+    if (toolCall != null) {
+        (0, http_1.writeSseEvent)(res, 'message', {
+            id: `chatcmpl_${Date.now()}`,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: payload.model,
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        role: 'assistant',
+                        tool_calls: [
+                            {
+                                index: 0,
+                                id: toolCall.call_id,
+                                type: 'function',
+                                function: {
+                                    name: toolCall.name,
+                                    arguments: toolCall.arguments
+                                }
+                            }
+                        ]
+                    },
+                    finish_reason: null
+                }
+            ]
+        });
+        (0, http_1.writeSseEvent)(res, 'message', {
+            id: `chatcmpl_${Date.now()}`,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: payload.model,
+            choices: [
+                {
+                    index: 0,
+                    delta: {},
+                    finish_reason: 'tool_calls'
+                }
+            ]
+        });
+    }
+    else {
+        (0, http_1.writeSseEvent)(res, 'message', {
+            id: `chatcmpl_${Date.now()}`,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: payload.model,
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        role: 'assistant',
+                        content: payload.text ?? ''
+                    },
+                    finish_reason: null
+                }
+            ]
+        });
+        (0, http_1.writeSseEvent)(res, 'message', {
+            id: `chatcmpl_${Date.now()}`,
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: payload.model,
+            choices: [
+                {
+                    index: 0,
+                    delta: {},
+                    finish_reason: 'stop'
+                }
+            ]
+        });
+    }
+    res.write('data: [DONE]\n\n');
+    res.end();
+};
+exports.writeChatCompletionResult = writeChatCompletionResult;

package/dist/scripts/adapter-e2e/mock-llm/http.d.ts

@@ -0,0 +1,3 @@
+import type { ServerResponse } from 'node:http';
+export declare const writeJson: (res: ServerResponse, statusCode: number, payload: unknown) => void;
+export declare const writeSseEvent: (res: ServerResponse, event: string, payload: unknown) => void;

package/dist/scripts/adapter-e2e/mock-llm/http.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeSseEvent = exports.writeJson = void 0;
+const writeJson = (res, statusCode, payload) => {
+    res.writeHead(statusCode, { 'content-type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(payload));
+};
+exports.writeJson = writeJson;
+const writeSseEvent = (res, event, payload) => {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+};
+exports.writeSseEvent = writeSseEvent;

package/dist/scripts/adapter-e2e/mock-llm/registry.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject, MockModelScenario, MockScenarioTurn } from '../types';
+export declare const resolveMockScenario: (scenarios: MockModelScenario[], model: string) => MockModelScenario | undefined;
+export declare const resolveMockTurn: (scenarios: MockModelScenario[], model: string, body: JsonObject) => MockScenarioTurn;