@wingman-ai/gateway 0.4.2 → 0.4.4

package/dist/bench/adapters/commandAdapter.cjs

@@ -0,0 +1,93 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CommandAdapter: ()=>CommandAdapter
+});
+const external_process_cjs_namespaceObject = require("../process.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function applyTemplate(input, context) {
+    return input.replaceAll("{{prompt}}", context.task.prompt).replaceAll("{{taskId}}", context.task.id).replaceAll("{{workingDirectory}}", context.workingDirectory);
+}
+function mapArgs(args, context) {
+    if (!args || 0 === args.length) return [];
+    return args.map((arg)=>applyTemplate(arg, context));
+}
+function mapEnv(env, context) {
+    const mapped = {
+        WINGMAN_BENCH_PROMPT: context.task.prompt,
+        WINGMAN_BENCH_TASK_ID: context.task.id,
+        WINGMAN_BENCH_WORKDIR: context.workingDirectory
+    };
+    for (const [key, value] of Object.entries(env || {}))mapped[key] = applyTemplate(value, context);
+    return mapped;
+}
+class CommandAdapter {
+    async invoke(context) {
+        const command = applyTemplate(this.config.command.command, context);
+        const args = mapArgs(this.config.command.args, context);
+        const env = mapEnv(this.config.command.env, context);
+        const execution = await (0, external_process_cjs_namespaceObject.runCommand)(command, args, {
+            cwd: context.workingDirectory,
+            timeoutMs: context.timeoutMs,
+            shell: this.config.command.shell,
+            env
+        });
+        return {
+            exitCode: execution.exitCode,
+            timedOut: execution.timedOut,
+            durationMs: execution.durationMs,
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            assistantText: execution.stdout.trim(),
+            errorMessage: 0 === execution.exitCode ? void 0 : execution.stderr.trim(),
+            tokens: {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0
+            }
+        };
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        this.config = config;
+    }
+}
+exports.CommandAdapter = __webpack_exports__.CommandAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CommandAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/adapters/commandAdapter.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterInvocationResult, CommandAdapterConfig, TaskRunContext, TerminalBenchAdapter } from "../types.js";
+export declare class CommandAdapter implements TerminalBenchAdapter {
+    private readonly config;
+    constructor(config: CommandAdapterConfig);
+    invoke(context: TaskRunContext): Promise<AdapterInvocationResult>;
+}

package/dist/bench/adapters/commandAdapter.js

@@ -0,0 +1,59 @@
+import { runCommand } from "../process.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function applyTemplate(input, context) {
+    return input.replaceAll("{{prompt}}", context.task.prompt).replaceAll("{{taskId}}", context.task.id).replaceAll("{{workingDirectory}}", context.workingDirectory);
+}
+function mapArgs(args, context) {
+    if (!args || 0 === args.length) return [];
+    return args.map((arg)=>applyTemplate(arg, context));
+}
+function mapEnv(env, context) {
+    const mapped = {
+        WINGMAN_BENCH_PROMPT: context.task.prompt,
+        WINGMAN_BENCH_TASK_ID: context.task.id,
+        WINGMAN_BENCH_WORKDIR: context.workingDirectory
+    };
+    for (const [key, value] of Object.entries(env || {}))mapped[key] = applyTemplate(value, context);
+    return mapped;
+}
+class CommandAdapter {
+    async invoke(context) {
+        const command = applyTemplate(this.config.command.command, context);
+        const args = mapArgs(this.config.command.args, context);
+        const env = mapEnv(this.config.command.env, context);
+        const execution = await runCommand(command, args, {
+            cwd: context.workingDirectory,
+            timeoutMs: context.timeoutMs,
+            shell: this.config.command.shell,
+            env
+        });
+        return {
+            exitCode: execution.exitCode,
+            timedOut: execution.timedOut,
+            durationMs: execution.durationMs,
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            assistantText: execution.stdout.trim(),
+            errorMessage: 0 === execution.exitCode ? void 0 : execution.stderr.trim(),
+            tokens: {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0
+            }
+        };
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        this.config = config;
+    }
+}
+export { CommandAdapter };

