@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/bench/officialCli.cjs

@@ -0,0 +1,204 @@
+"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__, {
+    parseOfficialBenchArgs: ()=>parseOfficialBenchArgs
+});
+const external_node_path_namespaceObject = require("node:path");
+function normalizeWingmanModel(value) {
+    const trimmed = value.trim();
+    if (trimmed.includes(":")) return trimmed;
+    const slash = trimmed.indexOf("/");
+    if (slash > 0 && slash < trimmed.length - 1) return `${trimmed.slice(0, slash)}:${trimmed.slice(slash + 1)}`;
+    return trimmed;
+}
+function parseOfficialBenchArgs(argv) {
+    const args = argv.slice(2);
+    let configPath = "bench/config.tb2.json";
+    const taskNames = [];
+    let useAllTasks = false;
+    const agentKwargs = {};
+    const overrides = {};
+    for(let i = 0; i < args.length; i += 1){
+        const arg = args[i];
+        if (("--config" === arg || "-c" === arg) && args[i + 1]) {
+            configPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--config=")) {
+            configPath = arg.slice(9);
+            continue;
+        }
+        if (("--task-id" === arg || "--task-name" === arg) && args[i + 1]) {
+            taskNames.push(args[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--task-id=")) {
+            taskNames.push(arg.slice(10));
+            continue;
+        }
+        if (arg.startsWith("--task-name=")) {
+            taskNames.push(arg.slice(12));
+            continue;
+        }
+        if ("--all-tasks" === arg) {
+            useAllTasks = true;
+            continue;
+        }
+        if ("--registry-url" === arg && args[i + 1]) {
+            overrides.registryUrl = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--registry-url=")) {
+            overrides.registryUrl = arg.slice(15);
+            continue;
+        }
+        if ("--registry-path" === arg && args[i + 1]) {
+            overrides.registryPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--registry-path=")) {
+            overrides.registryPath = arg.slice(16);
+            continue;
+        }
+        if ("--agent" === arg && args[i + 1]) {
+            overrides.agent = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--agent=")) {
+            overrides.agent = arg.slice(8);
+            continue;
+        }
+        if ("--agent-import-path" === arg && args[i + 1]) {
+            overrides.agentImportPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--agent-import-path=")) {
+            overrides.agentImportPath = arg.slice(20);
+            continue;
+        }
+        if ("--agent-kwarg" === arg && args[i + 1]) {
+            const [key, ...valueParts] = args[i + 1].split("=");
+            if (key && valueParts.length > 0) agentKwargs[key] = valueParts.join("=");
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--agent-kwarg=")) {
+            const pair = arg.slice(14);
+            const [key, ...valueParts] = pair.split("=");
+            if (key && valueParts.length > 0) agentKwargs[key] = valueParts.join("=");
+            continue;
+        }
+        if ("--wingman-agent" === arg && args[i + 1]) {
+            agentKwargs.wingman_agent = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--wingman-agent=")) {
+            agentKwargs.wingman_agent = arg.slice(16);
+            continue;
+        }
+        if ("--wingman-model" === arg && args[i + 1]) {
+            agentKwargs.wingman_model = normalizeWingmanModel(args[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--wingman-model=")) {
+            agentKwargs.wingman_model = normalizeWingmanModel(arg.slice(16));
+            continue;
+        }
+        if ("--model" === arg && args[i + 1]) {
+            overrides.model = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            overrides.model = arg.slice(8);
+            continue;
+        }
+        if ("--dataset" === arg && args[i + 1]) {
+            overrides.dataset = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--dataset=")) {
+            overrides.dataset = arg.slice(10);
+            continue;
+        }
+        if ("--n-concurrent" === arg && args[i + 1]) {
+            overrides.nConcurrent = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--n-concurrent=")) {
+            overrides.nConcurrent = Number.parseInt(arg.slice(15), 10);
+            continue;
+        }
+        if ("--n-attempts" === arg && args[i + 1]) {
+            overrides.nAttempts = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--n-attempts=")) {
+            overrides.nAttempts = Number.parseInt(arg.slice(13), 10);
+            continue;
+        }
+        if ("--n-tasks" === arg && args[i + 1]) {
+            overrides.nTasks = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--n-tasks=")) {
+            overrides.nTasks = Number.parseInt(arg.slice(10), 10);
+            continue;
+        }
+        if ("--timeout-ms" === arg && args[i + 1]) {
+            overrides.timeoutMs = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--timeout-ms=")) overrides.timeoutMs = Number.parseInt(arg.slice(13), 10);
+    }
+    if (useAllTasks) overrides.taskNames = [];
+    else if (taskNames.length > 0) overrides.taskNames = taskNames;
+    if (Object.keys(agentKwargs).length > 0) overrides.agentKwargs = agentKwargs;
+    return {
+        configPath: (0, external_node_path_namespaceObject.resolve)(process.cwd(), configPath),
+        overrides
+    };
+}
+exports.parseOfficialBenchArgs = __webpack_exports__.parseOfficialBenchArgs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parseOfficialBenchArgs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/officialCli.d.ts

@@ -0,0 +1,5 @@
+import type { OfficialBenchOverrides } from "./official.js";
+export declare function parseOfficialBenchArgs(argv: string[]): {
+    configPath: string;
+    overrides: OfficialBenchOverrides;
+};

package/dist/bench/officialCli.js

@@ -0,0 +1,170 @@
+import { resolve } from "node:path";
+function normalizeWingmanModel(value) {
+    const trimmed = value.trim();
+    if (trimmed.includes(":")) return trimmed;
+    const slash = trimmed.indexOf("/");
+    if (slash > 0 && slash < trimmed.length - 1) return `${trimmed.slice(0, slash)}:${trimmed.slice(slash + 1)}`;
+    return trimmed;
+}
+function parseOfficialBenchArgs(argv) {
+    const args = argv.slice(2);
+    let configPath = "bench/config.tb2.json";
+    const taskNames = [];
+    let useAllTasks = false;
+    const agentKwargs = {};
+    const overrides = {};
+    for(let i = 0; i < args.length; i += 1){
+        const arg = args[i];
+        if (("--config" === arg || "-c" === arg) && args[i + 1]) {
+            configPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--config=")) {
+            configPath = arg.slice(9);
+            continue;
+        }
+        if (("--task-id" === arg || "--task-name" === arg) && args[i + 1]) {
+            taskNames.push(args[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--task-id=")) {
+            taskNames.push(arg.slice(10));
+            continue;
+        }
+        if (arg.startsWith("--task-name=")) {
+            taskNames.push(arg.slice(12));
+            continue;
+        }
+        if ("--all-tasks" === arg) {
+            useAllTasks = true;
+            continue;
+        }
+        if ("--registry-url" === arg && args[i + 1]) {
+            overrides.registryUrl = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--registry-url=")) {
+            overrides.registryUrl = arg.slice(15);
+            continue;
+        }
+        if ("--registry-path" === arg && args[i + 1]) {
+            overrides.registryPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--registry-path=")) {
+            overrides.registryPath = arg.slice(16);
+            continue;
+        }
+        if ("--agent" === arg && args[i + 1]) {
+            overrides.agent = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--agent=")) {
+            overrides.agent = arg.slice(8);
+            continue;
+        }
+        if ("--agent-import-path" === arg && args[i + 1]) {
+            overrides.agentImportPath = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--agent-import-path=")) {
+            overrides.agentImportPath = arg.slice(20);
+            continue;
+        }
+        if ("--agent-kwarg" === arg && args[i + 1]) {
+            const [key, ...valueParts] = args[i + 1].split("=");
+            if (key && valueParts.length > 0) agentKwargs[key] = valueParts.join("=");
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--agent-kwarg=")) {
+            const pair = arg.slice(14);
+            const [key, ...valueParts] = pair.split("=");
+            if (key && valueParts.length > 0) agentKwargs[key] = valueParts.join("=");
+            continue;
+        }
+        if ("--wingman-agent" === arg && args[i + 1]) {
+            agentKwargs.wingman_agent = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--wingman-agent=")) {
+            agentKwargs.wingman_agent = arg.slice(16);
+            continue;
+        }
+        if ("--wingman-model" === arg && args[i + 1]) {
+            agentKwargs.wingman_model = normalizeWingmanModel(args[i + 1]);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--wingman-model=")) {
+            agentKwargs.wingman_model = normalizeWingmanModel(arg.slice(16));
+            continue;
+        }
+        if ("--model" === arg && args[i + 1]) {
+            overrides.model = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            overrides.model = arg.slice(8);
+            continue;
+        }
+        if ("--dataset" === arg && args[i + 1]) {
+            overrides.dataset = args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--dataset=")) {
+            overrides.dataset = arg.slice(10);
+            continue;
+        }
+        if ("--n-concurrent" === arg && args[i + 1]) {
+            overrides.nConcurrent = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--n-concurrent=")) {
+            overrides.nConcurrent = Number.parseInt(arg.slice(15), 10);
+            continue;
+        }
+        if ("--n-attempts" === arg && args[i + 1]) {
+            overrides.nAttempts = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--n-attempts=")) {
+            overrides.nAttempts = Number.parseInt(arg.slice(13), 10);
+            continue;
+        }
+        if ("--n-tasks" === arg && args[i + 1]) {
+            overrides.nTasks = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--n-tasks=")) {
+            overrides.nTasks = Number.parseInt(arg.slice(10), 10);
+            continue;
+        }
+        if ("--timeout-ms" === arg && args[i + 1]) {
+            overrides.timeoutMs = Number.parseInt(args[i + 1], 10);
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith("--timeout-ms=")) overrides.timeoutMs = Number.parseInt(arg.slice(13), 10);
+    }
+    if (useAllTasks) overrides.taskNames = [];
+    else if (taskNames.length > 0) overrides.taskNames = taskNames;
+    if (Object.keys(agentKwargs).length > 0) overrides.agentKwargs = agentKwargs;
+    return {
+        configPath: resolve(process.cwd(), configPath),
+        overrides
+    };
+}
+export { parseOfficialBenchArgs };

package/dist/bench/process.cjs

@@ -0,0 +1,78 @@
+"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__, {
+    runCommand: ()=>runCommand
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_events_namespaceObject = require("node:events");
+async function runCommand(command, args, options) {
+    const startedAt = Date.now();
+    const child = (0, external_node_child_process_namespaceObject.spawn)(command, args, {
+        cwd: options.cwd,
+        env: {
+            ...process.env,
+            ...options.env || {}
+        },
+        shell: true === options.shell,
+        stdio: [
+            "ignore",
+            "pipe",
+            "pipe"
+        ]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk)=>{
+        stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk)=>{
+        stderr += chunk.toString();
+    });
+    let timedOut = false;
+    const timer = setTimeout(()=>{
+        timedOut = true;
+        child.kill("SIGTERM");
+        setTimeout(()=>{
+            if (!child.killed) child.kill("SIGKILL");
+        }, 500);
+    }, options.timeoutMs);
+    const [code] = await (0, external_node_events_namespaceObject.once)(child, "close");
+    clearTimeout(timer);
+    return {
+        exitCode: code ?? 1,
+        timedOut,
+        durationMs: Date.now() - startedAt,
+        stdout,
+        stderr
+    };
+}
+exports.runCommand = __webpack_exports__.runCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "runCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/bench/process.d.ts

@@ -0,0 +1,14 @@
+export interface CommandExecutionOptions {
+    cwd: string;
+    timeoutMs: number;
+    env?: Record<string, string>;
+    shell?: boolean;
+}
+export interface CommandExecutionResult {
+    exitCode: number;
+    timedOut: boolean;
+    durationMs: number;
+    stdout: string;
+    stderr: string;
+}
+export declare function runCommand(command: string, args: string[], options: CommandExecutionOptions): Promise<CommandExecutionResult>;

package/dist/bench/process.js

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+async function runCommand(command, args, options) {
+    const startedAt = Date.now();
+    const child = spawn(command, args, {
+        cwd: options.cwd,
+        env: {
+            ...process.env,
+            ...options.env || {}
+        },
+        shell: true === options.shell,
+        stdio: [
+            "ignore",
+            "pipe",
+            "pipe"
+        ]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk)=>{
+        stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk)=>{
+        stderr += chunk.toString();
+    });
+    let timedOut = false;
+    const timer = setTimeout(()=>{
+        timedOut = true;
+        child.kill("SIGTERM");
+        setTimeout(()=>{
+            if (!child.killed) child.kill("SIGKILL");
+        }, 500);
+    }, options.timeoutMs);
+    const [code] = await once(child, "close");
+    clearTimeout(timer);
+    return {
+        exitCode: code ?? 1,
+        timedOut,
+        durationMs: Date.now() - startedAt,
+        stdout,
+        stderr
+    };
+}
+export { runCommand };