@wiro-ai/wiro-mcp 1.3.4 → 1.4.1

package/dist/utils/workflow.js

@@ -0,0 +1,712 @@
+import { z } from 'zod';
+import { asString, isPlainObject, toInteger, toNumber, truncate, unixToIso, } from './api.js';
+import { formatPrice } from './format.js';
+// Workflow rows and runs as the Wiro API returns them, projected to what an
+// assistant needs: a workflow keeps its slug, title, inputs, outputs, state,
+// counts and creator and team names, and a run its status, steps, cost and
+// outputs, resolved from the End node the same way a run does.
+export const WORKFLOW_PAGE_URL = 'https://wiro.ai/workflows/';
+export const RUN_TERMINAL_STATUSES = ['completed', 'failed', 'cancelled', 'stopped'];
+export class WorkflowInputError extends Error {
+}
+// What the workflow tools hide, and where. A secret-looking name matches
+// SENSITIVE_INPUT_KEY; a key-looking value matches looksLikeSecretValue.
+// - Input lists (get_workflow and the save results): a Start field's default and
+//   saved value show as "[hidden]" under a secret-looking name or when the value
+//   looks like a key, for every caller.
+// - get_workflow contents, for every caller: a saved value (metadata.input.values)
+//   or Start field default under a secret-looking name or that looks like a key
+//   shows as "[hidden]". For a caller outside the workflow's workspace, values
+//   under a secret-looking key at any depth of a step's input also show as
+//   "[REDACTED]". "$" references are wiring, not values, and stay as they are.
+// - wait_for_workflow_run debug_node_id: the inputs a step received, under a
+//   secret-looking key at any depth ("[hidden]").
+// update_workflow restores "[hidden]" and "[REDACTED]" from the saved workflow.
+export const SENSITIVE_INPUT_KEY = /(^|[-_])(password|secret|api[-_]?key|authorization|credentials?|private[-_]?key|access[-_]?token|refresh[-_]?token|client[-_]?secret|bearer[-_]?token|token)([-_]|$)/i;
+// The shapes of common provider API keys, which a name check alone misses
+// (an "openai_key" field, say).
+const PROVIDER_KEY_SHAPES = [
+    /^sk-[A-Za-z0-9_-]{20,}$/, // OpenAI, Anthropic
+    /^AIza[0-9A-Za-z_-]{30,}$/, // Google API
+    /^(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}$/, // GitHub
+    /^github_pat_[A-Za-z0-9_]{20,}$/, // GitHub fine-grained
+    /^xox[abprs]-[A-Za-z0-9-]{10,}$/, // Slack
+    /^AKIA[0-9A-Z]{16}$/, // AWS access key id
+    /^hf_[A-Za-z0-9]{30,}$/, // Hugging Face
+    /^r8_[A-Za-z0-9]{30,}$/, // Replicate
+    /^(sk|rk)_(live|test)_[A-Za-z0-9]{16,}$/, // Stripe
+];
+/** True for a string shaped like a known provider's API key, whatever field holds it. */
+export function looksLikeSecretValue(value) {
+    if (typeof value !== 'string')
+        return false;
+    const text = value.trim();
+    return PROVIDER_KEY_SHAPES.some(shape => shape.test(text));
+}
+function isFilledValue(value) {
+    return value !== '' && value !== null && value !== undefined;
+}
+/** Whether a Start field's default or saved value is shown as "[hidden]". */
+function hidesStartValue(key, value) {
+    return isFilledValue(value) && (looksLikeSecretValue(value) || SENSITIVE_INPUT_KEY.test(key));
+}
+/** Accepts '<slug>-<slugid>' or a wiro.ai workflow URL and returns the full slug. */
+export function parseWorkflowSlug(input) {
+    let value = input.trim();
+    if (/^https?:\/\//i.test(value)) {
+        try {
+            const url = new URL(value);
+            value = url.pathname.split('/').filter(Boolean).pop() ?? '';
+        }
+        catch {
+            throw new WorkflowInputError(`"${input}" is not a valid workflow URL.`);
+        }
+    }
+    value = decodeURIComponent(value.split(/[?#]/)[0] ?? '');
+    const separator = value.lastIndexOf('-');
+    const slugid = separator > 0 ? value.slice(separator + 1) : '';
+    if (value.length < 7 || separator <= 0 || !/^[A-Za-z0-9]{5}$/.test(slugid)) {
+        throw new WorkflowInputError(`"${input}" is not a full workflow slug. Use the "fullSlug" from list_workflows `
+            + 'or get_workflow (it ends with a dash and a 5-character id), or the workflow page URL.');
+    }
+    return value;
+}
+export function fullSlugOf(row) {
+    const slug = asString(row.slug);
+    const slugid = asString(row.slugid);
+    return slug && slugid ? `${slug}-${slugid}` : undefined;
+}
+export function workflowUrl(fullSlug) {
+    return `${WORKFLOW_PAGE_URL}${fullSlug}`;
+}
+export function parseJsonValue(value) {
+    if (typeof value !== 'string')
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function workflowTags(row) {
+    const tags = parseJsonValue(row.tags);
+    return Array.isArray(tags) ? tags.filter((tag) => typeof tag === 'string') : [];
+}
+export function workflowState(row) {
+    if (toInteger(row.ispublic) !== 1)
+        return 'private';
+    const status = toInteger(row.status, 1);
+    if (status === 2)
+        return 'published';
+    if (status === 3)
+        return 'rejected';
+    return 'pending_review';
+}
+export const workflowInputSchema = z.object({
+    key: z.string(),
+    label: z.string(),
+    type: z.string(),
+    field: z.string().optional(),
+    options: z.array(z.object({ value: z.string(), text: z.string() })).optional(),
+    default: z.unknown().optional(),
+    savedValue: z.unknown().optional(),
+});
+/** The Start fields a run takes, keyed exactly as /Workflow/Run expects. */
+export function workflowInputs(contents) {
+    if (!isPlainObject(contents))
+        return [];
+    const schema = isPlainObject(contents.schema) ? contents.schema : {};
+    const fields = isPlainObject(schema.input) ? schema.input : {};
+    const metadata = isPlainObject(contents.metadata) ? contents.metadata : {};
+    const inputMetadata = isPlainObject(metadata.input) ? metadata.input : {};
+    const values = isPlainObject(inputMetadata.values) ? inputMetadata.values : {};
+    return Object.entries(fields).map(([key, rawField]) => {
+        const field = isPlainObject(rawField) ? rawField : {};
+        const ui = isPlainObject(field.ui) ? field.ui : {};
+        const options = Array.isArray(ui.options)
+            ? ui.options
+                .filter(isPlainObject)
+                .map(option => ({
+                value: String(option.value ?? ''),
+                text: String(option.text ?? option.value ?? ''),
+            }))
+            : undefined;
+        // A summary is for showing the inputs, so a secret-looking field's value and
+        // a value that looks like a key are masked here, for every caller.
+        const shown = (value) => (hidesStartValue(key, value) ? '[hidden]' : value);
+        return {
+            key,
+            label: asString(field.label) || asString(field.name) || key,
+            type: asString(field.type) || 'string',
+            ...(asString(ui.field) ? { field: asString(ui.field) } : {}),
+            ...(options && options.length > 0 ? { options } : {}),
+            ...(Object.prototype.hasOwnProperty.call(field, 'defaultValue') ? { default: shown(field.defaultValue) } : {}),
+            ...(Object.prototype.hasOwnProperty.call(values, key) ? { savedValue: shown(values[key]) } : {}),
+        };
+    });
+}
+/** End node fields: output label to reference. */
+export function workflowOutputs(contents) {
+    if (!isPlainObject(contents) || !isPlainObject(contents.nodes))
+        return {};
+    const end = contents.nodes.output;
+    return isPlainObject(end) && isPlainObject(end.fields) ? { ...end.fields } : {};
+}
+export function workflowStepCount(contents) {
+    if (!isPlainObject(contents) || !isPlainObject(contents.nodes))
+        return 0;
+    return Object.keys(contents.nodes).filter(key => key !== 'output').length;
+}
+export const workflowSummarySchema = z.object({
+    fullSlug: z.string(),
+    url: z.string(),
+    title: z.string(),
+    description: z.string().optional(),
+    tags: z.array(z.string()),
+    state: z.enum(['private', 'pending_review', 'published', 'rejected']).optional(),
+    rejectReason: z.string().optional(),
+    isProtected: z.boolean(),
+    isClone: z.boolean().optional(),
+    stepCount: z.number().optional(),
+    toolCount: z.number().optional(),
+    models: z.array(z.string()).optional(),
+    creator: z.string().optional(),
+    team: z.string().optional(),
+    runCount: z.number().optional()
+        .describe('Runs while the workflow was in the public gallery, by anyone. Left out when there are none; the owner\'s runs of a private workflow are in list_workflow_runs.'),
+    likeCount: z.number().optional(),
+    cloneCount: z.number().optional(),
+    ratingAverage: z.number().optional(),
+    ratingCount: z.number().optional(),
+    commentCount: z.number().optional(),
+    cover: z.string().optional(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+    updatetime: z.string().optional(),
+});
+function optionalNumber(value) {
+    const parsed = toNumber(value);
+    return parsed === null ? undefined : parsed;
+}
+export function toWorkflowSummary(row, options = {}) {
+    const fullSlug = fullSlugOf(row) ?? '';
+    const user = isPlainObject(row.user) ? row.user : undefined;
+    const models = Array.isArray(row.tools)
+        ? row.tools.filter((tool) => typeof tool === 'string')
+        : undefined;
+    const description = asString(row.description);
+    const rejectReason = asString(row.rejectreason);
+    return {
+        fullSlug,
+        url: workflowUrl(fullSlug),
+        title: asString(row.title) ?? fullSlug,
+        ...(description ? { description: truncate(description, 600) } : {}),
+        tags: workflowTags(row),
+        ...(options.includeState ? { state: workflowState(row) } : {}),
+        ...(options.includeState && rejectReason ? { rejectReason } : {}),
+        isProtected: toInteger(row.isprotected) === 1,
+        ...(row.clonedfromid !== undefined ? { isClone: row.clonedfromid !== null && row.clonedfromid !== '' } : {}),
+        ...(optionalNumber(row.stepcount) !== undefined ? { stepCount: optionalNumber(row.stepcount) } : {}),
+        ...(optionalNumber(row.toolcount) !== undefined ? { toolCount: optionalNumber(row.toolcount) } : {}),
+        ...(models ? { models } : {}),
+        ...(user && asString(user.username) ? { creator: asString(user.username) } : {}),
+        ...(asString(row.teamname) ? { team: asString(row.teamname) } : {}),
+        // Wiro counts runs only while a workflow is in the public gallery, so the
+        // owner's runs of a private workflow or a copy are not in it.
+        ...((optionalNumber(row.runcount) ?? 0) > 0 ? { runCount: optionalNumber(row.runcount) } : {}),
+        ...(optionalNumber(row.likecount) !== undefined ? { likeCount: optionalNumber(row.likecount) } : {}),
+        ...(optionalNumber(row.clonecount) !== undefined ? { cloneCount: optionalNumber(row.clonecount) } : {}),
+        ...(optionalNumber(row.ratingaverage) !== undefined ? { ratingAverage: optionalNumber(row.ratingaverage) } : {}),
+        ...(optionalNumber(row.ratingcount) !== undefined ? { ratingCount: optionalNumber(row.ratingcount) } : {}),
+        ...(optionalNumber(row.commentcount) !== undefined ? { commentCount: optionalNumber(row.commentcount) } : {}),
+        ...(asString(row.cover) ? { cover: asString(row.cover) } : {}),
+        ...(unixToIso(row.createtime) ? { createdAt: unixToIso(row.createtime) } : {}),
+        ...(unixToIso(row.updatetime) ? { updatedAt: unixToIso(row.updatetime) } : {}),
+        ...(asString(row.updatetime) ? { updatetime: asString(row.updatetime) } : {}),
+    };
+}
+/** Masks, in place, the Start field defaults and saved values under a secret-looking name or that look like a key. */
+function maskStartValues(contents) {
+    const schema = isPlainObject(contents.schema) ? contents.schema : {};
+    if (isPlainObject(schema.input)) {
+        for (const [key, field] of Object.entries(schema.input)) {
+            if (isPlainObject(field) && hidesStartValue(key, field.defaultValue))
+                field.defaultValue = '[hidden]';
+        }
+    }
+    const metadata = isPlainObject(contents.metadata) ? contents.metadata : {};
+    const inputMetadata = isPlainObject(metadata.input) ? metadata.input : {};
+    if (isPlainObject(inputMetadata.values)) {
+        const values = inputMetadata.values;
+        for (const [key, value] of Object.entries(values)) {
+            if (hidesStartValue(key, value))
+                values[key] = '[hidden]';
+        }
+    }
+}
+/** A step input with every value under a secret-looking key blanked, at any depth. */
+function redactSecretKeys(value, secret = false) {
+    if (typeof value === 'string')
+        return secret && !value.startsWith('$') ? '[REDACTED]' : value;
+    if (Array.isArray(value))
+        return value.map(entry => redactSecretKeys(entry, secret));
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+            key,
+            redactSecretKeys(entry, secret || SENSITIVE_INPUT_KEY.test(key)),
+        ]));
+    }
+    return secret && value !== null && value !== undefined ? '[REDACTED]' : value;
+}
+/** The graph as a caller outside the workflow's workspace sees it. */
+function redactNodeInputs(contents) {
+    const copy = JSON.parse(JSON.stringify(contents));
+    if (isPlainObject(copy.nodes)) {
+        for (const node of Object.values(copy.nodes)) {
+            if (isPlainObject(node) && node.input !== undefined)
+                node.input = redactSecretKeys(node.input);
+        }
+    }
+    maskStartValues(copy);
+    return copy;
+}
+/** The graph as the workflow's own workspace sees it: secret Start values are hidden, step inputs are not. */
+function hideStartValues(contents) {
+    const copy = JSON.parse(JSON.stringify(contents));
+    maskStartValues(copy);
+    return copy;
+}
+export const workflowDetailSchema = workflowSummarySchema.extend({
+    insider: z.boolean(),
+    canEditGraph: z.boolean(),
+    graphHidden: z.boolean(),
+    ownerInactive: z.boolean().optional(),
+    inputs: z.array(workflowInputSchema),
+    outputs: z.record(z.string(), z.unknown()),
+    estimatedCost: z.object({
+        type: z.string().optional(),
+        valueUsd: z.number().nullable().optional(),
+        notes: z.array(z.string()).optional()
+            .describe('What the figure leaves out or counts only in part: steps charged after the run by usage or without a fixed price for their settings, steps counted as one unit of a per-unit price or at a default, and inputs that change the price.'),
+    }).optional(),
+    contents: z.record(z.string(), z.unknown()).optional(),
+});
+// What one unit of a per-unit price is, by the unit Wiro names in the estimate.
+const ESTIMATE_UNITS = {
+    'video-second': { per: 'per second of output video', unit: 'second' },
+    'audio-second': { per: 'per second of input audio', unit: 'second' },
+    'run-second': { per: 'per second of run time', unit: 'second' },
+    token: { per: 'per token', unit: 'token' },
+    character: { per: 'per character', unit: 'character' },
+};
+// Notes on a workflow's estimate, from the lines Wiro sends with it: steps the
+// figure leaves out, steps it counts as one unit or at a default, and inputs
+// that change the price.
+function estimateNotes(details) {
+    const notes = new Set();
+    const usd = (value) => {
+        const amount = toNumber(value);
+        return amount === null ? null : `$${formatPrice(amount)}`;
+    };
+    for (const detail of Array.isArray(details) ? details : []) {
+        if (!isPlainObject(detail))
+            continue;
+        const unit = asString(detail.unit);
+        const rate = usd(detail.rate);
+        const amount = usd(detail.amount);
+        const low = usd(detail.rangemin);
+        const high = usd(detail.rangemax);
+        const field = asString(detail.startfield);
+        const input = field ? `the \`${field}\` input` : 'an input';
+        if (detail.code === 'metered') {
+            const rates = typeof detail.note === 'string' ? detail.note.replace(/\s+/g, ' ').trim() : '';
+            notes.add(`A step charged after the run by usage is not in this figure${rates ? `. Its rates: ${rates}` : '.'}`);
+        }
+        else if (detail.code === 'no-price') {
+            notes.add('A step without a fixed price for its settings is not in this figure: its charge follows the time it takes.');
+        }
+        else if (detail.code === 'choose-setting') {
+            const setting = asString(detail.paramlabel) || asString(detail.param);
+            const range = low === null || high === null ? '' : low === high ? `, ${low},` : `, ${low} to ${high},`;
+            notes.add(`A step whose price depends on ${setting ? `its ${setting} setting` : 'a setting'}${range} is not in this figure.`);
+        }
+        else if (detail.code === 'per-unit') {
+            const words = unit ? ESTIMATE_UNITS[unit] : undefined;
+            if (words && rate)
+                notes.add(`A step priced at ${rate} ${words.per} counts as one ${words.unit} in this figure; it is charged for every ${words.unit}.`);
+        }
+        else if (detail.code === 'start-field') {
+            if (unit === 'image') {
+                if (low && high)
+                    notes.add(`Each image in ${input} adds ${low === high ? low : `${low} to ${high}`} by its size, which is not in this figure.`);
+            }
+            else if (unit === 'character') {
+                if (rate)
+                    notes.add(`A step priced at ${rate} per character of ${input} counts its ${toInteger(detail.defaultlength)}-character default in this figure${amount ? ` (${amount})` : ''}; other text costs more or less.`);
+            }
+            else if (unit === 'audio-second') {
+                if (rate)
+                    notes.add(`A step priced at ${rate} per second of the audio in ${input} counts as one second in this figure; it is charged for every second.`);
+            }
+            else {
+                const options = Array.isArray(detail.options)
+                    ? detail.options.filter(isPlainObject).map(option => `"${asString(option.value) ?? ''}" ${usd(option.price) ?? ''}`.trim())
+                    : [];
+                const at = (price, value) => (asString(value) ? `${price} for "${asString(value)}"` : price);
+                const prices = options.length > 0
+                    ? `: ${options.join(', ')}`
+                    : low && high ? `: ${low === high ? low : `${at(low, detail.rangeminvalue)} to ${at(high, detail.rangemaxvalue)}`}` : '';
+                const value = asString(detail.defaultvalue) ?? '';
+                const used = value === ''
+                    ? 'With no value set, that step is not in this figure.'
+                    : amount
+                        ? `The figure uses "${value}" (${amount}).`
+                        : `The figure uses "${value}", which has no price, so that step is not in it.`;
+                notes.add(`${field ? `The \`${field}\` input` : 'An input'} changes the price of a step${prices}. ${used}`);
+            }
+        }
+        else if (detail.code === 'earlier-step') {
+            if (unit === 'character') {
+                if (rate)
+                    notes.add(`A step priced at ${rate} per character of text from an earlier step counts its ${toInteger(detail.defaultlength)}-character default text in this figure${amount ? ` (${amount})` : ''}; the real text costs more or less.`);
+            }
+            else {
+                const setting = asString(detail.paramlabel) || asString(detail.param);
+                const value = asString(detail.defaultvalue);
+                const counted = value ? ` (${value}${amount ? `, ${amount}` : ''})` : amount ? ` (${amount})` : '';
+                notes.add(`A step whose ${setting ? `${setting} setting` : 'price setting'} comes from an earlier step counts at its default${counted} in this figure; it can cost ${low && high && low !== high ? `${low} to ${high}` : 'more or less'}.`);
+            }
+        }
+    }
+    return [...notes];
+}
+export function toWorkflowDetail(row, options = {}) {
+    const contents = parseJsonValue(row.contents);
+    const contentsObject = isPlainObject(contents) ? contents : {};
+    // A row with rejectreason comes from the caller's own workspace; only then
+    // are its state and rejectReason kept.
+    const insider = Object.prototype.hasOwnProperty.call(row, 'rejectreason');
+    const isProtected = toInteger(row.isprotected) === 1;
+    const isClone = row.clonedfromid !== undefined && row.clonedfromid !== null && row.clonedfromid !== '';
+    const graphHidden = row.estimatedcost !== undefined
+        || (isProtected && workflowStepCount(contentsObject) === 0);
+    const estimated = isPlainObject(row.estimatedcost) ? row.estimatedcost : undefined;
+    const notes = estimateNotes(estimated?.details);
+    const description = asString(row.description);
+    return {
+        ...toWorkflowSummary(row, { includeState: insider }),
+        // The full text: an edit starts from this value, so it must not be shortened.
+        ...(description ? { description } : {}),
+        // A hidden graph arrives emptied, so its own count would read 0; the row's
+        // stepcount, when sent, is kept instead.
+        ...(graphHidden ? {} : { stepCount: workflowStepCount(contentsObject) }),
+        insider,
+        canEditGraph: insider && !graphHidden && !(isClone && isProtected),
+        graphHidden,
+        ...(row.ownerinactive === true ? { ownerInactive: true } : {}),
+        inputs: workflowInputs(contentsObject),
+        outputs: workflowOutputs(contentsObject),
+        ...(estimated
+            ? {
+                estimatedCost: {
+                    ...(asString(estimated.type) ? { type: asString(estimated.type) } : {}),
+                    valueUsd: toNumber(estimated.value),
+                    ...(notes.length > 0 ? { notes } : {}),
+                },
+            }
+            : {}),
+        ...(options.includeGraph !== false && !graphHidden && isPlainObject(contents)
+            ? { contents: insider ? hideStartValues(contentsObject) : redactNodeInputs(contentsObject) }
+            : {}),
+    };
+}
+/** A value for a one-line summary: long text is cut inside its quotes. */
+function summaryValue(value) {
+    if (typeof value === 'string')
+        return JSON.stringify(truncate(value, 80));
+    return truncate(JSON.stringify(value) ?? '', 80);
+}
+export function formatWorkflowInputs(inputs) {
+    if (inputs.length === 0)
+        return ['No inputs. Run it with no `input`.'];
+    return inputs.map(input => {
+        const kind = input.field ? `${input.type}, ${input.field}` : input.type;
+        const fallback = input.savedValue !== undefined
+            ? ` (saved value: ${summaryValue(input.savedValue)})`
+            : input.default !== undefined && input.default !== ''
+                ? ` (default: ${summaryValue(input.default)})`
+                : '';
+        const options = input.options ? ` options: ${input.options.map(option => option.value).join(', ')}` : '';
+        return `- \`${input.key}\` (${kind}): ${input.label}${fallback}${options}`;
+    });
+}
+// ---------------------------------------------------------------------------
+// Runs
+export const runOutputItemSchema = z.object({
+    url: z.string().optional(),
+    name: z.string().optional(),
+    mimeType: z.string().optional(),
+    sizeBytes: z.number().nullable().optional(),
+    text: z.string().optional(),
+});
+export const runStepSchema = z.object({
+    nodeId: z.string(),
+    tool: z.string().optional(),
+    kind: z.string().optional(),
+    status: z.string(),
+    cause: z.string().optional(),
+    error: z.string().optional(),
+});
+export const workflowRunSchema = z.object({
+    workflowtoken: z.string(),
+    workflowSlug: z.string().optional(),
+    status: z.string(),
+    outcome: z.string().optional(),
+    canResume: z.boolean(),
+    graphMasked: z.boolean().optional(),
+    breakpointNodeId: z.string().nullable().optional(),
+    startedAt: z.string().optional(),
+    resumedAt: z.string().optional(),
+    endedAt: z.string().optional(),
+    elapsedSeconds: z.number().optional(),
+    listPriceUsd: z.number().nullable().optional(),
+    chargedUsd: z.number().nullable().optional(),
+    discountUsd: z.number().nullable().optional(),
+    outputs: z.record(z.string(), z.array(runOutputItemSchema)),
+    unresolvedOutputs: z.array(z.object({ field: z.string(), reason: z.string() })).optional(),
+    steps: z.array(runStepSchema),
+    counts: z.object({
+        failed: z.number(),
+        aborted: z.number(),
+        cancelled: z.number(),
+        pending: z.number(),
+        running: z.number(),
+        completed: z.number(),
+    }),
+});
+export function isRunTerminal(status) {
+    return RUN_TERMINAL_STATUSES.includes(String(status));
+}
+function msToIso(value) {
+    const ms = toNumber(value);
+    return ms !== null && ms > 0 ? new Date(ms).toISOString() : undefined;
+}
+export function isStrictlyEmpty(value) {
+    if (value === null || value === undefined || value === '')
+        return true;
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (isPlainObject(value))
+        return Object.keys(value).length === 0;
+    return false;
+}
+function normalizeOutputValue(value, out, depth = 0) {
+    if (depth > 6 || value === null || value === undefined)
+        return;
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            normalizeOutputValue(entry, out, depth + 1);
+        return;
+    }
+    if (typeof value === 'string') {
+        if (/^https?:\/\//i.test(value.trim()))
+            out.push({ url: value.trim() });
+        else if (value)
+            out.push({ text: truncate(value, 20_000) });
+        return;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        out.push({ text: String(value) });
+        return;
+    }
+    if (!isPlainObject(value))
+        return;
+    if (Array.isArray(value.children) && value.children.length > 0) {
+        normalizeOutputValue(value.children, out, depth + 1);
+        return;
+    }
+    if (value.contenttype === 'raw' && isPlainObject(value.content)) {
+        const answer = value.content.answer;
+        const text = Array.isArray(answer)
+            ? answer.map(part => (typeof part === 'string' ? part : isPlainObject(part) ? asString(part.text) ?? '' : '')).join('')
+            : asString(answer) ?? '';
+        if (text)
+            out.push({ text: truncate(text, 20_000) });
+        return;
+    }
+    if (typeof value.url === 'string' && value.url) {
+        out.push({
+            url: value.url,
+            ...(asString(value.name) ? { name: asString(value.name) } : {}),
+            ...(asString(value.contenttype) ? { mimeType: asString(value.contenttype) } : {}),
+            sizeBytes: toNumber(value.size),
+        });
+    }
+}
+/**
+ * Resolves the End node's fields against the run's step outputs, following the
+ * run engine: '$node-X.outputs' is a model step's output list, '$node-X.<port>'
+ * a utility port, '$input.<key>' the run's Start value, anything else a literal.
+ */
+export function resolveRunOutputs(contents, nodes) {
+    const outputs = {};
+    const unresolved = [];
+    const fields = workflowOutputs(contents);
+    const byId = new Map(nodes.map(node => [asString(node.nodeId) ?? '', node]));
+    const contentsObject = isPlainObject(contents) ? contents : {};
+    const schema = isPlainObject(contentsObject.schema) ? contentsObject.schema : {};
+    const schemaInput = isPlainObject(schema.input) ? schema.input : {};
+    const metadata = isPlainObject(contentsObject.metadata) ? contentsObject.metadata : {};
+    const metadataInput = isPlainObject(metadata.input) ? metadata.input : {};
+    const values = isPlainObject(metadataInput.values) ? metadataInput.values : {};
+    for (const [field, reference] of Object.entries(fields)) {
+        const references = Array.isArray(reference) ? reference : [reference];
+        const items = [];
+        for (const ref of references) {
+            if (typeof ref !== 'string' || !ref.startsWith('$')) {
+                normalizeOutputValue(ref, items);
+                continue;
+            }
+            if (ref.startsWith('$input.')) {
+                const key = ref.slice('$input.'.length);
+                const stored = Object.prototype.hasOwnProperty.call(values, key) ? values[key] : undefined;
+                const fieldDef = isPlainObject(schemaInput[key]) ? schemaInput[key] : {};
+                normalizeOutputValue(isStrictlyEmpty(stored) ? fieldDef.defaultValue : stored, items);
+                continue;
+            }
+            const match = /^\$(node-[^.]+)\.(.+)$/.exec(ref);
+            if (!match) {
+                unresolved.push({ field, reason: `Malformed reference ${ref}` });
+                continue;
+            }
+            const node = byId.get(match[1]);
+            if (!node) {
+                unresolved.push({ field, reason: `Step ${match[1]} is not part of this run's results` });
+                continue;
+            }
+            if (node.status !== 'completed') {
+                unresolved.push({ field, reason: `Step ${match[1]} is ${String(node.status)}` });
+                continue;
+            }
+            const stepOutputs = node.outputs;
+            if (match[2] === 'outputs' && Array.isArray(stepOutputs)) {
+                normalizeOutputValue(stepOutputs, items);
+            }
+            else if (isPlainObject(stepOutputs) && Object.prototype.hasOwnProperty.call(stepOutputs, match[2])) {
+                normalizeOutputValue(stepOutputs[match[2]], items);
+            }
+            else {
+                unresolved.push({ field, reason: `Step ${match[1]} has no output "${match[2]}"` });
+            }
+        }
+        outputs[field] = items;
+    }
+    return { outputs, unresolved };
+}
+export function toWorkflowRun(run, nodes) {
+    const status = asString(run.status) ?? 'running';
+    const terminal = isRunTerminal(status);
+    const resolved = terminal ? resolveRunOutputs(run.contents, nodes) : { outputs: {}, unresolved: [] };
+    const counts = { failed: 0, aborted: 0, cancelled: 0, pending: 0, running: 0, completed: 0 };
+    const steps = [];
+    for (const node of nodes) {
+        const nodeStatus = asString(node.status) ?? 'pending';
+        if (nodeStatus in counts)
+            counts[nodeStatus] += 1;
+        if (nodeStatus === 'completed')
+            continue;
+        const error = asString(node.error);
+        steps.push({
+            nodeId: asString(node.nodeId) ?? '',
+            ...(asString(node.tool) ? { tool: asString(node.tool) } : {}),
+            ...(asString(node.kind) ? { kind: asString(node.kind) } : {}),
+            status: nodeStatus,
+            ...(asString(node.cause) ? { cause: asString(node.cause) } : {}),
+            ...(error ? { error: truncate(error, 500) } : {}),
+        });
+    }
+    return {
+        workflowtoken: asString(run.workflowtoken) ?? '',
+        ...(asString(run.workflowslug) ? { workflowSlug: asString(run.workflowslug) } : {}),
+        status,
+        ...(asString(run.outcome) ? { outcome: asString(run.outcome) } : {}),
+        canResume: run.canresume === true,
+        ...(run.graphmasked === true ? { graphMasked: true } : {}),
+        ...(run.breakpointnodeid !== undefined ? { breakpointNodeId: asString(run.breakpointnodeid) ?? null } : {}),
+        ...(msToIso(run.startedAt) ? { startedAt: msToIso(run.startedAt) } : {}),
+        ...(msToIso(run.resumedAt) ? { resumedAt: msToIso(run.resumedAt) } : {}),
+        ...(msToIso(run.endedAt) ? { endedAt: msToIso(run.endedAt) } : {}),
+        ...(toNumber(run.elapsedseconds) !== null ? { elapsedSeconds: toNumber(run.elapsedseconds) } : {}),
+        ...(run.totalcost !== undefined ? { listPriceUsd: toNumber(run.totalcost) } : {}),
+        ...(run.chargedcost !== undefined ? { chargedUsd: toNumber(run.chargedcost) } : {}),
+        ...(run.discountamount !== undefined ? { discountUsd: toNumber(run.discountamount) } : {}),
+        outputs: resolved.outputs,
+        ...(resolved.unresolved.length > 0 ? { unresolvedOutputs: resolved.unresolved } : {}),
+        steps,
+        counts,
+    };
+}
+export function runMediaItems(run) {
+    const items = [];
+    for (const [field, values] of Object.entries(run.outputs)) {
+        for (const value of values) {
+            if (value.url)
+                items.push({ url: value.url, name: value.name || field, ...(value.mimeType ? { mimeType: value.mimeType } : {}) });
+        }
+    }
+    return items;
+}
+export function formatWorkflowRun(run) {
+    const lines = ['## Workflow Run', ''];
+    lines.push(`**Status:** ${run.status}`);
+    lines.push(`**Run token:** \`${run.workflowtoken}\``);
+    if (run.workflowSlug)
+        lines.push(`**Workflow:** ${workflowUrl(run.workflowSlug)}`);
+    if (run.elapsedSeconds !== undefined)
+        lines.push(`**Duration:** ${run.elapsedSeconds}s`);
+    if (run.chargedUsd !== undefined && run.chargedUsd !== null) {
+        lines.push(`**Charged:** $${run.chargedUsd}`);
+    }
+    else if (run.listPriceUsd !== undefined && run.listPriceUsd !== null) {
+        lines.push(`**Cost so far (list price):** $${run.listPriceUsd}`);
+    }
+    const unavailable = new Set((run.unresolvedOutputs ?? []).map(missing => missing.field));
+    const fields = Object.entries(run.outputs);
+    if (fields.length > 0) {
+        lines.push('', '### Outputs', '');
+        for (const [field, values] of fields) {
+            if (values.length === 0) {
+                // A field fed by a step that did not finish is listed once, below, as not available.
+                if (!unavailable.has(field))
+                    lines.push(`- **${field}:** (empty)`);
+                continue;
+            }
+            for (const value of values) {
+                if (value.url)
+                    lines.push(`- **${field}:** ${value.url}`);
+                else if (value.text)
+                    lines.push(`- **${field}:** ${truncate(value.text, 2_000)}`);
+            }
+        }
+    }
+    for (const missing of run.unresolvedOutputs ?? []) {
+        lines.push(`- **${missing.field}:** not available (${missing.reason})`);
+    }
+    const problems = run.steps.filter(step => step.status === 'failed' || step.status === 'aborted' || step.status === 'cancelled');
+    if (problems.length > 0) {
+        lines.push('', '### Steps that did not finish', '');
+        for (const step of problems) {
+            // A cause that only repeats the status, as a cancelled step's does, is left out.
+            const reason = step.status === 'aborted'
+                ? `skipped because an earlier step ${step.cause === 'earlier-cancellation-in-run' ? 'was cancelled' : 'failed'}`
+                : step.error || (step.cause && step.cause !== step.status ? step.cause : '');
+            lines.push(`- \`${step.nodeId}\`${step.tool ? ` (${step.tool})` : ''}: ${step.status}${reason ? `, ${reason}` : ''}`);
+        }
+    }
+    if (run.canResume) {
+        lines.push('', 'This run can be resumed with `resume_workflow_run`. Completed steps are kept and not charged again.');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=workflow.js.map