@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMockTurn = exports.resolveMockScenario = void 0;
+const runtime_1 = require("../runtime");
+const request_1 = require("./request");
+const tooling_1 = require("./tooling");
+const defaultResolveTurn = (scenario, body) => {
+    if ((0, request_1.isTitleGenerationRequest)(body)) {
+        return {
+            kind: 'message',
+            text: scenario.title
+        };
+    }
+    if ((0, request_1.hasToolResult)(body)) {
+        return {
+            kind: 'message',
+            text: scenario.finalOutput
+        };
+    }
+    const tool = (0, tooling_1.pickToolCall)(body);
+    if (tool != null) {
+        return {
+            kind: 'tool',
+            tool
+        };
+    }
+    return {
+        kind: 'message',
+        text: scenario.finalOutput
+    };
+};
+const resolveMockScenario = (scenarios, model) => {
+    const normalized = model.trim();
+    return scenarios.find((scenario) => (normalized.includes(scenario.id) ||
+        (scenario.aliases ?? []).some(alias => normalized.includes(alias))));
+};
+exports.resolveMockScenario = resolveMockScenario;
+const resolveMockTurn = (scenarios, model, body) => {
+    const scenario = (0, exports.resolveMockScenario)(scenarios, model);
+    if (scenario == null) {
+        throw new Error(`No mock model scenario registered for ${model}`);
+    }
+    if (scenario.resolveTurn != null) {
+        return scenario.resolveTurn({
+            model,
+            body,
+            repoRoot: runtime_1.repoRoot
+        }, {
+            getRequestText: request_1.getRequestText,
+            hasToolResult: request_1.hasToolResult,
+            isTitleGenerationRequest: request_1.isTitleGenerationRequest,
+            pickToolCall: tooling_1.pickToolCall
+        });
+    }
+    return defaultResolveTurn(scenario, body);
+};
+exports.resolveMockTurn = resolveMockTurn;

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

@@ -0,0 +1,10 @@
+import { Buffer } from 'node:buffer';
+import type { JsonObject, JsonValue } from '../types';
+export declare const asObject: (value: JsonValue | undefined) => JsonObject;
+export declare const asArray: (value: JsonValue | undefined) => JsonValue[];
+export declare const readJsonBody: (req: AsyncIterable<Buffer | string>) => Promise<JsonObject>;
+export declare const getRequestInputs: (body: JsonObject) => JsonValue[];
+export declare const getRequestText: (body: JsonObject) => string;
+export declare const isTitleGenerationRequest: (body: JsonObject) => boolean;
+export declare const hasToolResult: (body: JsonObject) => boolean;
+export declare const isStreamRequest: (body: JsonObject, acceptHeader: string | undefined) => boolean;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStreamRequest = exports.hasToolResult = exports.isTitleGenerationRequest = exports.getRequestText = exports.getRequestInputs = exports.readJsonBody = exports.asArray = exports.asObject = void 0;
+const node_buffer_1 = require("node:buffer");
+const asObject = (value) => (value != null && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {});
+exports.asObject = asObject;
+const asArray = (value) => (Array.isArray(value) ? value : []);
+exports.asArray = asArray;
+const readJsonBody = async (req) => {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === 'string' ? node_buffer_1.Buffer.from(chunk) : chunk);
+    }
+    const raw = node_buffer_1.Buffer.concat(chunks).toString('utf8').trim();
+    return (raw === '' ? {} : JSON.parse(raw));
+};
+exports.readJsonBody = readJsonBody;
+const getRequestInputs = (body) => {
+    const input = body.input;
+    if (Array.isArray(input))
+        return input;
+    const messages = body.messages;
+    return Array.isArray(messages) ? messages : [];
+};
+exports.getRequestInputs = getRequestInputs;
+const getRequestText = (body) => ((0, exports.getRequestInputs)(body)
+    .flatMap((item) => {
+    const object = (0, exports.asObject)(item);
+    if (typeof object.content === 'string')
+        return [object.content];
+    if (typeof object.text === 'string')
+        return [object.text];
+    const parts = (0, exports.asArray)(object.content);
+    return parts.map((part) => {
+        const value = (0, exports.asObject)(part);
+        if (typeof value.text === 'string')
+            return value.text;
+        if (typeof value.input_text === 'string')
+            return value.input_text;
+        return '';
+    });
+})
+    .filter(text => text.trim() !== '')
+    .join('\n'));
+exports.getRequestText = getRequestText;
+const isTitleGenerationRequest = (body) => {
+    const requestText = (0, exports.getRequestText)(body);
+    return requestText.includes('Generate a title for this conversation') ||
+        requestText.includes('You are a title generator');
+};
+exports.isTitleGenerationRequest = isTitleGenerationRequest;
+const hasToolResult = (body) => ((0, exports.getRequestInputs)(body).some((item) => {
+    const value = (0, exports.asObject)(item);
+    return value.type === 'function_call_output' || value.role === 'tool';
+}));
+exports.hasToolResult = hasToolResult;
+const isStreamRequest = (body, acceptHeader) => (body.stream === true || String(acceptHeader ?? '').includes('text/event-stream'));
+exports.isStreamRequest = isStreamRequest;

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

