@oxygen-agent/cli 1.1014.136 → 1.1014.618

package/dist/commands/table-ingestions.js

@@ -0,0 +1,145 @@
+import { parseJsonObject, readPositiveInt } from "../cli-values.js";
+import { TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS, TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS, buildGetSurfaceRunWaitConfig, isTerminalTableIngestionStatus, readPositiveNumber } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { waitForCliRun } from "../run-wait.js";
+import { readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { Command } from "commander";
+function waitForTableIngestionRun(runId, options) {
+    return waitForCliRun(buildGetSurfaceRunWaitConfig({
+        runId,
+        endpoint: "/api/cli/table-ingestion-runs",
+        retryTransientNetworkErrors: true,
+        requestedTimeoutSeconds: options.timeoutSeconds,
+        requestedIntervalSeconds: options.intervalSeconds,
+        defaultTimeoutSeconds: TABLE_INGESTION_WAIT_DEFAULT_TIMEOUT_SECONDS,
+        defaultIntervalSeconds: TABLE_INGESTION_WAIT_DEFAULT_INTERVAL_SECONDS,
+        isTerminal: isTerminalTableIngestionStatus,
+        runKey: "ingestionRun",
+        runIdKey: "ingestionRunId",
+        timeoutCode: "table_ingestion_wait_timeout",
+        timeoutMessage: "Timed out waiting for table ingestion run to finish. Check its latest status with `oxygen table-ingestions get <run_id>`.",
+        timeoutDetailIdKey: "ingestion_run_id",
+    }));
+}
+export function registerTableIngestionsFamily(program, handleAsyncAction) {
+    program
+        .command("table-ingestions")
+        .description("Durable background table ingestion commands. To find a table's ingestion runs: `runs list --table <table>`.")
+        .addCommand(new Command("create-tool-page")
+        .description("Create a bounded paged tool-source ingestion. LinkedIn ads: --tool adyntel.linkedin_ads --rows-path response.ads --cursor-path response.continuation_token --cursor-request-key continuation_token --upsert-key ad_id. Completed means the approved bound finished; use table-ingestions items to check whether more pages remain.")
+        .argument("<table>", "Table id or slug.")
+        .option("--tool <tool_id>", "Tool id such as blitzapi.people_search or hubspot.contacts_list.")
+        .option("--tool-id <tool_id>", "Alias for --tool.")
+        .requiredOption("--request-json <json>", "Tool request JSON object for the first page.")
+        .option("--rows-path <path>", "Path from the whole tool result, including response. Defaults to response.results; LinkedIn/Google ads use response.ads.")
+        .option("--row-mapping-json <json>", "Object mapping target column keys to dotted source-row paths.")
+        .option("--cursor-path <path>", "Path from the whole tool result; Adyntel ads use response.continuation_token.")
+        .option("--cursor-request-key <path>", "Dotted request key to receive the next cursor.")
+        .option("--max-pages <n>", "Maximum pages in this item's cursor chain. Defaults to 1; a page limit is not supplier exhaustion.")
+        .option("--upsert-key <key>", "Column key used to upsert instead of inserting.")
+        .option("--connection-id <connection_id>", "Optional provider integration connection id.")
+        .option("--max-concurrency <n>", "Maximum concurrent ingestion items for this run. Defaults to 5.")
+        .option("--max-credits <n>", "Maximum credits to reserve for this run; required for paid tools.")
+        .option("--metadata-json <json>", "Optional metadata object to attach to the run.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        await handleAsyncAction("table-ingestions create-tool-page", options, () => {
+            const toolId = readOption(options.tool) ?? readOption(options.toolId);
+            if (!toolId) {
+                throw new OxygenError("invalid_table_ingestion", "Pass --tool or --tool-id.", {
+                    exitCode: 1,
+                });
+            }
+            const maxPages = readPositiveInt(options.maxPages);
+            const maxConcurrency = readPositiveInt(options.maxConcurrency);
+            const maxCredits = readPositiveNumber(options.maxCredits);
+            const rowMappingJson = readOption(options.rowMappingJson);
+            const payload = {
+                tool_id: toolId,
+                request: parseJsonObject(options.requestJson),
+                ...(readOption(options.rowsPath) ? { rows_path: readOption(options.rowsPath) } : {}),
+                ...(rowMappingJson ? { row_mapping: parseJsonObject(rowMappingJson) } : {}),
+                ...(readOption(options.cursorPath) ? { cursor_path: readOption(options.cursorPath) } : {}),
+                ...(readOption(options.cursorRequestKey) ? { cursor_request_key: readOption(options.cursorRequestKey) } : {}),
+                ...(maxPages ? { max_pages: maxPages } : {}),
+            };
+            return requestOxygen("/api/cli/table-ingestion-runs", {
+                method: "POST",
+                body: {
+                    table,
+                    source_type: "tool_page",
+                    mode: options.upsertKey ? "upsert" : "insert",
+                    ...(readOption(options.upsertKey) ? { upsert_key: readOption(options.upsertKey) } : {}),
+                    ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                    ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
+                    ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                    metadata: {
+                        command: "table-ingestions create-tool-page",
+                        ...(options.metadataJson ? parseJsonObject(options.metadataJson) : {}),
+                    },
+                    items: [
+                        {
+                            position: 0,
+                            payload,
+                        },
+                    ],
+                },
+            });
+        });
+    }))
+        .addCommand(new Command("get")
+        .description("Get one durable table ingestion run. For provider pages, completed means its bounded work finished; inspect table-ingestions items for the source cursor and exhaustion.")
+        .argument("<run_id>", "Table ingestion run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-ingestions get", options, () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}`));
+    }))
+        .addCommand(new Command("items")
+        .description("List ingestion items, including completed pages. For tool_page, item.output.has_next_cursor=true means more pages remain; item.output.stopped_by=provider_exhausted records cursor exhaustion. item.nextCursor is the saved continuation: start a new approved create-tool-page run in the same Table with that request cursor, the same filters/mapping/upsert key and a new credit cap. Inspect failed or unknown outcomes before retrying.")
+        .argument("<run_id>", "Table ingestion run UUID.")
+        .option("--status <status>", "Filter by pending, leased, completed, failed, skipped, or canceled.")
+        .option("--limit <n>", "Maximum items to return. Defaults to 100.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-ingestions items", options, () => {
+            const query = new URLSearchParams();
+            if (readOption(options.status))
+                query.set("status", readOption(options.status) ?? "");
+            const limit = readPositiveInt(options.limit);
+            if (limit)
+                query.set("limit", String(limit));
+            const suffix = query.toString() ? `?${query.toString()}` : "";
+            return requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/items${suffix}`);
+        });
+    }))
+        .addCommand(new Command("wait")
+        .description("Wait for a table ingestion run (read-only, no credits). A completed bounded run may have more provider pages; inspect table-ingestions items for has_next_cursor, stopped_by and nextCursor. Retries transient network failures, including deploy disconnects, within the same timeout.")
+        .argument("<run_id>", "Table ingestion run UUID.")
+        .option("--timeout-seconds <n>", "Maximum time to wait. Defaults to 600.")
+        .option("--interval-seconds <n>", "Polling interval. Defaults to 5.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-ingestions wait", options, () => waitForTableIngestionRun(runId, options));
+    }))
+        .addCommand(new Command("cancel")
+        .description("Request cancellation for a durable table ingestion run.")
+        .argument("<run_id>", "Table ingestion run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-ingestions cancel", options, () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/cancel`, {
+            method: "POST",
+            body: {},
+        }));
+    }))
+        .addCommand(new Command("retry-failed")
+        .description("Requeue failed items for a durable table ingestion run.")
+        .argument("<run_id>", "Table ingestion run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-ingestions retry-failed", options, () => requestOxygen(`/api/cli/table-ingestion-runs/${encodeURIComponent(runId)}/retry-failed`, {
+            method: "POST",
+            body: {},
+        }));
+    }));
+}

package/dist/commands/table-runs.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerTableRunsFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler): void;

package/dist/commands/table-runs.js

@@ -0,0 +1,277 @@
+import { parseJsonObject, readPositiveInt } from "../cli-values.js";
+import { formatRows, normalizeExportRowsFormat, parseJsonArray, readCsvOption, readFilterSelectionOption, readFormulaValuesOption, readPositiveNumber, tableRunsListPath, waitForTableActionRun } from "../command-support.js";
+import { requestOxygen } from "../http-client.js";
+import { isRecord, readOption } from "../util.js";
+import { OxygenError } from "@oxygen/shared/cli-result";
+import { tableRunSummary } from "@oxygen/shared/table-run-summary";
+import { Command } from "commander";
+import { writeFileSync } from "node:fs";
+function readTableRunActions(options) {
+    if (options.actionsJson && readOption(options.column)) {
+        throw new OxygenError("invalid_table_run", "Pass either --actions-json or --column, not both.", {
+            exitCode: 1,
+        });
+    }
+    if (options.actionsJson)
+        return parseJsonArray(options.actionsJson);
+    const column = readOption(options.column);
+    if (column)
+        return [{ type: "tool_column", column }];
+    throw new OxygenError("invalid_table_run", "Pass --column or --actions-json.", {
+        exitCode: 1,
+    });
+}
+// Parse --then-json into an array of chain steps. Server validates the shape;
+// we only enforce that the top-level value is an array of objects so users get
+// a clear local error before round-tripping to the API.
+function readChainStepsOption(value) {
+    if (!value)
+        return [];
+    const parsed = parseJsonArray(value);
+    for (let i = 0; i < parsed.length; i += 1) {
+        const entry = parsed[i];
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new OxygenError("invalid_table_run", "--then-json entries must be objects.", {
+                details: { index: i },
+                exitCode: 1,
+            });
+        }
+    }
+    return parsed;
+}
+function readTableRunSelection(options) {
+    const hasAll = Boolean(options.all);
+    const limit = readPositiveInt(options.limit);
+    const rowIds = readCsvOption(options.rowIds);
+    const filterSelection = readFilterSelectionOption(options.filterJson);
+    const formulaValues = readFormulaValuesOption(options.formulaValues);
+    if (formulaValues && !filterSelection) {
+        throw new OxygenError("invalid_table_run", "--formula-values requires --filter-json on table-runs create.", { exitCode: 1 });
+    }
+    const selectedModes = [hasAll, Boolean(limit), rowIds.length > 0, Boolean(filterSelection)].filter(Boolean).length;
+    if (selectedModes > 1) {
+        throw new OxygenError("invalid_table_run", "Pass only one of --all, --limit, --row-ids, or --filter-json.", {
+            exitCode: 1,
+        });
+    }
+    if (hasAll)
+        return { mode: "all" };
+    if (limit)
+        return { mode: "limit", limit };
+    if (rowIds.length > 0)
+        return { mode: "row_ids", row_ids: rowIds };
+    if (filterSelection) {
+        return { ...filterSelection, ...(formulaValues ? { formula_values: formulaValues } : {}) };
+    }
+    throw new OxygenError("invalid_table_run", "Pass --all, --limit, --row-ids, or --filter-json.", {
+        exitCode: 1,
+    });
+}
+// `table-runs list --format` routes run history through the same serializer
+// `tables export` uses, so csv/jsonl/table run exports behave exactly like row
+// exports (header = union of run keys; nested objects like counts are
+// JSON-stringified by escapeCsvField). Without --format/--output the command
+// keeps its original envelope response untouched.
+async function listTableRuns(options) {
+    const rawFormat = readOption(options.format);
+    const outputPath = readOption(options.output);
+    if (!rawFormat && !outputPath)
+        return requestOxygen(tableRunsListPath(options));
+    // Validate the format before spending the API call.
+    const format = normalizeExportRowsFormat(rawFormat ?? undefined);
+    const result = await requestOxygen(tableRunsListPath(options));
+    const runs = Array.isArray(result.runs) ? result.runs.filter(isRecord) : [];
+    const formatted = formatRows(runs, format);
+    if (outputPath)
+        writeFileSync(outputPath, formatted.content);
+    return {
+        table: result.table ?? null,
+        status: result.status ?? null,
+        format,
+        runCount: runs.length,
+        output: outputPath ?? null,
+        ...(outputPath ? {} : { content: formatted.content }),
+        // An empty default listing says which finished runs it hid; keep that
+        // pointer when the history is formatted instead of returned as an envelope.
+        ...(typeof result.hint === "string"
+            ? { hidden_run_count: result.hidden_run_count ?? null, hint: result.hint, next_actions: result.next_actions ?? [] }
+            : {}),
+        ...(typeof result.web_url === "string" ? { web_url: result.web_url } : {}),
+    };
+}
+export function registerTableRunsFamily(program, handleAsyncAction) {
+    program
+        .command("table-runs")
+        .description("Durable background table action run commands. `list --table <table> --status all` is a table's full action-run history, including Function runs launched from it; without --status, list shows only active runs. Imports and other writes: `runs list --table <table>`.")
+        .addCommand(new Command("create")
+        .description("Create a durable background run for table tool-column actions. Large runs are accepted immediately and their rows are prepared in the background (execution_status 'planning'); follow with `table-runs wait <run_id>`.")
+        .argument("<table>", "Table id or slug.")
+        .option("--column <column>", "Column id or key for a single tool-column action.")
+        .option("--actions-json <json>", "JSON array of actions, each with type tool_column and column.")
+        .option("--limit <n>", "Run against the newest n rows.")
+        .option("--all", "Run against all rows, up to the server cap.")
+        .option("--row-ids <csv>", "Comma-separated row UUIDs to run.")
+        .option("--filter-json <json>", "Filter object or array for server-side row selection.")
+        .option("--formula-values <mode>", "With --filter-json on a formula column, first refresh that selector with `columns run <table> <column> --force` (0 credits), then pass 'materialized'; the durable row scope filters the stored snapshot and records this freshness acknowledgement.")
+        .option("--force", "Run even when the target cell already has a value.")
+        .option("--connection-id <connection_id>", "Optional provider integration connection id.")
+        .option("--approved", "Confirm the paid table action run after inspecting a dry run or preview.")
+        .option("--max-credits <n>", "Maximum OXYGEN credits for this run, including managed calls and own-key provider platform fees. Vendor charges on your own key are outside this ceiling.")
+        .option("--max-concurrency <n>", "Maximum concurrent row items for this run (1-1000; a ceiling shared with worker and provider capacity). Defaults to 50 (160 for Firecrawl scrape columns).")
+        .option("--metadata-json <json>", "Optional metadata object to attach to the run.")
+        .option("--idempotency-key <key>", "Reuse the same scoped run when retrying this exact request.")
+        .option("--then-json <json>", "JSON array of sequential follow-up steps. Each step runs after the previous terminates with completed or completed_with_errors. Paid steps require selection and max_credits. Shape: [{actions:[{type:'tool_column',column}],selection,force,max_concurrency,max_credits,metadata,run_on_failure}].")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (table, options) => {
+        const maxCredits = readPositiveNumber(options.maxCredits);
+        const maxConcurrency = readPositiveInt(options.maxConcurrency);
+        const chainSteps = readChainStepsOption(options.thenJson);
+        await handleAsyncAction("table-runs create", options, () => requestOxygen("/api/cli/table-action-runs", {
+            method: "POST",
+            body: {
+                table,
+                actions: readTableRunActions(options),
+                selection: readTableRunSelection(options),
+                ...(options.force ? { force: true } : {}),
+                ...(readOption(options.connectionId) ? { connection_id: readOption(options.connectionId) } : {}),
+                ...(options.approved ? { approved: true } : {}),
+                ...(maxCredits !== undefined ? { max_credits: maxCredits } : {}),
+                ...(maxConcurrency ? { max_concurrency: maxConcurrency } : {}),
+                ...(options.metadataJson ? { metadata: parseJsonObject(options.metadataJson) } : {}),
+                ...(readOption(options.idempotencyKey) ? { idempotency_key: readOption(options.idempotencyKey) } : {}),
+                ...(chainSteps.length > 0 ? { then: chainSteps } : {}),
+            },
+        }));
+    }))
+        .addCommand(new Command("list")
+        .description("List durable table action runs for one table. For every run of the table, imports included, use `runs list --table <table>`.")
+        .requiredOption("--table <table>", "Table id or slug.")
+        .option("--status <status>", "Filter by all, active, queued, running, paused, completed, completed_with_errors, failed, canceling, or canceled. Defaults to active; pass all for the full action-run history in one call, including Function runs launched from this table.")
+        .option("--limit <n>", "Maximum runs to return. Defaults to 20.")
+        .option("--format <format>", "Format run history as json, jsonl, csv, or table (same serializer as `tables export`). Omit to keep the default envelope output.")
+        .option("--output <path>", "Write the formatted run history to a file instead of embedding it in the response.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (options) => {
+        await handleAsyncAction("table-runs list", options, () => listTableRuns(options));
+    }))
+        .addCommand(new Command("get")
+        .description("Get one durable table action run. For a Function run, selection.rowIds are rows of the Function's execution table, not the calling table; list the calling table's rows it wrote with `tables query <caller> --filter-tree-json` on the Function column's \"action_run_id\" path.")
+        .argument("<run_id>", "Table action run UUID or parent workspace run UUID.")
+        .option("--full", "Read the full run, including stored inputs and metadata.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs get", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}?view=${options.full ? "full" : "summary"}`)
+            .then((run) => options.full ? run : tableRunSummary(run)));
+    }))
+        .addCommand(new Command("items")
+        .description("List row items for a durable table action run. For a Function run, list the calling table's rows it wrote with `tables query <caller> --filter-tree-json` on the Function column's \"action_run_id\" path instead of joining items.")
+        .argument("<run_id>", "Table action run UUID.")
+        .option("--status <status>", "Filter by pending, leased, completed, failed, skipped, or canceled.")
+        .option("--limit <n>", "Maximum items to return. Defaults to 100.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs items", options, () => {
+            const query = new URLSearchParams();
+            if (readOption(options.status))
+                query.set("status", readOption(options.status) ?? "");
+            const limit = readPositiveInt(options.limit);
+            if (limit)
+                query.set("limit", String(limit));
+            const suffix = query.toString() ? `?${query.toString()}` : "";
+            return requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/items${suffix}`);
+        });
+    }))
+        .addCommand(new Command("wait")
+        .description("Poll a durable table action run until it finishes.")
+        .argument("<run_id>", "Table action run UUID or parent workspace run UUID.")
+        .option("--timeout-seconds <n>", "Maximum time to wait. Defaults to 600.")
+        .option("--interval-seconds <n>", "Polling interval. Defaults to 5.")
+        .option("--full", "Return the full completed run instead of a progress summary.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs wait", options, () => waitForTableActionRun(runId, options));
+    }))
+        .addCommand(new Command("provider-summary")
+        .description("Summarize provider attempts, upstream request events, and credit capture/release for a table action run.")
+        .argument("<run_id>", "Table action run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs provider-summary", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/provider-summary`));
+    }))
+        .addCommand(new Command("cancel")
+        .description("Request cancellation for a durable table action run.")
+        .argument("<run_id>", "Table action run UUID or parent workspace run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs cancel", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/cancel`, {
+            method: "POST",
+            body: {},
+        }));
+    }))
+        .addCommand(new Command("pause")
+        .description("Pause a durable table action run before it starts more row jobs.")
+        .argument("<run_id>", "Table action run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs pause", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/pause`, {
+            method: "POST",
+            body: {},
+        }));
+    }))
+        .addCommand(new Command("resume")
+        .description("Resume a paused durable table action run.")
+        .argument("<run_id>", "Table action run UUID.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs resume", options, () => requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/resume`, {
+            method: "POST",
+            body: {},
+        }));
+    }))
+        .addCommand(new Command("effect-unknown")
+        .description("List the items of a run whose external write was dispatched but never confirmed. Oxygen will not retry them on its own: verify each destination, then record what you found with `oxygen cells resolve`.")
+        .argument("<run_id>", "Table action run UUID.")
+        .option("--include-resolved", "Also list items whose outcome a human has already recorded.")
+        .option("--limit <n>", "Maximum items to return. Defaults to 200.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        await handleAsyncAction("table-runs effect-unknown", options, () => {
+            const query = new URLSearchParams();
+            const limit = readPositiveInt(options.limit);
+            if (limit)
+                query.set("limit", String(limit));
+            if (options.includeResolved)
+                query.set("include_resolved", "true");
+            const suffix = query.toString() ? `?${query.toString()}` : "";
+            return requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/effect-unknown${suffix}`);
+        });
+    }))
+        .addCommand(new Command("retry-failed")
+        .description("Retry failed Table items or wake guarded Function callbacks from completed results at zero additional credits. Review --dry-run and approve its hash and ceiling. Unconfirmed external effects stay blocked.")
+        .argument("<run_id>", "Table action run UUID.")
+        .option("--dry-run", "Read the exact retry scope and approval hash without requeueing.")
+        .option("--approved", "Approve the inspected retry scope and additional-credit ceiling.")
+        .option("--retry-plan-hash <hash>", "Hash returned by the retry dry run.")
+        .option("--max-additional-credits <n>", "Fresh credit allowance for this recovery; never raises the original lifetime ceiling.")
+        .option("--approved-effect-unknown", "After a human verifies every affected destination, explicitly allow re-executing items whose prior external effect could not be confirmed.")
+        .option("--json", "Print a JSON envelope.")
+        .action(async (runId, options) => {
+        if (options.dryRun && (options.approved || options.retryPlanHash || options.maxAdditionalCredits !== undefined || options.approvedEffectUnknown)) {
+            throw new OxygenError("invalid_request", "Use --dry-run separately from retry approval flags.", { exitCode: 2 });
+        }
+        const maxAdditionalCredits = options.maxAdditionalCredits === undefined ? undefined : Number(options.maxAdditionalCredits);
+        if (maxAdditionalCredits !== undefined && (!options.maxAdditionalCredits?.trim() || !Number.isFinite(maxAdditionalCredits) || maxAdditionalCredits < 0)) {
+            throw new OxygenError("invalid_request", "--max-additional-credits must be a nonnegative number.", { exitCode: 2 });
+        }
+        await handleAsyncAction("table-runs retry-failed", options, () => options.dryRun
+            ? requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/retry-failed`, { method: "GET" })
+            : requestOxygen(`/api/cli/table-action-runs/${encodeURIComponent(runId)}/retry-failed`, {
+                method: "POST", body: {
+                    ...(options.approvedEffectUnknown ? { approved_effect_unknown: true } : {}),
+                    ...(options.approved !== undefined ? { approved: options.approved } : {}),
+                    ...(options.retryPlanHash !== undefined ? { retry_plan_hash: options.retryPlanHash } : {}),
+                    ...(maxAdditionalCredits !== undefined ? { max_additional_credits: maxAdditionalCredits } : {}),
+                },
+            }));
+    }));
+}

package/dist/commands/tables.d.ts

@@ -0,0 +1,3 @@
+import { ExtractedCommandActionHandler } from "../command-support.js";
+import { Command } from "commander";
+export declare function registerTablesFamily(program: Command, handleAsyncAction: ExtractedCommandActionHandler, binaryName: any): void;