@outputai/cli 0.8.2-next.4b5c049.0 → 0.8.2-next.57bc8d6.0

package/dist/api/generated/api.d.ts

@@ -452,6 +452,26 @@ export type GetWorkflowIdRunsRidHistory200 = {
     /** @nullable */
     nextPageToken?: string | null;
 };
+export type GetWorkflowIdHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
+export type GetWorkflowIdRunsRidHistoryStreamParams = {
+    /**
+     * Include decoded input/output payloads in events
+     */
+    includePayloads?: boolean;
+    /**
+     * Resume from this event ID (alternative to Last-Event-ID header)
+     */
+    lastEventId?: number;
+};
 export type GetWorkflowCatalogId200 = {
     /** Each workflow available in this catalog */
     workflows?: Workflow[];
@@ -1043,6 +1063,65 @@ export type getWorkflowIdRunsRidHistoryResponseError = (getWorkflowIdRunsRidHist
 export type getWorkflowIdRunsRidHistoryResponse = (getWorkflowIdRunsRidHistoryResponseSuccess | getWorkflowIdRunsRidHistoryResponseError);
 export declare const getGetWorkflowIdRunsRidHistoryUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams) => string;
 export declare const getWorkflowIdRunsRidHistory: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryResponse>;
+/**
+ * Opens a persistent SSE connection that delivers Temporal workflow history events in real time. Emits named events: `workflow` (metadata, once), `history` (event batches), `done` (terminal state), `server_error` (post-flush errors). The `done` event carries `{ reason, newRunId? }` where `reason` is the terminal Temporal event type (`WORKFLOW_EXECUTION_COMPLETED`, `WORKFLOW_EXECUTION_FAILED`, `WORKFLOW_EXECUTION_TIMED_OUT`, `WORKFLOW_EXECUTION_CANCELED`, `WORKFLOW_EXECUTION_TERMINATED`, `WORKFLOW_EXECUTION_CONTINUED_AS_NEW`) and `newRunId` is present only when the terminal event chains a follow-on run. `server_error` carries `{ error, message, workflowId, runId }`. Errors before the stream opens are returned as JSON HTTP responses (400/404); once open, failures arrive as a `server_error` event. Supports reconnect via `Last-Event-ID` header or `lastEventId` query param.
+
+ * @summary Stream workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdHistoryStreamResponseSuccess = (getWorkflowIdHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponseError = (getWorkflowIdHistoryStreamResponse400 | getWorkflowIdHistoryStreamResponse404 | getWorkflowIdHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdHistoryStreamResponse = (getWorkflowIdHistoryStreamResponseSuccess | getWorkflowIdHistoryStreamResponseError);
+export declare const getGetWorkflowIdHistoryStreamUrl: (id: string, params?: GetWorkflowIdHistoryStreamParams) => string;
+export declare const getWorkflowIdHistoryStream: (id: string, params?: GetWorkflowIdHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdHistoryStreamResponse>;
+/**
+ * Same as /workflow/{id}/history/stream but targets a specific run ID.
+ * @summary Stream pinned-run workflow history events via Server-Sent Events
+ */
+export type getWorkflowIdRunsRidHistoryStreamResponse200 = {
+    data: string;
+    status: 200;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse400 = {
+    data: BadRequestResponse;
+    status: 400;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse404 = {
+    data: NotFoundResponse;
+    status: 404;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse500 = {
+    data: InternalServerErrorResponse;
+    status: 500;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseSuccess = (getWorkflowIdRunsRidHistoryStreamResponse200) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponseError = (getWorkflowIdRunsRidHistoryStreamResponse400 | getWorkflowIdRunsRidHistoryStreamResponse404 | getWorkflowIdRunsRidHistoryStreamResponse500) & {
+    headers: Headers;
+};
+export type getWorkflowIdRunsRidHistoryStreamResponse = (getWorkflowIdRunsRidHistoryStreamResponseSuccess | getWorkflowIdRunsRidHistoryStreamResponseError);
+export declare const getGetWorkflowIdRunsRidHistoryStreamUrl: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams) => string;
+export declare const getWorkflowIdRunsRidHistoryStream: (id: string, rid: string, params?: GetWorkflowIdRunsRidHistoryStreamParams, options?: ApiRequestOptions) => Promise<getWorkflowIdRunsRidHistoryStreamResponse>;
 /**
  * @summary Get a specific workflow catalog by ID
  */

package/dist/api/generated/api.js

@@ -231,6 +231,38 @@ export const getWorkflowIdRunsRidHistory = async (id, rid, params, options) => {
         method: 'GET'
     });
 };
+export const getGetWorkflowIdHistoryStreamUrl = (id, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/history/stream?${stringifiedParams}` : `/workflow/${id}/history/stream`;
+};
+export const getWorkflowIdHistoryStream = async (id, params, options) => {
+    return customFetchInstance(getGetWorkflowIdHistoryStreamUrl(id, params), {
+        ...options,
+        method: 'GET'
+    });
+};
+export const getGetWorkflowIdRunsRidHistoryStreamUrl = (id, rid, params) => {
+    const normalizedParams = new URLSearchParams();
+    Object.entries(params || {}).forEach(([key, value]) => {
+        if (value !== undefined) {
+            normalizedParams.append(key, value === null ? 'null' : value.toString());
+        }
+    });
+    const stringifiedParams = normalizedParams.toString();
+    return stringifiedParams.length > 0 ? `/workflow/${id}/runs/${rid}/history/stream?${stringifiedParams}` : `/workflow/${id}/runs/${rid}/history/stream`;
+};
+export const getWorkflowIdRunsRidHistoryStream = async (id, rid, params, options) => {
+    return customFetchInstance(getGetWorkflowIdRunsRidHistoryStreamUrl(id, rid, params), {
+        ...options,
+        method: 'GET'
+    });
+};
 export const getGetWorkflowCatalogIdUrl = (id) => {
     return `/workflow/catalog/${id}`;
 };

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.4b5c049.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.8.2-next.57bc8d6.0}
     init: true
     networks:
       - main

package/dist/commands/workflow/dataset/generate.d.ts

@@ -7,6 +7,7 @@ export default class DatasetGenerate extends Command {
         scenario: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         trace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         download: import("@oclif/core/interfaces").BooleanFlag<boolean>;

package/dist/commands/workflow/dataset/generate.js

@@ -26,6 +26,14 @@ export default class DatasetGenerate extends Command {
         })
     };
     static flags = {
+        catalog: Flags.string({
+            char: 'c',
+            aliases: ['task-queue'],
+            charAliases: ['q'],
+            deprecateAliases: true,
+            description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         trace: Flags.string({
             char: 't',
             description: 'Path to a local trace file to extract dataset from',
@@ -61,15 +69,16 @@ export default class DatasetGenerate extends Command {
             await this.generateFromTrace(args.workflowName, flags.trace, flags.name);
             return;
         }
-        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name);
+        await this.generateFromScenario(args.workflowName, args.scenario, flags.input, flags.name, flags.catalog);
     }
-    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride) {
-        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag);
+    async generateFromScenario(workflowName, scenario, inputFlag, nameOverride, catalog) {
+        const resolvedInput = await this.resolveScenarioInput(workflowName, scenario, inputFlag, catalog);
         const datasetName = nameOverride ?? scenario ?? 'dataset';
         this.log(`Running workflow "${workflowName}"...`);
         const response = await postWorkflowRun({
             workflowName,
-            input: resolvedInput
+            input: resolvedInput,
+            catalog
         }, {
             config: { timeout: 600000 }
         });
@@ -116,7 +125,7 @@ export default class DatasetGenerate extends Command {
         }
         this.log(`\nGenerated ${traces.length} dataset(s)`);
     }
-    async resolveScenarioInput(workflowName, scenario, inputFlag) {
+    async resolveScenarioInput(workflowName, scenario, inputFlag, catalog) {
         if (inputFlag && scenario) {
             return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
         }
@@ -124,7 +133,7 @@ export default class DatasetGenerate extends Command {
             return parseInputFlag(inputFlag);
         }
         if (scenario) {
-            const resolution = await resolveScenarioPath(workflowName, scenario);
+            const resolution = await resolveScenarioPath(workflowName, scenario, undefined, undefined, catalog);
             if (!resolution.found) {
                 return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
             }

package/dist/commands/workflow/dataset/generate.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/workflow/dataset/generate.spec.js

@@ -0,0 +1,69 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('#api/generated/api.js', () => ({
+    postWorkflowRun: vi.fn()
+}));
+vi.mock('#utils/scenario_resolver.js', () => ({
+    resolveScenarioPath: vi.fn(),
+    getScenarioNotFoundMessage: vi.fn().mockReturnValue('not found')
+}));
+vi.mock('#utils/input_parser.js', () => ({
+    parseInputFlag: vi.fn()
+}));
+vi.mock('#services/datasets.js', () => ({
+    writeDataset: vi.fn(),
+    resolveDefaultDatasetsDir: vi.fn().mockResolvedValue('/datasets'),
+    buildDataset: vi.fn().mockReturnValue({ name: 'basic' }),
+    getExecutionTime: vi.fn().mockResolvedValue(100),
+    extractDatasetName: vi.fn()
+}));
+describe('workflow dataset generate command', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        delete process.env.OUTPUT_CATALOG_ID;
+    });
+    describe('command definition', () => {
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const DatasetGenerate = (await import('./generate.js')).default;
+            expect(DatasetGenerate.flags).toHaveProperty('catalog');
+            expect(DatasetGenerate.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(DatasetGenerate.flags.catalog.char).toBe('c');
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (flagOverrides = {}) => {
+            const DatasetGenerate = (await import('./generate.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const { resolveScenarioPath } = await import('#utils/scenario_resolver.js');
+            const { parseInputFlag } = await import('#utils/input_parser.js');
+            const cmd = new DatasetGenerate(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn(() => {
+                throw new Error('error called');
+            });
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: 'basic' },
+                flags: { catalog: undefined, trace: undefined, name: undefined, download: false, limit: 5, input: undefined, ...flagOverrides }
+            });
+            return {
+                cmd,
+                postWorkflowRun: vi.mocked(postWorkflowRun),
+                resolveScenarioPath: vi.mocked(resolveScenarioPath),
+                parseInputFlag: vi.mocked(parseInputFlag)
+            };
+        };
+        it('resolves the scenario and runs the workflow against the resolved catalog', async () => {
+            const { cmd, postWorkflowRun, resolveScenarioPath, parseInputFlag } = await createCommand({ catalog: 'my-catalog' });
+            resolveScenarioPath.mockResolvedValue({ found: true, path: '/scenarios/basic.json', searchedPaths: [] });
+            parseInputFlag.mockResolvedValue({ foo: 'bar' });
+            postWorkflowRun.mockResolvedValue({
+                data: { workflowId: 'wf-1', output: { ok: true } },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveScenarioPath).toHaveBeenCalledWith('my_workflow', 'basic', undefined, undefined, 'my-catalog');
+            expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }), expect.anything());
+        });
+    });
+});

package/dist/commands/workflow/run.js

@@ -63,7 +63,7 @@ export default class WorkflowRun extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowRun);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run');
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run', flags.catalog);
         this.log(`Executing workflow: ${args.workflowName}...`);
         const response = await executeWorkflow({
             body: {

package/dist/commands/workflow/run.spec.js

@@ -64,11 +64,28 @@ describe('workflow run command', () => {
                 headers: new Headers()
             });
             await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'run', undefined);
             expect(postWorkflowRun).toHaveBeenCalledTimes(1);
             expect(postWorkflowRun).toHaveBeenCalledWith({ workflowName: 'my_workflow', input: { key: 'value' }, catalog: undefined }, expect.objectContaining({ config: { timeout: 600000 } }));
             expect(cmd.log).toHaveBeenCalledWith('Executing workflow: my_workflow...');
             expect(cmd.log).toHaveBeenCalledWith(expect.stringMatching(/\n/));
         });
+        it('threads the resolved catalog to resolveInput and postWorkflowRun', async () => {
+            const { cmd, postWorkflowRun, resolveInput } = await createCommand();
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: 'basic' },
+                flags: { input: undefined, catalog: 'my-catalog', format: 'text' }
+            });
+            resolveInput.mockResolvedValue({ key: 'value' });
+            postWorkflowRun.mockResolvedValue({
+                data: { status: 'completed', result: {} },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', 'basic', undefined, 'run', 'my-catalog');
+            expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ catalog: 'my-catalog' }), expect.anything());
+        });
         it('retries when response has Retry-After and succeeds on second attempt', async () => {
             const { cmd, postWorkflowRun, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({});

package/dist/commands/workflow/start.js

@@ -37,7 +37,7 @@ export default class WorkflowStart extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowStart);
-        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start');
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start', flags.catalog);
         this.log(`Starting workflow: ${args.workflowName}...`);
         const response = await postWorkflowStart({
             workflowName: args.workflowName,

package/dist/commands/workflow/start.spec.js

@@ -1,11 +1,17 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../api/generated/api.js', () => ({
+vi.mock('#api/generated/api.js', () => ({
     postWorkflowStart: vi.fn()
 }));
+vi.mock('#utils/resolve_input.js', () => ({
+    resolveInput: vi.fn()
+}));
 describe('workflow start command', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
         vi.clearAllMocks();
         delete process.env.OUTPUT_CATALOG_ID;
+        const { resolveInput } = await import('#utils/resolve_input.js');
+        vi.mocked(resolveInput).mockResolvedValue({});
     });
     describe('command definition', () => {
         it('should export a valid OCLIF command', async () => {
@@ -25,5 +31,50 @@ describe('workflow start command', () => {
             expect(WorkflowStart.args).toHaveProperty('scenario');
             expect(WorkflowStart.args.scenario.required).toBe(false);
         });
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(WorkflowStart.flags.catalog.char).toBe('c');
+        });
+    });
+    describe('run()', () => {
+        const createCommand = async (flagOverrides = {}) => {
+            const WorkflowStart = (await import('./start.js')).default;
+            const { postWorkflowStart } = await import('#api/generated/api.js');
+            const { resolveInput } = await import('#utils/resolve_input.js');
+            const cmd = new WorkflowStart(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.error = vi.fn(() => {
+                throw new Error('error called');
+            });
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: undefined },
+                flags: { input: undefined, catalog: undefined, ...flagOverrides }
+            });
+            return { cmd, postWorkflowStart: vi.mocked(postWorkflowStart), resolveInput: vi.mocked(resolveInput) };
+        };
+        it('threads the resolved catalog to resolveInput and postWorkflowStart', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand({ catalog: 'my-catalog' });
+            resolveInput.mockResolvedValue({ key: 'value' });
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', 'my-catalog');
+            expect(postWorkflowStart).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }));
+        });
+        it('passes undefined catalog through when none is set', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(resolveInput).toHaveBeenCalledWith('my_workflow', undefined, undefined, 'start', undefined);
+        });
     });
 });

package/dist/commands/workflow/test_eval.d.ts

@@ -9,6 +9,7 @@ export default class WorkflowTest extends Command {
         workflowName: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         cached: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         save: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         dataset: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/workflow/test_eval.js

@@ -24,6 +24,14 @@ export default class WorkflowTest extends Command {
         })
     };
     static flags = {
+        catalog: Flags.string({
+            char: 'c',
+            aliases: ['task-queue'],
+            charAliases: ['q'],
+            deprecateAliases: true,
+            description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         cached: Flags.boolean({
             description: 'Use cached output from dataset files (skip workflow execution)',
             default: false,
@@ -43,7 +51,7 @@ export default class WorkflowTest extends Command {
         const { args, flags } = await this.parse(WorkflowTest);
         const filterNames = flags.dataset?.split(',').map(s => s.trim());
         const evalName = getEvalWorkflowName(args.workflowName);
-        await this.ensureEvalWorkflowRegistered(args.workflowName, evalName);
+        await this.ensureEvalWorkflowRegistered(args.workflowName, evalName, flags.catalog);
         const { datasets, dir } = await readAllDatasets(args.workflowName, filterNames);
         if (datasets.length === 0) {
             this.error(`No datasets found for workflow "${args.workflowName}".\n` +
@@ -51,11 +59,12 @@ export default class WorkflowTest extends Command {
         }
         const preparedDatasets = flags.cached ?
             this.validateDatasets(datasets) :
-            await this.runWorkflowForDatasets(args.workflowName, datasets, flags.save, dir);
+            await this.runWorkflowForDatasets(args.workflowName, datasets, flags.save, dir, flags.catalog);
         this.log(`Running eval workflow "${evalName}"...\n`);
         const response = await postWorkflowRun({
             workflowName: evalName,
-            input: { datasets: preparedDatasets }
+            input: { datasets: preparedDatasets },
+            catalog: flags.catalog
         }, {
             config: { timeout: 600000 }
         });
@@ -73,9 +82,9 @@ export default class WorkflowTest extends Command {
         process.exitCode = computeExitCode(evalOutput);
         return evalOutput;
     }
-    async ensureEvalWorkflowRegistered(workflowName, evalName) {
-        const catalog = await fetchWorkflowCatalog().catch(() => null);
-        if (catalog && !catalog.some(w => w.name === evalName)) {
+    async ensureEvalWorkflowRegistered(workflowName, evalName, catalog) {
+        const workflows = await fetchWorkflowCatalog(catalog).catch(() => null);
+        if (workflows && !workflows.some(w => w.name === evalName)) {
             this.error(await diagnoseMissingEvalWorkflow(workflowName), { exit: 1 });
         }
     }
@@ -88,7 +97,7 @@ export default class WorkflowTest extends Command {
         }
         return datasets;
     }
-    async runWorkflowForDatasets(workflowName, datasets, save, dir) {
+    async runWorkflowForDatasets(workflowName, datasets, save, dir, catalog) {
         this.log(`Running workflow "${workflowName}" for ${datasets.length} dataset(s)...\n`);
         const results = [];
         for (const dataset of datasets) {
@@ -96,7 +105,8 @@ export default class WorkflowTest extends Command {
             const startMs = Date.now();
             const response = await postWorkflowRun({
                 workflowName,
-                input: dataset.input
+                input: dataset.input,
+                catalog
             }, {
                 config: { timeout: 600000 }
             });

package/dist/commands/workflow/test_eval.spec.js

@@ -4,10 +4,16 @@ import { getEvalWorkflowName, renderEvalOutput } from '@outputai/evals';
 vi.mock('#api/generated/api.js', () => ({
     postWorkflowRun: vi.fn()
 }));
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
 vi.mock('#services/datasets.js', () => ({
     readAllDatasets: vi.fn(),
     writeDataset: vi.fn()
 }));
+vi.mock('#utils/eval_diagnostics.js', () => ({
+    diagnoseMissingEvalWorkflow: vi.fn().mockResolvedValue('missing eval workflow')
+}));
 const passingOutput = {
     cases: [{ datasetName: 'd1', verdict: 'pass', evaluators: [] }],
     summary: { total: 1, passed: 1, partial: 0, failed: 0, acceptableRate: 1 }
@@ -23,10 +29,16 @@ describe('workflow test command', () => {
         exitState.original = process.exitCode;
         process.exitCode = undefined;
         const { readAllDatasets } = await import('#services/datasets.js');
+        const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
         vi.mocked(readAllDatasets).mockResolvedValue({
             datasets: [{ name: 'd1', input: {}, last_output: { output: {}, date: '2026-01-01' } }],
             dir: '/tmp/datasets'
         });
+        // Catalog includes both eval names so ensureEvalWorkflowRegistered passes deterministically.
+        vi.mocked(fetchWorkflowCatalog).mockResolvedValue([
+            { name: getEvalWorkflowName('simple') },
+            { name: getEvalWorkflowName('my_workflow') }
+        ]);
     });
     afterEach(() => {
         process.exitCode = exitState.original;
@@ -36,6 +48,12 @@ describe('workflow test command', () => {
             const WorkflowTest = (await import('./test_eval.js')).default;
             expect(WorkflowTest.enableJsonFlag).toBe(true);
         });
+        it('binds the catalog flag to OUTPUT_CATALOG_ID', async () => {
+            const WorkflowTest = (await import('./test_eval.js')).default;
+            expect(WorkflowTest.flags).toHaveProperty('catalog');
+            expect(WorkflowTest.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(WorkflowTest.flags.catalog.char).toBe('c');
+        });
     });
     describe('run()', () => {
         const createCommand = async (jsonEnabled) => {
@@ -80,5 +98,24 @@ describe('workflow test command', () => {
             expect(result).toEqual(failingOutput);
             expect(process.exitCode).toBe(1);
         });
+        it('routes registration, dataset runs, and the eval run to the resolved catalog', async () => {
+            const WorkflowTest = (await import('./test_eval.js')).default;
+            const { postWorkflowRun } = await import('#api/generated/api.js');
+            const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+            const cmd = new WorkflowTest(['my_workflow'], {});
+            cmd.log = vi.fn();
+            cmd.jsonEnabled = vi.fn().mockReturnValue(false);
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow' },
+                flags: { catalog: 'my-catalog', cached: false, save: false, dataset: undefined }
+            });
+            vi.mocked(postWorkflowRun)
+                .mockResolvedValueOnce({ data: { output: {} }, status: 200, headers: new Headers() })
+                .mockResolvedValueOnce({ data: { output: passingOutput }, status: 200, headers: new Headers() });
+            await cmd.run();
+            expect(vi.mocked(fetchWorkflowCatalog)).toHaveBeenCalledWith('my-catalog');
+            expect(postWorkflowRun).toHaveBeenNthCalledWith(1, expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }), expect.anything());
+            expect(postWorkflowRun).toHaveBeenNthCalledWith(2, expect.objectContaining({ workflowName: getEvalWorkflowName('my_workflow'), catalog: 'my-catalog' }), expect.anything());
+        });
     });
 });

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.8.2-next.4b5c049.0"
+    "framework": "0.8.2-next.57bc8d6.0"
 }

package/dist/utils/resolve_input.d.ts

@@ -1 +1 @@
-export declare function resolveInput(workflowName: string, scenario: string | undefined, inputFlag: string | undefined, commandName: string): Promise<unknown>;
+export declare function resolveInput(workflowName: string, scenario: string | undefined, inputFlag: string | undefined, commandName: string, catalog?: string): Promise<unknown>;

package/dist/utils/resolve_input.js

@@ -1,7 +1,7 @@
 import { ux } from '@oclif/core';
 import { parseInputFlag } from '#utils/input_parser.js';
 import { resolveScenarioPath, getScenarioNotFoundMessage } from '#utils/scenario_resolver.js';
-export async function resolveInput(workflowName, scenario, inputFlag, commandName) {
+export async function resolveInput(workflowName, scenario, inputFlag, commandName, catalog) {
     if (inputFlag && scenario) {
         return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
     }
@@ -9,7 +9,7 @@ export async function resolveInput(workflowName, scenario, inputFlag, commandNam
         return parseInputFlag(inputFlag);
     }
     if (scenario) {
-        const resolution = await resolveScenarioPath(workflowName, scenario);
+        const resolution = await resolveScenarioPath(workflowName, scenario, undefined, undefined, catalog);
         if (!resolution.found) {
             return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
         }

package/dist/utils/scenario_resolver.d.ts

@@ -4,6 +4,6 @@ export interface ScenarioResolutionResult {
     path?: string;
     searchedPaths: string[];
 }
-export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: string, workflowPath?: string): Promise<ScenarioResolutionResult>;
+export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: string, workflowPath?: string, catalog?: string): Promise<ScenarioResolutionResult>;
 export declare function listScenariosForWorkflow(workflowName: string, workflowPath?: string, basePath?: string): string[];
 export declare function getScenarioNotFoundMessage(workflowName: string, scenarioName: string, searchedPaths: string[]): string;

package/dist/utils/scenario_resolver.js

@@ -26,7 +26,7 @@ function resolveScenarioFromScenarioDirs(scenariosDirs, scenarioFileName) {
         { found: true, path, searchedPaths } :
         { found: false, searchedPaths };
 }
-export async function resolveScenarioPath(workflowName, scenarioName, basePath = getWorkflowsBasePath(), workflowPath) {
+export async function resolveScenarioPath(workflowName, scenarioName, basePath = getWorkflowsBasePath(), workflowPath, catalog) {
     const scenarioFileName = scenarioName.endsWith('.json') ?
         scenarioName :
         `${scenarioName}.json`;
@@ -36,7 +36,7 @@ export async function resolveScenarioPath(workflowName, scenarioName, basePath =
             return pathResult;
         }
     }
-    const catalogPath = workflowPath ? null : await fetchWorkflowPath(workflowName);
+    const catalogPath = workflowPath ? null : await fetchWorkflowPath(workflowName, catalog);
     if (catalogPath) {
         const result = resolveScenarioFromScenarioDirs(candidateScenarioDirsFromPath(catalogPath, basePath), scenarioFileName);
         if (result.found) {

package/dist/utils/scenario_resolver.spec.js

@@ -156,6 +156,20 @@ describe('resolveScenarioPath', () => {
             expect(result.path).toContain('complex/deep_test.json');
         });
     });
+    describe('catalog routing', () => {
+        it('forwards the provided catalog to the catalog lookup', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await resolveScenarioPath('my_workflow', 'test', '/project', undefined, 'os-workflows');
+            expect(catalog.fetchWorkflowCatalog).toHaveBeenCalledWith('os-workflows');
+        });
+        it('looks up the default catalog when no catalog is provided', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await resolveScenarioPath('my_workflow', 'test', '/project');
+            expect(catalog.fetchWorkflowCatalog).toHaveBeenCalledWith(undefined);
+        });
+    });
 });
 describe('listScenariosForWorkflow', () => {
     beforeEach(() => {

package/dist/utils/workflow_dir.d.ts

@@ -2,7 +2,7 @@ export declare const WORKFLOWS_PATHS: string[];
 export declare function extractWorkflowRelativePath(path: string): string | null;
 export declare function candidateWorkflowDirsFromPath(workflowPath: string, basePath: string): string[];
 export declare function findWorkflowDirectoryFromPath(workflowPath: string | undefined, basePath?: string): string | null;
-export declare function fetchWorkflowPath(workflowName: string): Promise<string | null>;
+export declare function fetchWorkflowPath(workflowName: string, catalog?: string): Promise<string | null>;
 /**
  * Resolve the on-disk directory of a registered workflow by name.
  *

package/dist/utils/workflow_dir.js

@@ -23,9 +23,9 @@ export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkfl
     }
     return candidateWorkflowDirsFromPath(workflowPath, basePath).find(existsSync) ?? null;
 }
-export async function fetchWorkflowPath(workflowName) {
+export async function fetchWorkflowPath(workflowName, catalog) {
     try {
-        const workflows = await fetchWorkflowCatalog();
+        const workflows = await fetchWorkflowCatalog(catalog);
         const workflow = workflows.find(w => w.name === workflowName);
         return workflow?.path ?? null;
     }

package/oclif.manifest.json

@@ -1164,6 +1164,22 @@
           "allowNo": false,
           "type": "boolean"
         },
+        "catalog": {
+          "aliases": [
+            "task-queue"
+          ],
+          "char": "c",
+          "charAliases": [
+            "q"
+          ],
+          "deprecateAliases": true,
+          "description": "Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)",
+          "env": "OUTPUT_CATALOG_ID",
+          "name": "catalog",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "cached": {
           "description": "Use cached output from dataset files (skip workflow execution)",
           "exclusive": [
@@ -1228,6 +1244,22 @@
         "<%= config.bin %> <%= command.id %> simple --download --limit 5"
       ],
       "flags": {
+        "catalog": {
+          "aliases": [
+            "task-queue"
+          ],
+          "char": "c",
+          "charAliases": [
+            "q"
+          ],
+          "deprecateAliases": true,
+          "description": "Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)",
+          "env": "OUTPUT_CATALOG_ID",
+          "name": "catalog",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "trace": {
           "char": "t",
           "description": "Path to a local trace file to extract dataset from",
@@ -1422,5 +1454,5 @@
       ]
     }
   },
-  "version": "0.8.2-next.4b5c049.0"
+  "version": "0.8.2-next.57bc8d6.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.8.2-next.4b5c049.0",
+  "version": "0.8.2-next.57bc8d6.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -36,9 +36,9 @@
     "semver": "7.7.4",
     "undici": "8.5.0",
     "yaml": "^2.8.3",
-    "@outputai/credentials": "0.8.2-next.4b5c049.0",
-    "@outputai/llm": "0.8.2-next.4b5c049.0",
-    "@outputai/evals": "0.8.2-next.4b5c049.0"
+    "@outputai/evals": "0.8.2-next.57bc8d6.0",
+    "@outputai/credentials": "0.8.2-next.57bc8d6.0",
+    "@outputai/llm": "0.8.2-next.57bc8d6.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",