@@ -0,0 +1,16 @@
+import type { ServerResponse } from 'node:http';
+import type { MockToolCall } from '../types';
+export declare const buildResponsesToolCall: (tool: MockToolCall) => {
+    id: string;
+    type: string;
+    status: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+};
+export declare const writeResponsesResult: (res: ServerResponse, payload: {
+    model: string;
+    text?: string;
+    tool?: MockToolCall;
+    stream?: boolean;
+}) => void;

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

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeResponsesResult = exports.buildResponsesToolCall = void 0;
+const node_crypto_1 = require("node:crypto");
+const http_1 = require("./http");
+const buildResponsesToolCall = (tool) => {
+    const callId = `call_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`;
+    return {
+        id: callId,
+        type: 'function_call',
+        status: 'completed',
+        call_id: callId,
+        name: tool.name,
+        arguments: JSON.stringify(tool.args)
+    };
+};
+exports.buildResponsesToolCall = buildResponsesToolCall;
+const buildResponsesMessage = (text) => ({
+    id: `msg_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`,
+    type: 'message',
+    role: 'assistant',
+    status: 'completed',
+    content: [
+        {
+            type: 'output_text',
+            text
+        }
+    ]
+});
+const buildResponseObject = (model, output) => ({
+    id: `resp_${(0, node_crypto_1.randomUUID)().replace(/-/g, '')}`,
+    object: 'response',
+    created_at: Math.floor(Date.now() / 1000),
+    model,
+    output,
+    parallel_tool_calls: false,
+    usage: {
+        input_tokens: 0,
+        output_tokens: 0,
+        total_tokens: 0
+    }
+});
+const writeResponsesResult = (res, payload) => {
+    const output = payload.tool != null
+        ? [(0, exports.buildResponsesToolCall)(payload.tool)]
+        : [buildResponsesMessage(payload.text ?? '')];
+    const response = buildResponseObject(payload.model, output);
+    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'
+    });
+    (0, http_1.writeSseEvent)(res, 'response.created', {
+        type: 'response.created',
+        response: {
+            id: response.id,
+            model: response.model,
+            output: []
+        }
+    });
+    if (payload.tool != null) {
+        const toolCall = output[0];
+        (0, http_1.writeSseEvent)(res, 'response.output_item.added', {
+            type: 'response.output_item.added',
+            output_index: 0,
+            item: {
+                ...toolCall,
+                status: 'in_progress',
+                arguments: ''
+            },
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+        (0, http_1.writeSseEvent)(res, 'response.function_call_arguments.delta', {
+            type: 'response.function_call_arguments.delta',
+            item_id: toolCall.id,
+            output_index: 0,
+            delta: toolCall.arguments,
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+        (0, http_1.writeSseEvent)(res, 'response.function_call_arguments.done', {
+            type: 'response.function_call_arguments.done',
+            item_id: toolCall.id,
+            output_index: 0,
+            arguments: toolCall.arguments,
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+        (0, http_1.writeSseEvent)(res, 'response.output_item.done', {
+            type: 'response.output_item.done',
+            output_index: 0,
+            item: toolCall,
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+    }
+    else {
+        const message = output[0];
+        (0, http_1.writeSseEvent)(res, 'response.output_item.added', {
+            type: 'response.output_item.added',
+            output_index: 0,
+            item: {
+                ...message,
+                status: 'in_progress',
+                content: [{ type: 'output_text', text: '' }]
+            },
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+        (0, http_1.writeSseEvent)(res, 'response.output_text.delta', {
+            type: 'response.output_text.delta',
+            item_id: message.id,
+            output_index: 0,
+            content_index: 0,
+            delta: payload.text ?? '',
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+        (0, http_1.writeSseEvent)(res, 'response.output_text.done', {
+            type: 'response.output_text.done',
+            item_id: message.id,
+            output_index: 0,
+            content_index: 0,
+            text: payload.text ?? '',
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+        (0, http_1.writeSseEvent)(res, 'response.output_item.done', {
+            type: 'response.output_item.done',
+            output_index: 0,
+            item: message,
+            response: {
+                id: response.id,
+                model: response.model
+            }
+        });
+    }
+    (0, http_1.writeSseEvent)(res, 'response.completed', {
+        type: 'response.completed',
+        response
+    });
+    res.end();
+};
+exports.writeResponsesResult = writeResponsesResult;

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

@@ -0,0 +1,22 @@
+import type { JsonObject, MockModelScenario, MockScenarioContext, MockScenarioHelpers, MockScenarioRule, MockScenarioTurn, MockToolCall } from '../types';
+type ScenarioPredicate = (context: MockScenarioContext, helpers: MockScenarioHelpers) => boolean;
+export declare const defineMockScenarioRule: (rule: MockScenarioRule) => MockScenarioRule;
+export declare const messageTurn: (text: string) => MockScenarioTurn;
+export declare const toolTurn: (name: string, args?: MockToolCall["args"]) => MockScenarioTurn;
+export declare const selectedToolTurn: (fallback?: MockScenarioTurn) => (context: MockScenarioContext, helpers: MockScenarioHelpers) => MockScenarioTurn;
+export declare const whenTitleGeneration: () => ScenarioPredicate;
+export declare const whenToolResult: () => ScenarioPredicate;
+export declare const whenRequestTextIncludes: (...needles: string[]) => ScenarioPredicate;
+export declare const whenToolsAvailable: () => ScenarioPredicate;
+export declare const whenAlways: () => ScenarioPredicate;
+export declare const andPredicates: (...predicates: ScenarioPredicate[]) => ScenarioPredicate;
+export declare const createRuleBasedMockScenario: (input: {
+    id: string;
+    title: string;
+    aliases?: string[];
+    finalOutput: string;
+    rules: MockScenarioRule[];
+    fallback?: MockScenarioTurn;
+}) => MockModelScenario;
+export declare const matchRequest: (body: JsonObject, predicates: ScenarioPredicate[], helpers: MockScenarioHelpers, model: string, repoRoot: string) => boolean;
+export {};

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchRequest = exports.createRuleBasedMockScenario = exports.andPredicates = exports.whenAlways = exports.whenToolsAvailable = exports.whenRequestTextIncludes = exports.whenToolResult = exports.whenTitleGeneration = exports.selectedToolTurn = exports.toolTurn = exports.messageTurn = exports.defineMockScenarioRule = void 0;
+const resolveTurn = (turn, context, helpers) => {
+    if (typeof turn === 'function') {
+        return turn(context, helpers);
+    }
+    return turn;
+};
+const defineMockScenarioRule = (rule) => rule;
+exports.defineMockScenarioRule = defineMockScenarioRule;
+const messageTurn = (text) => ({
+    kind: 'message',
+    text
+});
+exports.messageTurn = messageTurn;
+const toolTurn = (name, args = {}) => ({
+    kind: 'tool',
+    tool: {
+        name,
+        args
+    }
+});
+exports.toolTurn = toolTurn;
+const selectedToolTurn = (fallback) => (context, helpers) => {
+    const tool = helpers.pickToolCall(context.body);
+    if (tool != null) {
+        return {
+            kind: 'tool',
+            tool
+        };
+    }
+    return fallback ?? (0, exports.messageTurn)('');
+};
+exports.selectedToolTurn = selectedToolTurn;
+const whenTitleGeneration = () => (context, helpers) => helpers.isTitleGenerationRequest(context.body);
+exports.whenTitleGeneration = whenTitleGeneration;
+const whenToolResult = () => (context, helpers) => helpers.hasToolResult(context.body);
+exports.whenToolResult = whenToolResult;
+const whenRequestTextIncludes = (...needles) => (context, helpers) => {
+    const requestText = helpers.getRequestText(context.body);
+    return needles.every(needle => requestText.includes(needle));
+};
+exports.whenRequestTextIncludes = whenRequestTextIncludes;
+const whenToolsAvailable = () => (context, helpers) => helpers.pickToolCall(context.body) != null;
+exports.whenToolsAvailable = whenToolsAvailable;
+const whenAlways = () => () => true;
+exports.whenAlways = whenAlways;
+const andPredicates = (...predicates) => (context, helpers) => predicates.every(predicate => predicate(context, helpers));
+exports.andPredicates = andPredicates;
+const createRuleBasedMockScenario = (input) => ({
+    id: input.id,
+    title: input.title,
+    aliases: input.aliases,
+    finalOutput: input.finalOutput,
+    resolveTurn: (context, helpers) => {
+        for (const rule of input.rules) {
+            if (rule.when(context, helpers)) {
+                return resolveTurn(rule.respond, context, helpers);
+            }
+        }
+        return input.fallback ?? (0, exports.messageTurn)(input.finalOutput);
+    }
+});
+exports.createRuleBasedMockScenario = createRuleBasedMockScenario;
+const matchRequest = (body, predicates, helpers, model, repoRoot) => predicates.every(predicate => predicate({ body, model, repoRoot }, helpers));
+exports.matchRequest = matchRequest;

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

@@ -0,0 +1,5 @@
+import type { MockLlmServerHandle, MockLlmServerOptions } from '../types';
+export declare const startMockLlmServer: (options?: MockLlmServerOptions) => Promise<MockLlmServerHandle>;
+export { resolveMockScenario, resolveMockTurn } from './registry';
+export { hasToolResult, isTitleGenerationRequest } from './request';
+export { pickToolCall } from './tooling';

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickToolCall = exports.isTitleGenerationRequest = exports.hasToolResult = exports.resolveMockTurn = exports.resolveMockScenario = exports.startMockLlmServer = void 0;
+const node_http_1 = require("node:http");
+const runtime_1 = require("../runtime");
+const chat_completions_1 = require("./chat-completions");
+const http_1 = require("./http");
+const registry_1 = require("./registry");
+const request_1 = require("./request");
+const responses_1 = require("./responses");
+const tooling_1 = require("./tooling");
+const createDebugLogger = (enabled) => (...args) => {
+    if (!enabled)
+        return;
+    console.error('[adapter-e2e:debug]', ...args);
+};
+const startMockLlmServer = async (options = {}) => {
+    const scenarios = options.scenarios ?? [];
+    const logDebug = createDebugLogger(options.debug ?? runtime_1.isDebugEnabled);
+    const trace = [];
+    const server = (0, node_http_1.createServer)(async (req, res) => {
+        if (req.method === 'GET' && req.url === '/health') {
+            (0, http_1.writeJson)(res, 200, { ok: true });
+            return;
+        }
+        if (req.method !== 'POST' || req.url == null) {
+            (0, http_1.writeJson)(res, 404, { error: 'not_found' });
+            return;
+        }
+        const body = await (0, request_1.readJsonBody)(req).catch(() => undefined);
+        if (body == null) {
+            (0, http_1.writeJson)(res, 400, { error: 'invalid_json' });
+            return;
+        }
+        const requestPath = req.url.split('?')[0];
+        const model = typeof body.model === 'string' && body.model.trim() !== ''
+            ? body.model
+            : 'hook-smoke-mock,unknown';
+        const requestedToolCount = (0, request_1.asArray)(body.tools).length;
+        const selectedTool = (0, tooling_1.pickToolCall)(body);
+        const shouldRejectForUnsupportedTool = !(0, request_1.isTitleGenerationRequest)(body) &&
+            !(0, request_1.hasToolResult)(body) &&
+            requestedToolCount > 0 &&
+            selectedTool == null;
+        let turn;
+        try {
+            turn = (0, registry_1.resolveMockTurn)(scenarios, model, body);
+        }
+        catch (error) {
+            logDebug('mock-llm unknown scenario', JSON.stringify({
+                model,
+                requestPath
+            }));
+            (0, http_1.writeJson)(res, 404, {
+                error: 'unknown_model_scenario',
+                message: error instanceof Error ? error.message : `No mock model scenario registered for ${model}`,
+                model
+            });
+            return;
+        }
+        const traceEntry = {
+            path: requestPath,
+            model,
+            requestText: (0, request_1.getRequestText)(body),
+            inputTypes: (0, request_1.getRequestInputs)(body).map((item) => {
+                const value = (0, request_1.asObject)(item);
+                return String(value.type ?? value.role ?? 'unknown');
+            }),
+            requestedToolCount,
+            selectedTool,
+            response: turn
+        };
+        trace.push(traceEntry);
+        logDebug('mock-llm request', JSON.stringify({
+            ...traceEntry,
+            stream: (0, request_1.isStreamRequest)(body, req.headers.accept),
+            turn: turn.kind,
+            toolCount: requestedToolCount
+        }));
+        if (shouldRejectForUnsupportedTool) {
+            (0, http_1.writeJson)(res, 422, { error: 'no_supported_tool_available' });
+            return;
+        }
+        if (requestPath.endsWith('/responses')) {
+            (0, responses_1.writeResponsesResult)(res, {
+                model,
+                text: turn.kind === 'message' ? turn.text : undefined,
+                tool: turn.kind === 'tool' ? turn.tool : undefined,
+                stream: (0, request_1.isStreamRequest)(body, req.headers.accept)
+            });
+            return;
+        }
+        if (requestPath.endsWith('/chat/completions')) {
+            (0, chat_completions_1.writeChatCompletionResult)(res, {
+                model,
+                text: turn.kind === 'message' ? turn.text : undefined,
+                tool: turn.kind === 'tool' ? turn.tool : undefined,
+                stream: (0, request_1.isStreamRequest)(body, req.headers.accept)
+            });
+            return;
+        }
+        (0, http_1.writeJson)(res, 404, { error: 'unsupported_path', path: requestPath });
+    });
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => resolve());
+    });
+    const address = server.address();
+    if (address == null || typeof address === 'string') {
+        throw new Error('Failed to determine mock LLM server address');
+    }
+    return {
+        port: address.port,
+        getTrace: () => [...trace],
+        close: async () => {
+            await new Promise((resolve, reject) => {
+                server.close((error) => {
+                    if (error != null)
+                        reject(error);
+                    else
+                        resolve();
+                });
+            });
+        }
+    };
+};
+exports.startMockLlmServer = startMockLlmServer;
+var registry_2 = require("./registry");
+Object.defineProperty(exports, "resolveMockScenario", { enumerable: true, get: function () { return registry_2.resolveMockScenario; } });
+Object.defineProperty(exports, "resolveMockTurn", { enumerable: true, get: function () { return registry_2.resolveMockTurn; } });
+var request_2 = require("./request");
+Object.defineProperty(exports, "hasToolResult", { enumerable: true, get: function () { return request_2.hasToolResult; } });
+Object.defineProperty(exports, "isTitleGenerationRequest", { enumerable: true, get: function () { return request_2.isTitleGenerationRequest; } });
+var tooling_2 = require("./tooling");
+Object.defineProperty(exports, "pickToolCall", { enumerable: true, get: function () { return tooling_2.pickToolCall; } });

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

@@ -0,0 +1,3 @@
+import type { JsonObject, MockToolCall, MockToolCandidate } from '../types';
+export declare const getToolCandidates: (body: JsonObject) => MockToolCandidate[];
+export declare const pickToolCall: (body: JsonObject) => MockToolCall | undefined;

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

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickToolCall = exports.getToolCandidates = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const runtime_1 = require("../runtime");
+const request_1 = require("./request");
+const getToolName = (tool) => {
+    if (typeof tool.name === 'string' && tool.name.trim() !== '')
+        return tool.name;
+    const func = (0, request_1.asObject)(tool.function);
+    if (typeof func.name === 'string' && func.name.trim() !== '')
+        return func.name;
+    if (typeof tool.type === 'string' && tool.type.trim() !== '' && tool.type !== 'function') {
+        return tool.type;
+    }
+    return undefined;
+};
+const getToolParameters = (tool) => {
+    const func = (0, request_1.asObject)(tool.function);
+    return (0, request_1.asObject)(tool.parameters ?? func.parameters ?? tool.input_schema ?? tool.inputSchema);
+};
+const resolveToolArgs = (toolName, toolParameters) => {
+    const normalized = toolName.toLowerCase();
+    const properties = (0, request_1.asObject)(toolParameters.properties);
+    const readmePath = node_path_1.default.resolve(runtime_1.repoRoot, 'README.md');
+    if (normalized === 'read' ||
+        'filePath' in properties ||
+        'file_path' in properties ||
+        'path' in properties) {
+        return {
+            ...('file_path' in properties ? { file_path: readmePath } : {}),
+            ...('filePath' in properties || !('file_path' in properties) ? { filePath: readmePath } : {}),
+            ...('path' in properties ? { path: readmePath } : {}),
+            offset: 1,
+            limit: 2000
+        };
+    }
+    if (normalized === 'exec_command' || 'cmd' in properties) {
+        return {
+            cmd: "sed -n '1,200p' README.md",
+            workdir: runtime_1.repoRoot,
+            yield_time_ms: 1000,
+            max_output_tokens: 2000
+        };
+    }
+    if (normalized === 'bash' ||
+        normalized === 'shell' ||
+        normalized === 'local_shell' ||
+        'command' in properties) {
+        return {
+            command: "sed -n '1,200p' README.md"
+        };
+    }
+    return {};
+};
+const getToolCandidates = (body) => ((0, request_1.asArray)(body.tools)
+    .map((value) => (0, request_1.asObject)(value))
+    .map((tool) => {
+    const name = getToolName(tool);
+    const parameters = getToolParameters(tool);
+    return {
+        name: name ?? '',
+        parameters,
+        args: name == null ? {} : resolveToolArgs(name, parameters)
+    };
+})
+    .filter(candidate => candidate.name !== ''));
+exports.getToolCandidates = getToolCandidates;
+const pickToolCall = (body) => {
+    const candidates = (0, exports.getToolCandidates)(body);
+    const preferred = candidates.find(item => item.name.toLowerCase() === 'read') ??
+        candidates.find(item => item.name.toLowerCase() === 'exec_command') ??
+        candidates.find(item => item.name.toLowerCase() === 'bash') ??
+        candidates.find(item => item.name.toLowerCase() === 'shell') ??
+        candidates.find(item => Object.keys(item.args).length > 0);
+    return preferred == null
+        ? undefined
+        : {
+            name: preferred.name,
+            args: preferred.args
+        };
+};
+exports.pickToolCall = pickToolCall;

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

@@ -0,0 +1,10 @@
+import type { AdapterE2EHarnessOptions, AdapterE2EResult, ResolvedAdapterE2ECase } from './types';
+export declare const runWrappedAdapter: (testCase: ResolvedAdapterE2ECase, mockServerPort: number, options: AdapterE2EHarnessOptions) => Promise<AdapterE2EResult>;
+export declare const runOpenCodeUpstream: (input: {
+    testCase: ResolvedAdapterE2ECase;
+    ctxId: string;
+    sessionId: string;
+    mockServerPort: number;
+    passthroughStdIO: boolean;
+}) => Promise<AdapterE2EResult>;
+export declare const runOpenCode: (testCase: ResolvedAdapterE2ECase, mockServerPort: number, options: AdapterE2EHarnessOptions) => Promise<AdapterE2EResult>;