package/dist/bench/adapters/helpers.cjs

@@ -0,0 +1,170 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    detectAssistantFailureMessage: ()=>detectAssistantFailureMessage,
+    parseWingmanJsonOutput: ()=>parseWingmanJsonOutput
+});
+function asRecord(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    return value;
+}
+function getNumber(value) {
+    return "number" == typeof value && Number.isFinite(value) ? value : 0;
+}
+function extractTextFromContent(content) {
+    if ("string" == typeof content) return content;
+    if (!Array.isArray(content)) return "";
+    const parts = [];
+    for (const part of content){
+        if (!part || "object" != typeof part) continue;
+        const typedPart = part;
+        if ("string" == typeof typedPart.text) parts.push(typedPart.text);
+    }
+    return parts.join("");
+}
+function normalizeRoleLike(value) {
+    if ("string" != typeof value) return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+function isAssistantLikeMessage(message) {
+    const role = normalizeRoleLike(message.role);
+    if ("assistant" === role || "ai" === role) return true;
+    const type = normalizeRoleLike(message.type);
+    if ("assistant" === type || "ai" === type) return true;
+    const id = Array.isArray(message.id) ? message.id.filter((part)=>"string" == typeof part) : [];
+    return id.some((part)=>part.toLowerCase().includes("aimessage"));
+}
+function extractTextFromMessage(message) {
+    const direct = extractTextFromContent(message.content);
+    if (direct) return direct;
+    const kwargs = asRecord(message.kwargs);
+    if (kwargs) {
+        const kwargsContent = extractTextFromContent(kwargs.content);
+        if (kwargsContent) return kwargsContent;
+        if ("string" == typeof kwargs.text) return kwargs.text;
+    }
+    const data = asRecord(message.data);
+    if (data) {
+        const dataContent = extractTextFromContent(data.content);
+        if (dataContent) return dataContent;
+        if ("string" == typeof data.text) return data.text;
+    }
+    return "";
+}
+const ASSISTANT_FAILURE_PATTERNS = [
+    /^model call failed/i,
+    /\bbadrequesterror\b/i,
+    /\bstatus code\s*[45]\d{2}\b/i,
+    /\brate limit\b/i,
+    /\binsufficient[_\s-]?quota\b/i,
+    /\binvalid api key\b/i,
+    /\bauthentication\b/i
+];
+function detectAssistantFailureMessage(assistantText) {
+    const text = String(assistantText || "").trim();
+    if (!text) return;
+    for (const pattern of ASSISTANT_FAILURE_PATTERNS)if (pattern.test(text)) return text;
+}
+function collectTokenUsage(target, payload) {
+    const record = asRecord(payload);
+    if (!record) return;
+    const directInput = getNumber(record.input_tokens) || getNumber(record.inputTokens) || getNumber(record.prompt_tokens) || getNumber(record.promptTokens);
+    const directOutput = getNumber(record.output_tokens) || getNumber(record.outputTokens) || getNumber(record.completion_tokens) || getNumber(record.completionTokens);
+    const directTotal = getNumber(record.total_tokens) || getNumber(record.totalTokens);
+    if (directInput > 0) target.inputTokens = Math.max(target.inputTokens, directInput);
+    if (directOutput > 0) target.outputTokens = Math.max(target.outputTokens, directOutput);
+    if (directTotal > 0) target.totalTokens = Math.max(target.totalTokens, directTotal);
+    const nestedCandidates = [
+        record.usage,
+        record.usage_metadata,
+        record.tokenUsage,
+        record.response_metadata
+    ];
+    for (const nested of nestedCandidates){
+        const nestedRecord = asRecord(nested);
+        if (nestedRecord) collectTokenUsage(target, nestedRecord);
+    }
+}
+function parseWingmanJsonOutput(output) {
+    const lines = output.split(/\r?\n/).map((line)=>line.trim());
+    const assistantParts = [];
+    let errorMessage;
+    const tokenUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+    };
+    for (const line of lines){
+        if (!line) continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        } catch  {
+            continue;
+        }
+        const event = asRecord(parsed);
+        if (event && "string" == typeof event.type) {
+            if ("agent-error" === event.type && "string" == typeof event.error) errorMessage = event.error;
+            if ("agent-complete" === event.type) {
+                const result = asRecord(event.result);
+                const messages = Array.isArray(result?.messages) ? result?.messages : [];
+                for (const message of messages){
+                    const messageRecord = asRecord(message);
+                    if (!messageRecord || !isAssistantLikeMessage(messageRecord)) continue;
+                    const text = extractTextFromMessage(messageRecord);
+                    if (text) assistantParts.push(text);
+                }
+                collectTokenUsage(tokenUsage, result);
+            }
+            if ("agent-stream" === event.type) {
+                const chunk = asRecord(event.chunk);
+                if (!chunk) continue;
+                collectTokenUsage(tokenUsage, chunk);
+                const data = asRecord(chunk.data);
+                const streamChunk = asRecord(data?.chunk) || asRecord(data?.message);
+                if (!streamChunk) continue;
+                const text = "string" == typeof streamChunk.text ? streamChunk.text : extractTextFromContent(streamChunk.content);
+                if (text) assistantParts.push(text);
+            }
+        }
+    }
+    if (0 === tokenUsage.totalTokens) tokenUsage.totalTokens = tokenUsage.inputTokens + tokenUsage.outputTokens;
+    return {
+        assistantText: assistantParts.join("").trim(),
+        tokenUsage,
+        errorMessage
+    };
+}
+exports.detectAssistantFailureMessage = __webpack_exports__.detectAssistantFailureMessage;
+exports.parseWingmanJsonOutput = __webpack_exports__.parseWingmanJsonOutput;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectAssistantFailureMessage",
+    "parseWingmanJsonOutput"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/adapters/helpers.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterTokenUsage } from "../types.js";
+export declare function detectAssistantFailureMessage(assistantText: string | null | undefined): string | undefined;
+export declare function parseWingmanJsonOutput(output: string): {
+    assistantText: string;
+    tokenUsage: AdapterTokenUsage;
+    errorMessage?: string;
+};

