@metrio-ai/cli 1.0.0

package/dist/commands/workflow.js

@@ -0,0 +1,666 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRACE_MODES = void 0;
+exports.shapeWorkflowOutput = shapeWorkflowOutput;
+exports.runWorkflowCommand = runWorkflowCommand;
+exports.parseWorkflowCases = parseWorkflowCases;
+exports.mergeCaseJson = mergeCaseJson;
+exports.runWorkflowBatch = runWorkflowBatch;
+const client_1 = require("@metrio-ai/client");
+const client_2 = require("@metrio-ai/client");
+const shared_1 = require("./shared");
+const path = __importStar(require("path"));
+const WORKFLOW_HELP = `metrio workflow - run MetrioAI workflows
+
+Usage:
+  metrio workflow run [options]        Run one workflow completion
+  metrio workflow run-batch [options]  Run several cases in one process
+
+Run "metrio workflow run --help" or "metrio workflow run-batch --help" for the
+full option list of either command.
+`;
+const WORKFLOW_RUN_HELP = `metrio workflow run - run a MetrioAI workflow completion
+
+Usage:
+  metrio workflow run --workflow-id <slug> (--message <text> | --messages-file <path>) [options]
+
+Required:
+  -w, --workflow-id <slug>   Workflow slug (e.g. groceriesfriends-order)
+  One of:
+      --message <text>       A single user text message
+      --messages-file <path> Path to a messages JSON file (same format as chat)
+
+Options:
+      --version <n>          Pin a workflow version (positive integer; default: active version)
+      --channel <json>       Channel JSON, e.g. '{"User":{"name":"...","customer_id":"..."}}'
+      --variables <json>     Variables JSON, surfaced as $variables
+      --timezone <tz>        IANA timezone, e.g. "Asia/Taipei"
+      --request-tag <tag>    Request-level tag recorded on the run, e.g. "test"
+                             (repeatable; max 5; each 1-32 chars, lowercase
+                             alphanumeric start, may contain "-" and "_")
+      --trace <mode>         Node trace detail; requires --json (default: summary)
+                               path     node_id, type, went_to, elapsed_ms
+                                        (+ error when a node failed); no state
+                               summary  same fields, adds "state" (the default)
+                               full     adds per-node input/output (debugging)
+  -e, --env <file>           Env file to load (default: .env in the current dir)
+      --api-key <key>        API key (overrides env file / environment)
+      --base-url <url>       Base API URL (overrides env file / environment)
+      --json                 Print the full response JSON (default: reply only)
+  -h, --help                 Show this help
+
+Environment (read from the env file or the shell; flags take precedence):
+  METRIOAI_API_KEY / METRIO_API_KEY / METRIO_PROJECT_API_KEY   API key
+  METRIOAI_BASE_URL / METRIO_BASE_URL                          Base URL
+
+By default a human-readable reply is printed to stdout (text content, or the
+pretty-printed structContent for struct replies), with a one-line run summary
+(llmCalls, elapsedTime, taskId) on stderr. Use --json for the full response.
+With --json the output is flattened for assertions: "path" (the node id
+sequence), "terminalNodeId" and "tags" are always present — including on
+silent runs — so one call is enough to verify a route.
+`;
+/** Accepted `--trace` values, in help-text order. */
+exports.TRACE_MODES = ['path', 'summary', 'full'];
+/**
+ * Flattens a workflow response into the shape assertions read.
+ *
+ * Adds `path` (the node id sequence) and guarantees `terminalNodeId`, deriving
+ * it from the trace when talking to a backend that predates the field. Every
+ * field the API returned is preserved, so this is always a superset of the raw
+ * body — modes only decide how much trace detail comes along.
+ */
+function shapeWorkflowOutput(res, mode) {
+    const nodeTrace = res.nodeTrace ?? [];
+    const shaped = {
+        ...res,
+        path: nodeTrace.map((t) => t.node_id),
+    };
+    if (shaped.terminalNodeId === undefined) {
+        shaped.terminalNodeId = nodeTrace.length
+            ? nodeTrace[nodeTrace.length - 1].node_id
+            : null;
+    }
+    // The documented --json contract promises `tags` (and, outside path mode,
+    // `state`) are always present, so default them when an older backend that
+    // predates the fields omits them — assertions must not be backend-version-
+    // dependent.
+    if (shaped.tags === undefined) {
+        shaped.tags = [];
+    }
+    if (shaped.state === undefined) {
+        shaped.state = {};
+    }
+    // `state` is the workflow's own run summary; path mode is deliberately the
+    // minimal routing view, so it does not carry it.
+    if (mode === 'path') {
+        delete shaped.state;
+    }
+    // The API only sends input/output for trace:"full", but strip defensively so
+    // the mode alone determines the output size.
+    if (mode !== 'full') {
+        shaped.nodeTrace = nodeTrace.map(({ input, output, ...rest }) => rest);
+    }
+    return shaped;
+}
+/**
+ * Parses the `--channel` flag. The runtime surfaces it as `$channel` and reads
+ * named keys off it, so a non-object (an array, a bare string) would silently
+ * produce an empty `$channel` — reject it at the CLI instead.
+ */
+function parseChannelFlag(raw) {
+    if (raw === undefined)
+        return undefined;
+    const parsed = (0, shared_1.parseJsonFlag)(raw, '--channel');
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('--channel must be a JSON object');
+    }
+    return parsed;
+}
+/** Parses argv for `workflow run`. Throws on malformed input. */
+function parseWorkflowArgs(argv) {
+    const options = { json: false, help: false, tags: [] };
+    const next = (i, flag) => {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            throw new Error(`Missing value for ${flag}`);
+        }
+        return value;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        let arg = argv[i];
+        let inline;
+        // Accept both `--flag value` and `--flag=value`.
+        const eq = arg.indexOf('=');
+        if (arg.startsWith('--') && eq > 2) {
+            inline = arg.slice(eq + 1);
+            arg = arg.slice(0, eq);
+        }
+        const take = (flag) => {
+            if (inline !== undefined)
+                return inline;
+            return next(i++, flag);
+        };
+        switch (arg) {
+            case '-w':
+            case '--workflow-id':
+                options.workflowId = take(arg);
+                break;
+            case '--message':
+                options.message = take(arg);
+                break;
+            case '--messages-file':
+                options.messagesFile = take(arg);
+                break;
+            case '--version': {
+                const raw = take(arg);
+                const v = Number(raw);
+                if (!Number.isInteger(v) || v <= 0) {
+                    throw new Error(`--version must be a positive integer, got "${raw}"`);
+                }
+                options.version = v;
+                break;
+            }
+            case '--channel':
+                options.channel = take(arg);
+                break;
+            case '--variables':
+                options.variables = take(arg);
+                break;
+            case '--timezone':
+                options.timezone = take(arg);
+                break;
+            case '--request-tag': {
+                const tag = take(arg).trim();
+                if (!tag) {
+                    throw new Error('--request-tag cannot be empty');
+                }
+                options.tags.push(tag);
+                break;
+            }
+            case '--trace': {
+                const raw = take(arg);
+                if (!exports.TRACE_MODES.includes(raw)) {
+                    throw new Error(`--trace must be one of ${exports.TRACE_MODES.join('|')}, got "${raw}"`);
+                }
+                options.trace = raw;
+                break;
+            }
+            case '-e':
+            case '--env':
+                options.envFile = take(arg);
+                break;
+            case '--api-key':
+                options.apiKey = take(arg);
+                break;
+            case '--base-url':
+                options.baseUrl = take(arg);
+                break;
+            case '--json':
+                if (inline !== undefined) {
+                    throw new Error('--json does not take a value');
+                }
+                options.json = true;
+                break;
+            case '-h':
+            case '--help':
+                if (inline !== undefined) {
+                    throw new Error('--help does not take a value');
+                }
+                options.help = true;
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+/** The `workflow run` subcommand: run a workflow completion. */
+async function runWorkflowCommand(argv) {
+    const action = argv[0];
+    if (action === undefined || action === '-h' || action === '--help') {
+        process.stdout.write(WORKFLOW_HELP);
+        return;
+    }
+    if (action === 'run-batch') {
+        await runWorkflowBatch(argv.slice(1));
+        return;
+    }
+    if (action !== 'run') {
+        throw new Error(`Unknown workflow command: "${action}". Try "workflow run" or "workflow run-batch".`);
+    }
+    const options = parseWorkflowArgs(argv.slice(1));
+    if (options.help) {
+        process.stdout.write(WORKFLOW_RUN_HELP);
+        return;
+    }
+    if (!options.workflowId || options.workflowId.trim() === '') {
+        throw new Error('Missing required option: --workflow-id');
+    }
+    if (options.message === undefined && options.messagesFile === undefined) {
+        throw new Error('Provide either --message <text> or --messages-file <path>');
+    }
+    if (options.message !== undefined && options.messagesFile !== undefined) {
+        throw new Error('Use only one of --message or --messages-file');
+    }
+    if (options.trace !== undefined && !options.json) {
+        throw new Error('--trace requires --json (the human-readable output prints the reply only)');
+    }
+    (0, shared_1.loadEnv)(options.envFile);
+    // Build messages: either a single user text message or a full messages file.
+    let messages;
+    if (options.messagesFile !== undefined) {
+        const baseDir = path.dirname(path.resolve(options.messagesFile));
+        messages = (0, shared_1.buildMessages)((0, shared_1.readMessagesFile)(options.messagesFile), baseDir);
+    }
+    else {
+        if (options.message.trim() === '') {
+            throw new Error('--message cannot be empty');
+        }
+        messages = [{ role: 'user', content: { type: 'text', text: options.message } }];
+    }
+    if (messages.length === 0) {
+        throw new Error('Messages cannot be empty');
+    }
+    const channel = parseChannelFlag(options.channel);
+    const variables = options.variables !== undefined ? (0, shared_1.parseJsonFlag)(options.variables, '--variables') : undefined;
+    const client = new client_1.MetrioAI({
+        apiKey: (0, shared_1.resolveApiKey)(options.apiKey),
+        baseUrl: (0, shared_1.resolveBaseUrl)(options.baseUrl),
+    });
+    const req = {
+        workflowId: options.workflowId,
+        messages,
+        version: options.version,
+        channel,
+        variables,
+        timezone: options.timezone,
+        tags: options.tags.length ? options.tags : undefined,
+        // Only "full" needs the heavier server-side trace; path and summary are
+        // both served by the default routing trace.
+        trace: options.trace === 'full' ? 'full' : undefined,
+    };
+    const res = await client.workflowCompletion(req);
+    if (options.json) {
+        const shaped = shapeWorkflowOutput(res, options.trace ?? 'summary');
+        process.stdout.write(`${JSON.stringify(shaped, null, 2)}\n`);
+    }
+    else {
+        const reply = res.reply;
+        if (!reply) {
+            process.stdout.write(`${res.response ?? ''}\n`);
+        }
+        else if (reply.responseType === 'struct') {
+            process.stdout.write(`${JSON.stringify(reply.structContent, null, 2)}\n`);
+        }
+        else if (reply.responseType === 'text') {
+            process.stdout.write(`${reply.content ?? ''}\n`);
+        }
+        else {
+            process.stdout.write(`${reply.reason ?? '(no response)'}\n`);
+        }
+    }
+    // Run summary goes to stderr so stdout stays clean for piping. A disabled
+    // workflow returns 200 with skipped=true, so surface that instead of letting
+    // it look like a normal successful run.
+    const summary = [
+        `version=${res.version}`,
+        `llmCalls=${res.llmCalls}`,
+        `elapsedTime=${res.elapsedTime}ms`,
+        `taskId=${res.taskId}`,
+    ];
+    if (res.terminalNodeId)
+        summary.push(`terminal=${res.terminalNodeId}`);
+    if (res.tags?.length)
+        summary.push(`tags=${res.tags.join(',')}`);
+    if (res.skipped)
+        summary.push('skipped=true');
+    process.stderr.write(`workflow run: ${summary.join(', ')}\n`);
+}
+const WORKFLOW_BATCH_HELP = `metrio workflow run-batch - run several workflow cases in one process
+
+Usage:
+  metrio workflow run-batch -w <slug> --cases <file.jsonl> [options]
+
+Required:
+  -w, --workflow-id <slug>   Workflow slug (e.g. groceriesfriends-order)
+      --cases <file>         JSONL cases file; "-" reads stdin
+
+Options:
+      --concurrency <n>      Cases to run at once (default: 4)
+      --version <n>          Pin a workflow version for every case
+                             (positive integer; a case may override)
+      --channel <json>       Channel JSON applied to every case
+      --variables <json>     Variables JSON applied to every case
+      --timezone <tz>        IANA timezone, e.g. "Asia/Taipei"
+      --request-tag <tag>    Request-level tag recorded on every run, e.g. "test"
+                             (repeatable; max 5; each 1-32 chars, lowercase
+                             alphanumeric start, may contain "-" and "_")
+      --trace <mode>         Node trace detail per case (default: summary;
+                             no --json needed, batch output is always JSON)
+                               path     node_id, type, went_to, elapsed_ms
+                                        (+ error when a node failed); no state
+                               summary  same fields, adds "state" (the default)
+                               full     adds per-node input/output (debugging)
+  -o, --out <file>           Write result JSONL here (default: stdout)
+  -e, --env <file>           Env file to load (default: .env in the current dir)
+      --api-key <key>        API key (overrides env file / environment)
+      --base-url <url>       Base API URL (overrides env file / environment)
+  -h, --help                 Show this help
+
+Cases file format (one JSON object per line; blank and "//" lines are ignored):
+  {"id":"c1","message":"我要訂三鳥"}
+  {"id":"c2","messages":[{"role":"user","content":"…"}],"channel":{"User":{"name":"…"}},"variables":{"k":"v"},"version":3}
+
+Each case takes either "message" (a single user text) or "messages" (the same
+format as the chat command's messages file, including "file" attachments —
+paths resolve relative to the cases file, or the current directory when reading
+stdin). A case without an "id" is named by its line number, e.g. "case-3".
+
+"channel" and "variables" merge key by key over the global flags with the case
+winning; "version" replaces the global --version for that case.
+
+Results are JSONL in input order, one line per case — a successful row carries
+the same fields as "workflow run --json", so route assertions read the same:
+  {"id":"c1","ok":true,"path":["parse","reply"],"terminalNodeId":"reply","tags":[],"state":{…},"reply":{…}}
+  {"id":"c2","ok":false,"error":{"message":"…","status":404}}
+
+Progress goes to stderr as each case finishes — "[2/3] c2 ok 843ms
+terminal=reply" in completion order, then a "3 cases: 2 ok, 1 failed" tally —
+so stdout carries nothing but the result rows. Those rows are written once the
+whole batch has finished, not streamed per case, so watch stderr for live
+progress.
+
+A failing case does not stop the batch. The exit code is 1 if any case failed.
+`;
+/** True for a JSON object — not an array, not null, not a scalar. */
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Parses a JSONL cases file into workflow cases, validating the fields this
+ * command sends. Line numbering and the `case-<line>` fallback id come from
+ * the shared JSONL reader, so every batch command names cases the same way.
+ */
+function parseWorkflowCases(raw) {
+    return (0, shared_1.parseJsonlObjects)(raw).map(({ line, value }) => {
+        const hasMessage = value.message !== undefined;
+        const hasMessages = value.messages !== undefined;
+        if (hasMessage && hasMessages) {
+            throw new Error(`Case on line ${line} must use only one of "message" or "messages"`);
+        }
+        let messages;
+        if (hasMessage) {
+            if (typeof value.message !== 'string' || value.message.trim() === '') {
+                throw new Error(`Case on line ${line}: "message" must be a non-empty string`);
+            }
+            messages = [{ role: 'user', content: value.message }];
+        }
+        else {
+            if (!Array.isArray(value.messages) || value.messages.length === 0) {
+                throw new Error(`Case on line ${line} must have a "message" string or a non-empty "messages" array`);
+            }
+            messages = value.messages;
+        }
+        // A non-object channel would reach the runtime as an empty `$channel` and
+        // the case would run "ok" against the wrong user — reject it here.
+        if (value.channel !== undefined && !isPlainObject(value.channel)) {
+            throw new Error(`Case on line ${line}: "channel" must be a JSON object`);
+        }
+        if (value.version !== undefined &&
+            (!Number.isInteger(value.version) || value.version <= 0)) {
+            throw new Error(`Case on line ${line}: "version" must be a positive integer`);
+        }
+        return {
+            id: (0, shared_1.caseIdFor)(value, line),
+            messages,
+            channel: value.channel,
+            variables: value.variables,
+            version: value.version,
+        };
+    });
+}
+/**
+ * Layers a case's own `channel`/`variables` over the batch-wide flag value.
+ * Two plain objects merge key by key with the case winning, so a batch can
+ * share a channel and vary one field; anything else (an array, a scalar) is
+ * replaced wholesale, because there is no meaningful per-key merge.
+ */
+function mergeCaseJson(global, caseValue) {
+    if (caseValue === undefined)
+        return global;
+    if (global === undefined)
+        return caseValue;
+    if (isPlainObject(global) && isPlainObject(caseValue))
+        return { ...global, ...caseValue };
+    return caseValue;
+}
+/** Parses argv for `workflow run-batch`. Throws on malformed input. */
+function parseWorkflowBatchArgs(argv) {
+    const options = {
+        concurrency: 4,
+        tags: [],
+        trace: 'summary',
+        help: false,
+    };
+    const next = (i, flag) => {
+        const value = argv[i + 1];
+        if (value === undefined) {
+            throw new Error(`Missing value for ${flag}`);
+        }
+        return value;
+    };
+    for (let i = 0; i < argv.length; i++) {
+        let arg = argv[i];
+        let inline;
+        // Accept both `--flag value` and `--flag=value`.
+        const eq = arg.indexOf('=');
+        if (arg.startsWith('--') && eq > 2) {
+            inline = arg.slice(eq + 1);
+            arg = arg.slice(0, eq);
+        }
+        const take = (flag) => {
+            if (inline !== undefined)
+                return inline;
+            return next(i++, flag);
+        };
+        switch (arg) {
+            case '-w':
+            case '--workflow-id':
+                options.workflowId = take(arg);
+                break;
+            case '--cases':
+                options.casesFile = take(arg);
+                break;
+            case '--concurrency': {
+                const raw = take(arg);
+                const n = Number(raw);
+                if (!Number.isInteger(n) || n <= 0) {
+                    throw new Error(`--concurrency must be a positive integer, got "${raw}"`);
+                }
+                options.concurrency = n;
+                break;
+            }
+            case '--version': {
+                const raw = take(arg);
+                const v = Number(raw);
+                if (!Number.isInteger(v) || v <= 0) {
+                    throw new Error(`--version must be a positive integer, got "${raw}"`);
+                }
+                options.version = v;
+                break;
+            }
+            case '--channel':
+                options.channel = take(arg);
+                break;
+            case '--variables':
+                options.variables = take(arg);
+                break;
+            case '--timezone':
+                options.timezone = take(arg);
+                break;
+            case '--request-tag': {
+                const tag = take(arg).trim();
+                if (!tag) {
+                    throw new Error('--request-tag cannot be empty');
+                }
+                options.tags.push(tag);
+                break;
+            }
+            case '--trace': {
+                const raw = take(arg);
+                if (!exports.TRACE_MODES.includes(raw)) {
+                    throw new Error(`--trace must be one of ${exports.TRACE_MODES.join('|')}, got "${raw}"`);
+                }
+                options.trace = raw;
+                break;
+            }
+            case '-o':
+            case '--out':
+                options.out = take(arg);
+                break;
+            case '-e':
+            case '--env':
+                options.envFile = take(arg);
+                break;
+            case '--api-key':
+                options.apiKey = take(arg);
+                break;
+            case '--base-url':
+                options.baseUrl = take(arg);
+                break;
+            case '-h':
+            case '--help':
+                if (inline !== undefined) {
+                    throw new Error('--help does not take a value');
+                }
+                options.help = true;
+                break;
+            default:
+                throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+/**
+ * The `workflow run-batch` subcommand: run several cases against one workflow
+ * with bounded concurrency.
+ *
+ * Each case is an independent workflow completion; the wins over a shell loop
+ * are paying process start-up and env loading once, running cases in parallel,
+ * and getting one JSONL stream in input order to diff across runs.
+ */
+async function runWorkflowBatch(argv) {
+    const options = parseWorkflowBatchArgs(argv);
+    if (options.help) {
+        process.stdout.write(WORKFLOW_BATCH_HELP);
+        return;
+    }
+    if (!options.workflowId || options.workflowId.trim() === '') {
+        throw new Error('Missing required option: --workflow-id');
+    }
+    if (!options.casesFile) {
+        throw new Error('Missing required option: --cases');
+    }
+    (0, shared_1.loadEnv)(options.envFile);
+    const globalChannel = parseChannelFlag(options.channel);
+    const globalVariables = options.variables !== undefined ? (0, shared_1.parseJsonFlag)(options.variables, '--variables') : undefined;
+    const { raw, baseDir } = await (0, shared_1.readCasesSource)(options.casesFile);
+    const cases = parseWorkflowCases(raw);
+    const client = new client_1.MetrioAI({
+        apiKey: (0, shared_1.resolveApiKey)(options.apiKey),
+        baseUrl: (0, shared_1.resolveBaseUrl)(options.baseUrl),
+    });
+    let completed = 0;
+    const results = await (0, shared_1.mapWithConcurrency)(cases, options.concurrency, async (c) => {
+        const row = await runOneWorkflowCase(client, c, baseDir, options, {
+            channel: globalChannel,
+            variables: globalVariables,
+        });
+        // Progress is reported as cases finish, so the counter is completion order
+        // even though the emitted rows stay in input order.
+        completed++;
+        process.stderr.write(`[${completed}/${cases.length}] ${c.id} ${describeRow(row)}\n`);
+        return row;
+    });
+    (0, shared_1.emitBatchResults)(results, options.out);
+}
+/** The one-line stderr progress description for a finished case. */
+function describeRow(row) {
+    if (!row.ok) {
+        return `failed: ${row.error?.message}`;
+    }
+    const parts = [`ok ${row.elapsedTime}ms`];
+    if (row.terminalNodeId)
+        parts.push(`terminal=${row.terminalNodeId}`);
+    if (row.skipped)
+        parts.push('skipped=true');
+    return parts.join(' ');
+}
+/** Runs a single case, converting any failure into a result row. */
+async function runOneWorkflowCase(client, c, baseDir, options, globals) {
+    try {
+        const req = {
+            workflowId: options.workflowId,
+            messages: (0, shared_1.buildMessages)(c.messages, baseDir),
+            version: c.version ?? options.version,
+            channel: mergeCaseJson(globals.channel, c.channel),
+            variables: mergeCaseJson(globals.variables, c.variables),
+            timezone: options.timezone,
+            tags: options.tags.length ? options.tags : undefined,
+            // Only "full" needs the heavier server-side trace; path and summary are
+            // both served by the default routing trace.
+            trace: options.trace === 'full' ? 'full' : undefined,
+        };
+        const res = await client.workflowCompletion(req);
+        const shaped = shapeWorkflowOutput(res, options.trace);
+        // Every row leads with the case id and ok; a response field of either name
+        // must not shadow them, since that is what assertions key off.
+        delete shaped.id;
+        delete shaped.ok;
+        return { id: c.id, ok: true, ...shaped };
+    }
+    catch (err) {
+        return {
+            id: c.id,
+            ok: false,
+            error: {
+                message: err instanceof Error ? err.message : String(err),
+                status: err instanceof client_2.MetrioApiError ? err.statusCode : undefined,
+            },
+        };
+    }
+}