@output.ai/cli 0.7.13 → 0.7.15

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

@@ -1,8 +1,8 @@
 /**
  * Generated by orval v7.20.0 🍺
  * Do not edit manually.
- * Output.ai SDK API
- * API for managing and executing Temporal workflows through Output SDK
+ * Output.ai API
+ * API for managing and executing Output.ai workflows
  * OpenAPI spec version: 1.0.0
  */
 import { type ApiRequestOptions } from '../http_client.js';
@@ -29,6 +29,8 @@ export interface Workflow {
     name: string;
     /** The description of the workflow */
     description?: string;
+    /** Absolute path to the workflow file */
+    path?: string;
     inputSchema?: JSONSchema;
     outputSchema?: JSONSchema;
 }

package/dist/api/generated/api.js

@@ -1,8 +1,8 @@
 /**
  * Generated by orval v7.20.0 🍺
  * Do not edit manually.
- * Output.ai SDK API
- * API for managing and executing Temporal workflows through Output SDK
+ * Output.ai API
+ * API for managing and executing Output.ai workflows
  * OpenAPI spec version: 1.0.0
  */
 import { customFetchInstance } from '../http_client.js';

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

@@ -112,10 +112,16 @@ services:
       - TRACE_LOCAL_ON=${TRACE_LOCAL_ON:-true}
       - TRACE_REMOTE_ON=${TRACE_REMOTE_ON:-}
       - TRACE_REMOTE_S3_BUCKET=${TRACE_REMOTE_S3_BUCKET:-}
-      - HOST_TRACE_PATH=${PWD}/logs
+      - TRACE_HOST_PATH=${PWD}/logs
       - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID:-}
       - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY:-}
       - AWS_REGION=${AWS_REGION:-us-west-1}
+      - MAX_CONCURRENT_ACTIVITY_TASKS=${MAX_CONCURRENT_ACTIVITY_TASKS:-40}
+      - MAX_CONCURRENT_WORKFLOW_TASKS=${MAX_CONCURRENT_WORKFLOW_TASKS:-200}
+      - MAX_CACHED_WORKFLOWS=${MAX_CACHED_WORKFLOWS:-1000}
+      - MAX_CONCURRENT_ACTIVITY_POLLS=${MAX_CONCURRENT_ACTIVITY_POLLS:-5}
+      - MAX_CONCURRENT_WORKFLOW_POLLS=${MAX_CONCURRENT_WORKFLOW_POLLS:-5}
+      - NODE_OPTIONS=${NODE_OPTIONS:---max-old-space-size=4096}
     command: >
       sh -c "
         npm run output:worker:install &&

package/dist/commands/init.js