package/dist/bench/adapters/helpers.js

@@ -0,0 +1,133 @@
+function asRecord(value) {
+    if (!value || "object" != typeof value || Array.isArray(value)) return null;
+    return value;
+}
+function getNumber(value) {
+    return "number" == typeof value && Number.isFinite(value) ? value : 0;
+}
+function extractTextFromContent(content) {
+    if ("string" == typeof content) return content;
+    if (!Array.isArray(content)) return "";
+    const parts = [];
+    for (const part of content){
+        if (!part || "object" != typeof part) continue;
+        const typedPart = part;
+        if ("string" == typeof typedPart.text) parts.push(typedPart.text);
+    }
+    return parts.join("");
+}
+function normalizeRoleLike(value) {
+    if ("string" != typeof value) return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+function isAssistantLikeMessage(message) {
+    const role = normalizeRoleLike(message.role);
+    if ("assistant" === role || "ai" === role) return true;
+    const type = normalizeRoleLike(message.type);
+    if ("assistant" === type || "ai" === type) return true;
+    const id = Array.isArray(message.id) ? message.id.filter((part)=>"string" == typeof part) : [];
+    return id.some((part)=>part.toLowerCase().includes("aimessage"));
+}
+function extractTextFromMessage(message) {
+    const direct = extractTextFromContent(message.content);
+    if (direct) return direct;
+    const kwargs = asRecord(message.kwargs);
+    if (kwargs) {
+        const kwargsContent = extractTextFromContent(kwargs.content);
+        if (kwargsContent) return kwargsContent;
+        if ("string" == typeof kwargs.text) return kwargs.text;
+    }
+    const data = asRecord(message.data);
+    if (data) {
+        const dataContent = extractTextFromContent(data.content);
+        if (dataContent) return dataContent;
+        if ("string" == typeof data.text) return data.text;
+    }
+    return "";
+}
+const ASSISTANT_FAILURE_PATTERNS = [
+    /^model call failed/i,
+    /\bbadrequesterror\b/i,
+    /\bstatus code\s*[45]\d{2}\b/i,
+    /\brate limit\b/i,
+    /\binsufficient[_\s-]?quota\b/i,
+    /\binvalid api key\b/i,
+    /\bauthentication\b/i
+];
+function detectAssistantFailureMessage(assistantText) {
+    const text = String(assistantText || "").trim();
+    if (!text) return;
+    for (const pattern of ASSISTANT_FAILURE_PATTERNS)if (pattern.test(text)) return text;
+}
+function collectTokenUsage(target, payload) {
+    const record = asRecord(payload);
+    if (!record) return;
+    const directInput = getNumber(record.input_tokens) || getNumber(record.inputTokens) || getNumber(record.prompt_tokens) || getNumber(record.promptTokens);
+    const directOutput = getNumber(record.output_tokens) || getNumber(record.outputTokens) || getNumber(record.completion_tokens) || getNumber(record.completionTokens);
+    const directTotal = getNumber(record.total_tokens) || getNumber(record.totalTokens);
+    if (directInput > 0) target.inputTokens = Math.max(target.inputTokens, directInput);
+    if (directOutput > 0) target.outputTokens = Math.max(target.outputTokens, directOutput);
+    if (directTotal > 0) target.totalTokens = Math.max(target.totalTokens, directTotal);
+    const nestedCandidates = [
+        record.usage,
+        record.usage_metadata,
+        record.tokenUsage,
+        record.response_metadata
+    ];
+    for (const nested of nestedCandidates){
+        const nestedRecord = asRecord(nested);
+        if (nestedRecord) collectTokenUsage(target, nestedRecord);
+    }
+}
+function parseWingmanJsonOutput(output) {
+    const lines = output.split(/\r?\n/).map((line)=>line.trim());
+    const assistantParts = [];
+    let errorMessage;
+    const tokenUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0
+    };
+    for (const line of lines){
+        if (!line) continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        } catch  {
+            continue;
+        }
+        const event = asRecord(parsed);
+        if (event && "string" == typeof event.type) {
+            if ("agent-error" === event.type && "string" == typeof event.error) errorMessage = event.error;
+            if ("agent-complete" === event.type) {
+                const result = asRecord(event.result);
+                const messages = Array.isArray(result?.messages) ? result?.messages : [];
+                for (const message of messages){
+                    const messageRecord = asRecord(message);
+                    if (!messageRecord || !isAssistantLikeMessage(messageRecord)) continue;
+                    const text = extractTextFromMessage(messageRecord);
+                    if (text) assistantParts.push(text);
+                }
+                collectTokenUsage(tokenUsage, result);
+            }
+            if ("agent-stream" === event.type) {
+                const chunk = asRecord(event.chunk);
+                if (!chunk) continue;
+                collectTokenUsage(tokenUsage, chunk);
+                const data = asRecord(chunk.data);
+                const streamChunk = asRecord(data?.chunk) || asRecord(data?.message);
+                if (!streamChunk) continue;
+                const text = "string" == typeof streamChunk.text ? streamChunk.text : extractTextFromContent(streamChunk.content);
+                if (text) assistantParts.push(text);
+            }
+        }
+    }
+    if (0 === tokenUsage.totalTokens) tokenUsage.totalTokens = tokenUsage.inputTokens + tokenUsage.outputTokens;
+    return {
+        assistantText: assistantParts.join("").trim(),
+        tokenUsage,
+        errorMessage
+    };
+}
+export { detectAssistantFailureMessage, parseWingmanJsonOutput };

package/dist/bench/adapters/index.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createAdapter: ()=>createAdapter
+});
+const external_commandAdapter_cjs_namespaceObject = require("./commandAdapter.cjs");
+const external_wingmanCliAdapter_cjs_namespaceObject = require("./wingmanCliAdapter.cjs");
+function createAdapter(config) {
+    if ("command" === config.type) return new external_commandAdapter_cjs_namespaceObject.CommandAdapter(config);
+    return new external_wingmanCliAdapter_cjs_namespaceObject.WingmanCliAdapter(config);
+}
+exports.createAdapter = __webpack_exports__.createAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/adapters/index.d.ts

@@ -0,0 +1,2 @@
+import type { TerminalBenchAdapter, TerminalBenchAdapterConfig } from "../types.js";
+export declare function createAdapter(config: TerminalBenchAdapterConfig): TerminalBenchAdapter;

package/dist/bench/adapters/index.js

@@ -0,0 +1,7 @@
+import { CommandAdapter } from "./commandAdapter.js";
+import { WingmanCliAdapter } from "./wingmanCliAdapter.js";
+function createAdapter(config) {
+    if ("command" === config.type) return new CommandAdapter(config);
+    return new WingmanCliAdapter(config);
+}
+export { createAdapter };

package/dist/bench/adapters/wingmanCliAdapter.cjs