@@ -2,7 +2,7 @@ import { Args, Command, Flags } from '@oclif/core';
 import { UserCancelledError } from '#types/errors.js';
 import { runInit } from '#services/project_scaffold.js';
 export default class Init extends Command {
-    static description = 'Initialize a new Output SDK workflow project by scaffolding the complete project structure';
+    static description = 'Initialize a new Output project by scaffolding the complete project structure';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '<%= config.bin %> <%= command.id %> my-workflow-project'

package/dist/commands/workflow/generate.js

@@ -6,7 +6,7 @@ import { getWorkflowGenerateSuccessMessage } from '#services/messages.js';
 import { DEFAULT_OUTPUT_DIRS } from '#utils/paths.js';
 import path from 'node:path';
 export default class Generate extends Command {
-    static description = 'Generate a new Output SDK workflow';
+    static description = 'Generate a new Output workflow';
     static examples = [
         '<%= config.bin %> <%= command.id %> my-workflow',
         '<%= config.bin %> <%= command.id %> my-workflow --skeleton',

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

@@ -5,6 +5,7 @@ interface WorkflowDisplay {
     description: string;
     inputs: string;
     outputs: string;
+    scenarios: string;
 }
 export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
 export default class WorkflowList extends Command {

package/dist/commands/workflow/list.js

@@ -3,6 +3,7 @@ import Table from 'cli-table3';
 import { getWorkflowCatalog } from '#api/generated/api.js';
 import { parseWorkflowDefinition, formatParameters } from '#api/parser.js';
 import { handleApiError } from '#utils/error_handler.js';
+import { listScenariosForWorkflow } from '#utils/scenario_resolver.js';
 const OUTPUT_FORMAT = {
     LIST: 'list',
     TABLE: 'table',
@@ -10,11 +11,13 @@ const OUTPUT_FORMAT = {
 };
 export function parseWorkflowForDisplay(workflow) {
     const parsed = parseWorkflowDefinition(workflow);
+    const scenarioNames = listScenariosForWorkflow(workflow.name, workflow.path);
     return {
         name: parsed.name,
         description: parsed.description || 'No description',
         inputs: formatParameters(parsed.inputs),
-        outputs: formatParameters(parsed.outputs)
+        outputs: formatParameters(parsed.outputs),
+        scenarios: scenarioNames.length > 0 ? scenarioNames.join(', ') : 'none'
     };
 }
 function caseInsensitiveIncludes(str, filter) {
@@ -35,8 +38,8 @@ function sortWorkflowsByName(workflows) {
 }
 function createWorkflowTable(workflows, detailed) {
     const table = new Table({
-        head: ['Name', 'Description', 'Inputs', 'Outputs'],
-        colWidths: detailed ? [25, 40, 40, 40] : [20, 30, 25, 25],
+        head: ['Name', 'Description', 'Inputs', 'Outputs', 'Scenarios'],
+        colWidths: detailed ? [30, 42, 42, 42, 60] : [24, 30, 24, 24, 48],
         wordWrap: true,
         style: {
             head: ['cyan']
@@ -48,17 +51,11 @@ function createWorkflowTable(workflows, detailed) {
         if (detailed) {
             const inputs = display.inputs.split(', ').join('\n');
             const outputs = display.outputs.split(', ').join('\n');
-            table.push([display.name, display.description, inputs, outputs]);
+            const scenarios = display.scenarios.split(', ').join('\n');
+            table.push([display.name, display.description, inputs, outputs, scenarios]);
         }
         else {
-            const maxLen = 22;
-            const inputs = display.inputs.length > maxLen ?
-                display.inputs.substring(0, maxLen) + '...' :
-                display.inputs;
-            const outputs = display.outputs.length > maxLen ?
-                display.outputs.substring(0, maxLen) + '...' :
-                display.outputs;
-            table.push([display.name, display.description, inputs, outputs]);
+            table.push([display.name, display.description, display.inputs, display.outputs, display.scenarios]);
         }
     });
     return table.toString();
@@ -77,6 +74,7 @@ function formatWorkflowsAsJson(workflows) {
                 description: display.description,
                 inputs: display.inputs.split(', '),
                 outputs: display.outputs.split(', '),
+                scenarios: display.scenarios === 'none' ? [] : display.scenarios.split(', '),
                 raw: w
             };
         })

package/dist/commands/workflow/{list.test.js → list.spec.js}

@@ -1,4 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+const mockListScenarios = vi.fn().mockReturnValue([]);
+vi.mock('#utils/scenario_resolver.js', () => ({
+    listScenariosForWorkflow: mockListScenarios
+}));
 describe('workflow list command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -47,6 +51,7 @@ describe('workflow list parsing', () => {
         expect(parsed.inputs).toContain('message: string');
         expect(parsed.inputs).toContain('count: number?');
         expect(parsed.outputs).toContain('result: string?');
+        expect(parsed.scenarios).toBe('none');
     });
     it('should handle workflows without schemas', async () => {
         const { parseWorkflowForDisplay } = await import('./list.js');
@@ -58,6 +63,17 @@ describe('workflow list parsing', () => {
         expect(parsed.name).toBe('simple-workflow');
         expect(parsed.inputs).toBe('none');
         expect(parsed.outputs).toBe('none');
+        expect(parsed.scenarios).toBe('none');
+    });
+    it('should include scenario names when scenarios exist', async () => {
+        mockListScenarios.mockReturnValueOnce(['basic', 'advanced', 'stress_test']);
+        const { parseWorkflowForDisplay } = await import('./list.js');
+        const mockWorkflow = {
+            name: 'workflow-with-scenarios',
+            description: 'Has scenarios'
+        };
+        const parsed = parseWorkflowForDisplay(mockWorkflow);
+        expect(parsed.scenarios).toBe('basic, advanced, stress_test');
     });
     it('should format nested parameters correctly', async () => {
         const { parseWorkflowForDisplay } = await import('./list.js');

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

@@ -4,9 +4,10 @@ export default class WorkflowRun extends Command {
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        scenario: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
-        input: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'task-queue': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         format: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
     };

package/dist/commands/workflow/run.js

@@ -1,28 +1,33 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowRun } from '#api/generated/api.js';
 import { OUTPUT_FORMAT } from '#utils/constants.js';
-import { parseInputFlag } from '#utils/input_parser.js';
 import { formatOutput } from '#utils/output_formatter.js';
 import { handleApiError } from '#utils/error_handler.js';
+import { resolveInput } from '#utils/resolve_input.js';
 export default class WorkflowRun extends Command {
     static description = 'Execute a workflow synchronously and wait for completion';
     static examples = [
+        '<%= config.bin %> <%= command.id %> simple basic_input',
+        '<%= config.bin %> <%= command.id %> simple my_scenario --format json',
         '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
         '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --format json',
         '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --task-queue my-queue'
     ];
     static args = {
         workflowName: Args.string({
             description: 'Name of the workflow to execute',
             required: true
+        }),
+        scenario: Args.string({
+            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
+            required: false
         })
     };
     static flags = {
         input: Flags.string({
             char: 'i',
-            description: 'Workflow input as JSON string or file path',
-            required: true
+            description: 'Workflow input as JSON string or file path (overrides scenario)',
+            required: false
         }),
         'task-queue': Flags.string({
             char: 'q',
@@ -37,7 +42,7 @@ export default class WorkflowRun extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowRun);
-        const input = parseInputFlag(flags.input);
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'run');
         this.log(`Executing workflow: ${args.workflowName}...`);
         const response = await postWorkflowRun({
             workflowName: args.workflowName,

package/dist/commands/workflow/{run.test.js → run.spec.js}

@@ -20,7 +20,12 @@ describe('workflow run command', () => {
             const WorkflowRun = (await import('./run.js')).default;
             expect(WorkflowRun.flags.format.options).toEqual(['json', 'text']);
             expect(WorkflowRun.flags.format.default).toBe('text');
-            expect(WorkflowRun.flags.input.required).toBe(true);
+            expect(WorkflowRun.flags.input.required).toBe(false);
+        });
+        it('should have optional scenario argument', async () => {
+            const WorkflowRun = (await import('./run.js')).default;
+            expect(WorkflowRun.args).toHaveProperty('scenario');
+            expect(WorkflowRun.args.scenario.required).toBe(false);
         });
     });
 });

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

@@ -4,9 +4,10 @@ export default class WorkflowStart extends Command {
     static examples: string[];
     static args: {
         workflowName: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        scenario: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static flags: {
-        input: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        input: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'task-queue': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/commands/workflow/start.js

@@ -1,10 +1,11 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { postWorkflowStart } from '#api/generated/api.js';
-import { parseInputFlag } from '#utils/input_parser.js';
 import { handleApiError } from '#utils/error_handler.js';
+import { resolveInput } from '#utils/resolve_input.js';
 export default class WorkflowStart extends Command {
     static description = 'Start a workflow asynchronously without waiting for completion';
     static examples = [
+        '<%= config.bin %> <%= command.id %> simple basic_input',
         '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
         '<%= config.bin %> <%= command.id %> simple --input input.json',
         '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --task-queue my-queue'
@@ -13,13 +14,17 @@ export default class WorkflowStart extends Command {
         workflowName: Args.string({
             description: 'Name of the workflow to start',
             required: true
+        }),
+        scenario: Args.string({
+            description: 'Scenario name (resolved from the workflow\'s scenarios/ directory)',
+            required: false
         })
     };
     static flags = {
         input: Flags.string({
             char: 'i',
-            description: 'Workflow input as JSON string or file path',
-            required: true
+            description: 'Workflow input as JSON string or file path (overrides scenario)',
+            required: false
         }),
         'task-queue': Flags.string({
             char: 'q',
@@ -28,7 +33,7 @@ export default class WorkflowStart extends Command {
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowStart);
-        const input = parseInputFlag(flags.input);
+        const input = await resolveInput(args.workflowName, args.scenario, flags.input, 'start');
         this.log(`Starting workflow: ${args.workflowName}...`);
         const response = await postWorkflowStart({
             workflowName: args.workflowName,

package/dist/commands/workflow/{start.test.js → start.spec.js}

@@ -17,7 +17,12 @@ describe('workflow start command', () => {
         });
         it('should have correct flag configuration', async () => {
             const WorkflowStart = (await import('./start.js')).default;
-            expect(WorkflowStart.flags.input.required).toBe(true);
+            expect(WorkflowStart.flags.input.required).toBe(false);
+        });
+        it('should have optional scenario argument', async () => {
+            const WorkflowStart = (await import('./start.js')).default;
+            expect(WorkflowStart.args).toHaveProperty('scenario');
+            expect(WorkflowStart.args.scenario.required).toBe(false);
         });
     });
 });

package/dist/generated/sdk_versions.json

@@ -1,6 +1,6 @@
 {
-    "core": "0.3.2",
-    "llm": "0.2.10",
+    "core": "0.3.6",
+    "llm": "0.2.12",
     "http": "0.1.2",
-    "cli": "0.7.13"
+    "cli": "0.7.15"
 }

package/dist/services/claude_client.js

@@ -29,7 +29,7 @@ const ADDITIONAL_INSTRUCTIONS_BUILD = `
 
 2. Follow the implementation plan exactly as specified in the plan file.
 
-3. Implement all workflow files following Output SDK patterns and best practices.
+3. Implement all workflow files following Output.ai patterns and best practices.
 
 4. After you mark all todos as complete, provide a summary of what was implemented.
 `;

package/dist/services/messages.js

@@ -177,7 +177,7 @@ export const getProjectSuccessMessage = (folderName, installSuccess, envConfigur
         note: 'Launches Temporal, Redis, PostgreSQL, API, Worker, and UI'
     }, {
         step: 'Run example workflow',
-        command: 'npx output workflow run blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json',
+        command: 'npx output workflow run blog_evaluator paulgraham_hwh',
         note: 'Execute in a new terminal after services are running'
     }, {
         step: 'Monitor workflows',
@@ -199,14 +199,14 @@ ${createOutputBanner()}
 
 ${divider}
 
-${ux.colorize('bold', ux.colorize('green', '🎉 SUCCESS!'))} ${ux.colorize('bold', 'Your Output SDK project has been created')}
+${ux.colorize('bold', ux.colorize('green', '🎉 SUCCESS!'))} ${ux.colorize('bold', 'Your Output project has been created')}
 
 ${divider}
 
 ${createSectionHeader('PROJECT DETAILS', '📁')}
 
   ${bulletPoint} ${ux.colorize('white', 'Name:')} ${formatPath(folderName)}
-  ${bulletPoint} ${ux.colorize('white', 'Type:')} Output SDK Workflow Project
+  ${bulletPoint} ${ux.colorize('white', 'Type:')} Output Project
   ${bulletPoint} ${ux.colorize('white', 'Structure:')} ${formatPath('.outputai/')} (agents), ${formatPath('workflows/')} (implementations)
 
 ${divider}
@@ -229,7 +229,7 @@ ${divider}
 ${ux.colorize('dim', '💡 Tip: Use ')}${formatCommand('npx output workflow plan')}${ux.colorize('dim', ' to design your first custom workflow')}
 ${ux.colorize('dim', '         with AI assistance.')}
 
-${ux.colorize('green', ux.colorize('bold', 'Happy building with Output SDK! 🚀'))}
+${ux.colorize('green', ux.colorize('bold', 'Happy building with Output! 🚀'))}
 `;
 };
 export const getWorkflowGenerateSuccessMessage = (workflowName, targetDir, filesCreated) => {
@@ -321,7 +321,7 @@ ${createSectionHeader('RUN A WORKFLOW', '🚀')}
 
   ${ux.colorize('white', 'In a new terminal, execute:')}
 
-    ${formatCommand('npx output workflow run blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json')}
+    ${formatCommand('npx output workflow run blog_evaluator paulgraham_hwh')}
 
 ${divider}
 

package/dist/services/project_scaffold.js

@@ -62,7 +62,7 @@ const promptForProjectName = async (defaultProjectName) => {
     }) || defaultProjectName;
 };
 const generateProjectDescription = (projectName) => {
-    return `An Output SDK workflow for ${kebabCase(projectName)}`;
+    return `AI Agents & Workflows built with Output.ai for ${kebabCase(projectName)}`;
 };
 /**
  * Get project configuration from user input
@@ -98,7 +98,7 @@ async function scaffoldProjectFiles(projectPath, projectName, description) {
     const templateVars = {
         projectName: kebabCase(projectName),
         ProjectName: pascalCase(projectName),
-        description: description || `An Output SDK workflow for ${projectName}`,
+        description: description || `An Output.ai workflow for ${projectName}`,
         coreVersion: sdkVersions.core,
         llmVersion: sdkVersions.llm,
         httpVersion: sdkVersions.http,

package/dist/services/project_scaffold.spec.js

@@ -48,7 +48,7 @@ describe('project_scaffold', () => {
         });
         it('should auto-generate description when folderName provided', async () => {
             const config = await getProjectConfig('test-folder');
-            expect(config.description).toBe('An Output SDK workflow for test-folder');
+            expect(config.description).toBe('AI Agents & Workflows built with Output.ai for test-folder');
         });
         it('should prompt for project name and folder name when not provided', async () => {
             const { input } = await import('@inquirer/prompts');
@@ -58,7 +58,7 @@ describe('project_scaffold', () => {
             const config = await getProjectConfig();
             expect(config.projectName).toBe('Test Project');
             expect(config.folderName).toBe('test-project');
-            expect(config.description).toBe('An Output SDK workflow for test-project');
+            expect(config.description).toBe('AI Agents & Workflows built with Output.ai for test-project');
             expect(input).toHaveBeenCalledTimes(2);
         });
     });

package/dist/templates/agent_instructions/dotoutputai/AGENTS.md.template

@@ -2,17 +2,17 @@
 
 ## Overview
 
-This project uses Output.ai Framework to build durable, LLM-powered workflows orchestrated by Temporal. Output Framework provides abstractions for creating reliable AI workflows with automatic retry, tracing, and error handling. Developers use it to build workflows like fact checkers, content generators, data extractors, research assistants, and multi-step AI agents mixing API clients.
+This project uses Output.ai Framework to build production-ready AI applications with built-in prompt management, evaluation, observability, and error handling. Developers use it to build AI features like fact checkers, content generators, data extractors, research assistants, and multi-step agents.
 
 ### Project Overview
 
-Each workflow lives in its own folder under `src/workflows/` and follows a consistent structure. Workflows define the orchestration logic, calling steps to perform external operations like API calls, database queries, and LLM inference. The system automatically handles retries, timeouts, and distributed execution through Temporal.
+Each workflow lives in its own folder under `src/workflows/` and follows a consistent structure. Workflows define the orchestration logic, calling steps to perform external operations like API calls, database queries, and LLM inference. The framework automatically handles retries, timeouts, and reliable execution.
 
 ### Key Concepts
 
-#### Built on Top of Temporal
+#### Durable Execution powered by Temporal.io
 
-Temporal provides durable execution guarantees - if a workflow fails mid-execution, it resumes from the last successful step rather than restarting. Output Framework wraps Temporal's workflow and activity primitives with higher-level abstractions (`workflow`, `step`, `evaluator`) that enforce best practices and provide automatic tracing.
+Output provides durable execution guarantees (built on Temporal.io) - if execution fails mid-run, it resumes from the last successful step rather than restarting. The framework provides high-level abstractions (`workflow`, `step`, `evaluator`) that enforce best practices and provide automatic tracing.
 
 #### Single Folder Project Structure
 

package/dist/templates/project/README.md.template

@@ -81,7 +81,7 @@ This starts:
 In a new terminal:
 
 ```bash
-npx output workflow run blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json
+npx output workflow run blog_evaluator paulgraham_hwh
 ```
 
 ### 5. Stop Services

package/dist/templates/workflow/README.md.template

@@ -4,7 +4,7 @@
 
 ## Overview
 
-This workflow was generated using the Output SDK CLI. It provides a starting point for building Temporal-based workflows with LLM integration.
+This was generated using the Output.ai CLI. It provides a starting point for building AI applications with production-ready LLM integration, built-in prompt management, evaluation, and observability.
 
 ## Files
 
@@ -41,7 +41,7 @@ workflow/
 
 ## Import Rules
 
-**Important:** Steps and evaluators are Temporal activities. Activities cannot call other activities.
+**Important:** Steps and evaluators are isolated execution units that cannot call each other.
 
 **Steps can import from:**
 - Local utilities (`./utils.ts`, `./utils/*.ts`)
@@ -105,7 +105,7 @@ Example:
 
 ### Workflow Structure
 
-The workflow follows the Output SDK conventions:
+The workflow follows the Output.ai conventions:
 
 ```typescript
 import { workflow, z } from '@output.ai/core';
@@ -221,7 +221,7 @@ To test your workflow:
 
 1. Build the parent project containing this workflow
 2. Start the Output worker
-3. Execute the workflow using the Output SDK API
+3. Execute the workflow using the Output.ai API
 
 Example execution:
 ```bash
@@ -230,5 +230,5 @@ npx output workflow run {{workflowName}} --input '{"prompt": "Hello"}'
 
 ## Resources
 
-- [Output SDK Documentation](https://docs.output.ai)
+- [Output.ai Documentation](https://docs.output.ai)
 - [Temporal Documentation](https://docs.temporal.io)

package/dist/types/trace.d.ts

@@ -107,7 +107,7 @@ export interface TraceStructure {
     children?: DebugNode[];
 }
 /**
- * The structure of a workflow trace file generated by Output SDK workflow runs.
+ * The structure of a workflow trace file generated by Output.ai workflow runs.
  * This file is written to the local filesystem during workflow execution and contains
  * the complete execution history including timing, inputs, outputs, and any errors.
  */

package/dist/utils/resolve_input.d.ts

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

package/dist/utils/resolve_input.js

@@ -0,0 +1,22 @@
+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) {
+    if (inputFlag && scenario) {
+        return ux.error('Cannot use both scenario argument and --input flag. Choose one.', { exit: 1 });
+    }
+    if (inputFlag) {
+        return parseInputFlag(inputFlag);
+    }
+    if (scenario) {
+        const resolution = await resolveScenarioPath(workflowName, scenario);
+        if (!resolution.found) {
+            return ux.error(getScenarioNotFoundMessage(workflowName, scenario, resolution.searchedPaths), { exit: 1 });
+        }
+        ux.stdout(`Using scenario: ${resolution.path}\n`);
+        return parseInputFlag(resolution.path);
+    }
+    return ux.error('Input required. Provide either:\n' +
+        `  - A scenario name: output workflow ${commandName} <workflow> <scenario>\n` +
+        `  - An input flag: output workflow ${commandName} <workflow> --input <json-or-file>`, { exit: 1 });
+}

package/dist/utils/scenario_resolver.d.ts

@@ -0,0 +1,9 @@
+export interface ScenarioResolutionResult {
+    found: boolean;
+    path?: string;
+    searchedPaths: string[];
+}
+export declare function extractWorkflowRelativePath(path: string): string | null;
+export declare function resolveScenarioPath(workflowName: string, scenarioName: string, basePath?: 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

@@ -0,0 +1,92 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { getWorkflowCatalog } from '#api/generated/api.js';
+const SCENARIOS_DIR = 'scenarios';
+const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
+export function extractWorkflowRelativePath(path) {
+    const match = path.match(/workflows\/(.+)\/workflow\.[jt]s$/);
+    return match ? match[1] : null;
+}
+async function fetchWorkflowDirectory(workflowName) {
+    try {
+        const response = await getWorkflowCatalog();
+        const workflows = response?.data?.workflows;
+        if (!workflows) {
+            return null;
+        }
+        const workflow = workflows.find(w => w.name === workflowName);
+        if (!workflow) {
+            return null;
+        }
+        const workflowPath = workflow.path;
+        if (!workflowPath) {
+            return null;
+        }
+        return extractWorkflowRelativePath(workflowPath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveScenarioFromDirectory(relativeDir, scenarioFileName, basePath) {
+    const searchedPaths = [];
+    for (const workflowsDir of WORKFLOWS_PATHS) {
+        const candidatePath = resolve(basePath, workflowsDir, relativeDir, SCENARIOS_DIR, scenarioFileName);
+        searchedPaths.push(candidatePath);
+        if (existsSync(candidatePath)) {
+            return { found: true, path: candidatePath, searchedPaths };
+        }
+    }
+    return { found: false, searchedPaths };
+}
+export async function resolveScenarioPath(workflowName, scenarioName, basePath = process.cwd()) {
+    const scenarioFileName = scenarioName.endsWith('.json') ?
+        scenarioName :
+        `${scenarioName}.json`;
+    const catalogDir = await fetchWorkflowDirectory(workflowName);
+    if (catalogDir) {
+        const result = resolveScenarioFromDirectory(catalogDir, scenarioFileName, basePath);
+        if (result.found) {
+            return result;
+        }
+        // Catalog resolved but scenario not found at that path — still try convention fallback
+        // in case the catalog path differs from local source layout
+        if (catalogDir !== workflowName) {
+            const fallback = resolveScenarioFromDirectory(workflowName, scenarioFileName, basePath);
+            return {
+                found: fallback.found,
+                path: fallback.path,
+                searchedPaths: [...result.searchedPaths, ...fallback.searchedPaths]
+            };
+        }
+        return result;
+    }
+    // API unavailable or workflow not in catalog — fall back to convention
+    return resolveScenarioFromDirectory(workflowName, scenarioFileName, basePath);
+}
+export function listScenariosForWorkflow(workflowName, workflowPath, basePath = process.cwd()) {
+    const relativeDir = (workflowPath && extractWorkflowRelativePath(workflowPath)) || workflowName;
+    for (const workflowsDir of WORKFLOWS_PATHS) {
+        const scenariosDir = resolve(basePath, workflowsDir, relativeDir, SCENARIOS_DIR);
+        if (existsSync(scenariosDir)) {
+            return readdirSync(scenariosDir)
+                .filter(f => f.endsWith('.json'))
+                .map(f => f.replace(/\.json$/, ''));
+        }
+    }
+    return [];
+}
+export function getScenarioNotFoundMessage(workflowName, scenarioName, searchedPaths) {
+    const pathsList = searchedPaths.map(p => `  - ${p}`).join('\n');
+    return [
+        `Scenario '${scenarioName}' not found for workflow '${workflowName}'.`,
+        '',
+        'Searched in:',
+        pathsList,
+        '',
+        'Tip: Create a scenario file in your workflow\'s scenarios/ directory.',
+        '',
+        'Or use --input to specify a custom path:',
+        `  output workflow run ${workflowName} --input /path/to/input.json`
+    ].join('\n');
+}

package/dist/utils/scenario_resolver.spec.d.ts

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

package/dist/utils/scenario_resolver.spec.js

@@ -0,0 +1,214 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { resolveScenarioPath, getScenarioNotFoundMessage, extractWorkflowRelativePath, listScenariosForWorkflow } from './scenario_resolver.js';
+import * as fs from 'node:fs';
+import * as api from '#api/generated/api.js';
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn(),
+    readdirSync: vi.fn()
+}));
+vi.mock('#api/generated/api.js', () => ({
+    getWorkflowCatalog: vi.fn()
+}));
+function mockCatalog(workflows) {
+    vi.mocked(api.getWorkflowCatalog).mockResolvedValue({
+        data: { workflows },
+        status: 200,
+        headers: new Headers()
+    });
+}
+function mockCatalogFailure() {
+    vi.mocked(api.getWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
+}
+describe('extractWorkflowRelativePath', () => {
+    it('should extract relative path from workflow.js path', () => {
+        expect(extractWorkflowRelativePath('/app/dist/workflows/basic_research/workflow.js'))
+            .toBe('basic_research');
+    });
+    it('should extract nested relative path', () => {
+        expect(extractWorkflowRelativePath('/app/dist/workflows/viz_examples/01_simple_linear/workflow.js'))
+            .toBe('viz_examples/01_simple_linear');
+    });
+    it('should handle workflow.ts extension', () => {
+        expect(extractWorkflowRelativePath('/src/workflows/my_flow/workflow.ts'))
+            .toBe('my_flow');
+    });
+    it('should return null for non-matching paths', () => {
+        expect(extractWorkflowRelativePath('/app/dist/other/workflow.js')).toBeNull();
+        expect(extractWorkflowRelativePath('/app/dist/workflows/')).toBeNull();
+    });
+});
+describe('resolveScenarioPath', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('when API returns workflow with path', () => {
+        it('should resolve scenario using catalog path', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test_scenario.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/my_workflow/scenarios/test_scenario.json');
+        });
+        it('should resolve when workflow name differs from folder name', async () => {
+            mockCatalog([{ name: 'simpleLinear', path: '/app/dist/workflows/viz_examples/01_simple_linear/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/viz_examples/01_simple_linear/scenarios/basic.json');
+            });
+            const result = await resolveScenarioPath('simpleLinear', 'basic', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/viz_examples/01_simple_linear/scenarios/basic.json');
+        });
+        it('should handle nested workflow directories', async () => {
+            mockCatalog([{ name: 'deep_flow', path: '/app/dist/workflows/category/sub/deep_flow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/category/sub/deep_flow/scenarios/test.json');
+            });
+            const result = await resolveScenarioPath('deep_flow', 'test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/category/sub/deep_flow/scenarios/test.json');
+        });
+        it('should return not found when scenario file does not exist', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            const result = await resolveScenarioPath('my_workflow', 'missing', '/project');
+            expect(result.found).toBe(false);
+            expect(result.searchedPaths.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should fall back to convention when catalog path has no scenario but convention does', async () => {
+            mockCatalog([{ name: 'renamedFlow', path: '/app/dist/workflows/actual_folder/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                // Not found at catalog-resolved path, but found at convention path
+                return String(path).includes('src/workflows/renamedFlow/scenarios/test.json');
+            });
+            const result = await resolveScenarioPath('renamedFlow', 'test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/renamedFlow/scenarios/test.json');
+        });
+    });
+    describe('when API is unavailable', () => {
+        it('should fall back to convention-based lookup', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test_scenario.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/my_workflow/scenarios/test_scenario.json');
+        });
+    });
+    describe('when workflow is not in catalog', () => {
+        it('should fall back to convention-based lookup', async () => {
+            mockCatalog([{ name: 'other_workflow', path: '/app/dist/workflows/other/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('src/workflows/my_workflow/scenarios/test.json');
+        });
+    });
+    describe('json extension normalization', () => {
+        it('should handle scenario name with .json extension', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/test_scenario.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario.json', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('test_scenario.json');
+            expect(result.path).not.toContain('test_scenario.json.json');
+        });
+    });
+    describe('workflows fallback directory', () => {
+        it('should find scenario in workflows/ fallback path', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('workflows/my_workflow/scenarios/test_scenario.json') &&
+                    !String(path).includes('src/workflows');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'test_scenario', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('workflows/my_workflow/scenarios/test_scenario.json');
+        });
+    });
+    describe('subdirectory scenarios', () => {
+        it('should support subdirectory paths in scenario name', async () => {
+            mockCatalogFailure();
+            vi.mocked(fs.existsSync).mockImplementation(path => {
+                return String(path).includes('src/workflows/my_workflow/scenarios/complex/deep_test.json');
+            });
+            const result = await resolveScenarioPath('my_workflow', 'complex/deep_test', '/project');
+            expect(result.found).toBe(true);
+            expect(result.path).toContain('complex/deep_test.json');
+        });
+    });
+});
+describe('listScenariosForWorkflow', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should return scenario names from scenarios directory', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/my_workflow/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['basic.json', 'advanced.json', 'README.md']);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual(['basic', 'advanced']);
+    });
+    it('should use workflowPath from catalog to derive directory', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/viz_examples/01_simple_linear/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['test.json']);
+        const result = listScenariosForWorkflow('simpleLinear', '/app/dist/workflows/viz_examples/01_simple_linear/workflow.js', '/project');
+        expect(result).toEqual(['test']);
+    });
+    it('should fall back to workflowName when workflowPath is undefined', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/my_workflow/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['scenario_a.json']);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual(['scenario_a']);
+    });
+    it('should fall back to workflowName when path extraction returns null', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path).includes('src/workflows/my_workflow/scenarios'));
+        vi.mocked(fs.readdirSync).mockReturnValue(['test.json']);
+        const result = listScenariosForWorkflow('my_workflow', '/invalid/path.js', '/project');
+        expect(result).toEqual(['test']);
+    });
+    it('should return empty array when no scenarios directory exists', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual([]);
+    });
+    it('should try workflows/ fallback when src/workflows/ does not exist', () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => {
+            const p = String(path);
+            return p.includes('workflows/my_workflow/scenarios') && !p.includes('src/workflows');
+        });
+        vi.mocked(fs.readdirSync).mockReturnValue(['fallback.json']);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual(['fallback']);
+    });
+    it('should return empty array for empty scenarios directory', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readdirSync).mockReturnValue([]);
+        const result = listScenariosForWorkflow('my_workflow', undefined, '/project');
+        expect(result).toEqual([]);
+    });
+});
+describe('getScenarioNotFoundMessage', () => {
+    it('should return a helpful error message', () => {
+        const searchedPaths = [
+            '/project/src/workflows/my_workflow/scenarios/test.json',
+            '/project/workflows/my_workflow/scenarios/test.json'
+        ];
+        const message = getScenarioNotFoundMessage('my_workflow', 'test', searchedPaths);
+        expect(message).toContain('Scenario \'test\' not found for workflow \'my_workflow\'');
+        expect(message).toContain('Searched in:');
+        expect(message).toContain(searchedPaths[0]);
+        expect(message).toContain(searchedPaths[1]);
+        expect(message).toContain('Tip:');
+        expect(message).toContain('--input');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.7.13",
+  "version": "0.7.15",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",