@@ -0,0 +1,100 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    WingmanCliAdapter: ()=>WingmanCliAdapter
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_process_cjs_namespaceObject = require("../process.cjs");
+const external_helpers_cjs_namespaceObject = require("./helpers.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+function resolveAgent(config, context) {
+    return context.task.adapterOverrides?.agent || config.agent;
+}
+function resolveArgs(config, context) {
+    const overrideArgs = context.task.adapterOverrides?.extraArgs || [];
+    const extraArgs = [
+        ...config.extraArgs || [],
+        ...overrideArgs
+    ];
+    const cliArgs = [
+        "agent",
+        "--local",
+        "--output=json",
+        "--agent",
+        resolveAgent(config, context),
+        ...extraArgs,
+        context.task.prompt
+    ];
+    return cliArgs;
+}
+class WingmanCliAdapter {
+    async invoke(context) {
+        const configuredCommand = this.config.cliPath || "./bin/wingman";
+        const cliEntryPath = (0, external_node_path_namespaceObject.isAbsolute)(configuredCommand) ? configuredCommand : (0, external_node_path_namespaceObject.resolve)(process.cwd(), configuredCommand);
+        const args = resolveArgs(this.config, context);
+        const runtimeCommand = (0, external_node_fs_namespaceObject.existsSync)(process.execPath) ? process.execPath : "bun";
+        const execution = await (0, external_process_cjs_namespaceObject.runCommand)(runtimeCommand, [
+            cliEntryPath,
+            ...args
+        ], {
+            cwd: context.workingDirectory,
+            timeoutMs: context.timeoutMs,
+            env: this.config.env
+        });
+        const parsed = (0, external_helpers_cjs_namespaceObject.parseWingmanJsonOutput)(execution.stdout);
+        return {
+            exitCode: execution.exitCode,
+            timedOut: execution.timedOut,
+            durationMs: execution.durationMs,
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            assistantText: parsed.assistantText,
+            errorMessage: parsed.errorMessage || (0 === execution.exitCode ? void 0 : execution.stderr.trim()),
+            tokens: parsed.tokenUsage
+        };
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        this.config = config;
+    }
+}
+exports.WingmanCliAdapter = __webpack_exports__.WingmanCliAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WingmanCliAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/adapters/wingmanCliAdapter.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterInvocationResult, TaskRunContext, TerminalBenchAdapter, WingmanCliAdapterConfig } from "../types.js";
+export declare class WingmanCliAdapter implements TerminalBenchAdapter {
+    private readonly config;
+    constructor(config: WingmanCliAdapterConfig);
+    invoke(context: TaskRunContext): Promise<AdapterInvocationResult>;
+}