@output.ai/cli 0.7.9 → 0.7.11-dev.pr263-8f8e94a

package/dist/generated/sdk_versions.json

@@ -1,6 +1,6 @@
 {
-    "core": "0.2.2",
+    "core": "0.3.0",
     "llm": "0.2.8",
     "http": "0.1.1",
-    "cli": "0.7.9"
+    "cli": "0.7.11"
 }

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 example_question --input src/workflows/example_question/scenarios/question_ada_lovelace.json',
+        command: 'npx output workflow run poke_battle --input src/workflows/poke_battle/scenarios/pikachu_vs_charmander.json',
         note: 'Execute in a new terminal after services are running'
     }, {
         step: 'Monitor workflows',

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

@@ -186,7 +186,7 @@ export default workflow({
 });
 ```
 
-**Allowed imports**: steps.ts, evaluators.ts, shared_steps.ts, types.ts, consts.ts, utils.ts
+**Allowed imports**: steps.ts, evaluators.ts, ../../shared/steps/*.ts, types.ts, consts.ts, utils.ts
 
 **Forbidden in workflows**: Direct API calls, Math.random(), Date.now(), dynamic imports
 

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

@@ -7,6 +7,43 @@
 - Node.js >= 24.3
 - Docker and Docker Compose (for local development)
 
+## Project Structure
+
+```
+src/
+├── shared/                    # Shared code across workflows
+│   ├── clients/               # API clients (e.g., pokeapi.ts)
+│   └── utils/                 # Utility functions (e.g., string.ts)
+└── workflows/                 # Workflow definitions
+    └── poke_battle/           # Example workflow
+        ├── workflow.ts        # Main workflow
+        ├── steps.ts           # Workflow steps
+        ├── evaluators.ts      # Quality evaluators
+        ├── utils.ts           # Local utilities
+        ├── prompts/           # LLM prompts
+        └── scenarios/         # Test scenarios
+```
+
+### Shared Directory
+
+The `src/shared/` directory contains code shared across multiple workflows:
+
+- **`shared/clients/`** - API clients using `@output.ai/http` for external services
+- **`shared/utils/`** - Helper functions and utilities
+
+### Import Rules
+
+**Workflows** can import from:
+- Local steps, evaluators, and utilities
+- Shared steps, evaluators, clients, and utilities
+
+**Steps and Evaluators** can import from:
+- Local utilities and clients
+- Shared utilities and clients
+
+**Steps and Evaluators cannot** import from:
+- Other steps or evaluators (Temporal activity isolation)
+
 ## Getting Started
 
 ### 1. Install Dependencies
@@ -44,7 +81,7 @@ This starts:
 In a new terminal:
 
 ```bash
-npx output workflow run example_question --input '{"question": "who really is ada lovelace?"}'
+npx output workflow run poke_battle --input src/workflows/poke_battle/scenarios/pikachu_vs_charmander.json
 ```
 
 ### 5. Stop Services

package/dist/templates/project/src/shared/clients/pokeapi.ts.template

@@ -0,0 +1,43 @@
+import { httpClient, HttpClientOptions } from '@output.ai/http';
+
+export interface Pokemon {
+  name: string;
+  types: Array<{ type: { name: string } }>;
+  abilities: Array<{ ability: { name: string }; is_hidden: boolean }>;
+  stats: Array<{ stat: { name: string }; base_stat: number }>;
+}
+
+const basePokeApiClient = httpClient( {
+  prefixUrl: 'https://pokeapi.co/api/v2'
+} );
+
+const pokemonClient = basePokeApiClient.extend( options => ( {
+  prefixUrl: `${options.prefixUrl}/pokemon`,
+  timeout: 10000
+} ) as HttpClientOptions );
+
+/**
+ * Fetch Pokemon data from PokeAPI, extracting only the relevant fields.
+ * The full API response is huge (sprites, all moves, etc.), so we filter
+ * to just what's needed for the battle screenplay.
+ */
+export async function getPokemon( name: string ): Promise<Pokemon> {
+  const response = await pokemonClient.get( name );
+  const data = await response.json() as Record<string, unknown>;
+
+  // Extract only the fields we need to avoid sending huge payloads to LLM
+  return {
+    name: data.name as string,
+    types: ( data.types as Array<{ type: { name: string } }> ).map( t => ( {
+      type: { name: t.type.name }
+    } ) ),
+    abilities: ( data.abilities as Array<{ ability: { name: string }; is_hidden: boolean }> ).map( a => ( {
+      ability: { name: a.ability.name },
+      is_hidden: a.is_hidden
+    } ) ),
+    stats: ( data.stats as Array<{ stat: { name: string }; base_stat: number }> ).map( s => ( {
+      stat: { name: s.stat.name },
+      base_stat: s.base_stat
+    } ) )
+  };
+}

package/dist/templates/project/src/shared/utils/string.ts.template

@@ -0,0 +1,3 @@
+export function lowercase( str: string ): string {
+  return str.toLowerCase();
+}

package/dist/templates/project/src/workflows/poke_battle/evaluators.ts.template

@@ -0,0 +1,47 @@
+import { evaluator, z, EvaluationNumberResult } from '@output.ai/core';
+import { generateObject } from '@output.ai/llm';
+import type { Pokemon } from '../../shared/clients/pokeapi.js';
+
+const pokemonSchema = z.object( {
+  name: z.string(),
+  types: z.array( z.object( {
+    type: z.object( { name: z.string() } )
+  } ) ),
+  abilities: z.array( z.object( {
+    ability: z.object( { name: z.string() } ),
+    is_hidden: z.boolean()
+  } ) ),
+  stats: z.array( z.object( {
+    stat: z.object( { name: z.string() } ),
+    base_stat: z.number()
+  } ) )
+} );
+
+export const evaluateBattleRealism = evaluator( {
+  name: 'evaluate_battle_realism',
+  description: 'Evaluate how realistic the Pokemon battle screenplay is',
+  inputSchema: z.object( {
+    screenplay: z.string(),
+    pokemon1: pokemonSchema,
+    pokemon2: pokemonSchema
+  } ),
+  fn: async ( input: { screenplay: string; pokemon1: Pokemon; pokemon2: Pokemon } ) => {
+    const { result } = await generateObject( {
+      prompt: 'evaluate_realism@v1',
+      variables: {
+        pokemon1Name: input.pokemon1.name,
+        pokemon1Description: JSON.stringify( input.pokemon1 ),
+        pokemon2Name: input.pokemon2.name,
+        pokemon2Description: JSON.stringify( input.pokemon2 ),
+        screenplay: input.screenplay
+      },
+      schema: z.object( {
+        score: z.number().min( 0 ).max( 100 ).describe( 'Realism score 0-100' )
+      } )
+    } );
+    return new EvaluationNumberResult( {
+      value: result.score,
+      confidence: 0.9
+    } );
+  }
+} );

package/dist/templates/project/src/workflows/poke_battle/prompts/evaluate_realism@v1.prompt.template

@@ -0,0 +1,26 @@
+---
+provider: anthropic
+model: claude-haiku-4-5
+temperature: 0.7
+maxTokens: 8192
+---
+
+<user>
+Evaluate this Pokemon battle screenplay for realism.
+
+Consider:
+- Are the moves/abilities used consistent with each Pokemon's actual abilities?
+- Is the battle outcome realistic given their types and stats?
+- Does the pacing feel like a real battle?
+
+\{{ pokemon1Name }}'s Stat Sheet:
+
+\{{ pokemon1Description }}
+
+\{{ pokemon2Name }}'s Stat Sheet:
+
+\{{ pokemon2Description }}
+
+Screenplay:
+\{{ screenplay }}
+</user>

package/dist/templates/project/src/workflows/poke_battle/prompts/generate_screenplay@v1.prompt.template

@@ -0,0 +1,20 @@
+---
+provider: anthropic
+model: claude-haiku-4-5
+temperature: 0.7
+maxTokens: 8192
+---
+
+<user>
+Write a dramatic 5-minute screenplay of a Pokemon battle between \{{ pokemon1Name }} and \{{ pokemon2Name }}.
+
+\{{ pokemon1Name }}'s Stat Sheet:
+
+\{{ pokemon1Description }}
+
+\{{ pokemon2Name }}'s Stat Sheet:
+
+\{{ pokemon2Description }}
+
+Include dramatic moments, skill usage that matches their actual abilities, and a decisive outcome based on their type matchups. Format it as a proper screenplay with scene descriptions and dialogue.
+</user>

package/dist/templates/project/src/workflows/poke_battle/scenarios/pikachu_vs_charmander.json.template

@@ -0,0 +1,4 @@
+{
+  "pokemon1Name": "pikachu",
+  "pokemon2Name": "charmander"
+}

package/dist/templates/project/src/workflows/poke_battle/steps.ts.template

@@ -0,0 +1,58 @@
+import { step, z } from '@output.ai/core';
+import { generateText } from '@output.ai/llm';
+import { getPokemon, type Pokemon } from '../../shared/clients/pokeapi.js';
+
+const pokemonSchema = z.object( {
+  name: z.string(),
+  types: z.array( z.object( {
+    type: z.object( { name: z.string() } )
+  } ) ),
+  abilities: z.array( z.object( {
+    ability: z.object( { name: z.string() } ),
+    is_hidden: z.boolean()
+  } ) ),
+  stats: z.array( z.object( {
+    stat: z.object( { name: z.string() } ),
+    base_stat: z.number()
+  } ) )
+} );
+
+/**
+ * Step to fetch Pokemon data and generate a battle screenplay.
+ * HTTP clients must be used inside steps (activities), not directly in workflows,
+ * because workflows run in a sandboxed environment without Node.js APIs.
+ */
+export const generateScreenplay = step( {
+  name: 'generate_screenplay',
+  description: 'Fetch Pokemon data and generate a dramatic 5-minute battle screenplay',
+  inputSchema: z.object( {
+    pokemon1Name: z.string().describe( 'Name of the first Pokemon' ),
+    pokemon2Name: z.string().describe( 'Name of the second Pokemon' )
+  } ),
+  outputSchema: z.object( {
+    screenplay: z.string(),
+    pokemon1: pokemonSchema,
+    pokemon2: pokemonSchema
+  } ),
+  fn: async ( input: { pokemon1Name: string; pokemon2Name: string } ) => {
+    // Fetch Pokemon data inside the step (activities can use HTTP clients)
+    const pokemon1 = await getPokemon( input.pokemon1Name );
+    const pokemon2 = await getPokemon( input.pokemon2Name );
+
+    const { result } = await generateText( {
+      prompt: 'generate_screenplay@v1',
+      variables: {
+        pokemon1Name: pokemon1.name,
+        pokemon2Name: pokemon2.name,
+        pokemon1Description: JSON.stringify( pokemon1 ),
+        pokemon2Description: JSON.stringify( pokemon2 )
+      }
+    } );
+
+    return {
+      screenplay: result,
+      pokemon1: pokemon1 as Pokemon,
+      pokemon2: pokemon2 as Pokemon
+    };
+  }
+} );

package/dist/templates/project/src/workflows/poke_battle/utils.ts.template

@@ -0,0 +1,7 @@
+export function createWorkflowOutput( screenplay: string, confidenceScore: number ) {
+  return {
+    screenplay,
+    confidenceScore,
+    summary: `Battle screenplay (${confidenceScore}% confidence)`
+  };
+}

package/dist/templates/project/src/workflows/poke_battle/workflow.ts.template

@@ -0,0 +1,45 @@
+import { workflow, z } from '@output.ai/core';
+import { lowercase } from '../../shared/utils/string.js';
+import { generateScreenplay } from './steps.js';
+import { evaluateBattleRealism } from './evaluators.js';
+import { createWorkflowOutput } from './utils.js';
+
+export default workflow( {
+  name: 'poke_battle',
+  description: '{{description}}',
+  inputSchema: z.object( {
+    pokemon1Name: z.string().describe( 'Name of the first Pokemon' ),
+    pokemon2Name: z.string().describe( 'Name of the second Pokemon' )
+  } ),
+  outputSchema: z.object( {
+    screenplay: z.string().describe( 'A 5-minute battle screenplay' ),
+    confidenceScore: z.number().describe( 'Realism confidence score 0-100' ),
+    summary: z.string().describe( 'Battle summary with confidence' )
+  } ),
+  fn: async input => {
+    // Use shared util to normalize names
+    const name1 = lowercase( input.pokemon1Name );
+    const name2 = lowercase( input.pokemon2Name );
+
+    // Generate the battle screenplay (fetches Pokemon data inside the step)
+    const { screenplay, pokemon1, pokemon2 } = await generateScreenplay( {
+      pokemon1Name: name1,
+      pokemon2Name: name2
+    } );
+
+    // Evaluate realism
+    const evaluation = await evaluateBattleRealism( {
+      screenplay,
+      pokemon1,
+      pokemon2
+    } );
+
+    // Use local util to format output
+    return createWorkflowOutput( screenplay, evaluation.value );
+  },
+  options: {
+    retry: {
+      maximumAttempts: 3
+    }
+  }
+} );

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

@@ -10,8 +10,50 @@ This workflow was generated using the Output SDK CLI. It provides a starting poi
 
 - `workflow.ts` - Main workflow definition with input/output schemas
 - `steps.ts` - Activity/step definitions with input/output schemas
-- `prompt@v1.prompt` - Example LLM prompt template
-- `.env` - Environment variables for API keys and configuration
+- `evaluators.ts` - Quality evaluators for workflow outputs
+- `prompts/` - LLM prompt templates
+
+## File Organization
+
+You can organize your workflow files in two ways:
+
+**Flat files:**
+```
+workflow/
+├── workflow.ts
+├── steps.ts
+├── evaluators.ts
+└── utils.ts
+```
+
+**Folder-based:**
+```
+workflow/
+├── workflow.ts
+├── steps/
+│   ├── fetch_data.ts
+│   └── process_data.ts
+├── evaluators/
+│   └── quality.ts
+└── utils/
+    └── helpers.ts
+```
+
+## Import Rules
+
+**Important:** Steps and evaluators are Temporal activities. Activities cannot call other activities.
+
+**Steps can import from:**
+- Local utilities (`./utils.ts`, `./utils/*.ts`)
+- Shared utilities (`../../shared/utils/*.ts`)
+- Shared clients (`../../shared/clients/*.ts`)
+
+**Steps cannot import from:**
+- Other steps or evaluators (activity isolation)
+- Workflow files
+
+**Workflows can import from:**
+- Steps, evaluators, and utilities (local and shared)
 
 ## Setup
 
@@ -63,121 +105,109 @@ Example:
 
 ### Workflow Structure
 
-The workflow follows the new Output SDK conventions:
+The workflow follows the Output SDK conventions:
 
 ```typescript
-import { workflow } from '@output.ai/core';
-import { myStep, anotherStep } from './steps.js';
-
-const inputSchema = {
-  type: 'object',
-  properties: {
-    // Define your input properties
-  }
-};
-
-const outputSchema = {
-  type: 'object',
-  properties: {
-    // Define your output properties
-  }
-};
+import { workflow, z } from '@output.ai/core';
+import { myStep } from './steps.js';
+import { evaluateQuality } from './evaluators.js';
 
 export default workflow( {
   name: 'workflowName',
   description: 'Workflow description',
-  inputSchema,
-  outputSchema,
+  inputSchema: z.object( { /* ... */ } ),
+  outputSchema: z.object( { /* ... */ } ),
   fn: async ( input ) => {
-    // Call steps directly
     const result = await myStep( input );
-    return result;
+    const { score } = await evaluateQuality( { input, output: result } );
+    return { result, qualityScore: score };
   }
 } );
 ```
 
 ### Adding New Steps
 
-1. Define new steps in `steps.ts` with schemas:
+Define steps in `steps.ts` with schemas:
 
 ```typescript
-import { step } from '@output.ai/core';
-
-const inputSchema = {
-  type: 'object',
-  properties: {
-    value: { type: 'number' }
-  },
-  required: ['value']
-};
-
-const outputSchema = {
-  type: 'object',
-  properties: {
-    result: { type: 'string' }
-  }
-};
+import { step, z } from '@output.ai/core';
 
 export const myStep = step( {
   name: 'myStep',
   description: 'Description of what this step does',
-  inputSchema,
-  outputSchema,
-  fn: async ( input: { value: number } ) => {
-    // Step implementation
+  inputSchema: z.object( {
+    value: z.number()
+  } ),
+  outputSchema: z.object( {
+    result: z.string()
+  } ),
+  fn: async ( input ) => {
     return { result: `Processed ${input.value}` };
   }
 } );
 ```
 
-2. Import and use the step in your workflow (`workflow.ts`):
+### Adding Evaluators
+
+Define evaluators in `evaluators.ts`:
 
 ```typescript
-import { myStep } from './steps.js';
+import { evaluator, z } from '@output.ai/core';
+import { generateText } from '@output.ai/llm';
 
-// Inside workflow fn:
-const result = await myStep( { value: 42 } );
+export const evaluateQuality = evaluator( {
+  name: 'evaluate_quality',
+  description: 'Evaluate output quality',
+  inputSchema: z.object( {
+    input: z.any(),
+    output: z.any()
+  } ),
+  outputSchema: z.object( {
+    score: z.number().min( 0 ).max( 100 )
+  } ),
+  fn: async ( data ) => {
+    const { result } = await generateText( {
+      prompt: 'evaluate@v1',
+      variables: { input: data.input, output: data.output }
+    } );
+    return { score: parseInt( result, 10 ) };
+  }
+} );
 ```
 
 ### Using LLM in Steps
 
-The template includes an example of using LLM with prompts:
-
 ```typescript
 import { generateText } from '@output.ai/llm';
 
 export const llmStep = step( {
   name: 'llmStep',
   description: 'Generate text using LLM',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      userInput: { type: 'string' }
-    }
-  },
-  outputSchema: { type: 'string' },
-  fn: async ( input: { userInput: string } ) => {
-    const response = await generateText( {
+  inputSchema: z.object( {
+    userInput: z.string()
+  } ),
+  outputSchema: z.string(),
+  fn: async ( input ) => {
+    const { result } = await generateText( {
       prompt: 'prompt@v1',
       variables: { userInput: input.userInput }
     } );
-    return response;
+    return result;
   }
 } );
 ```
 
 ### Creating Prompt Templates
 
-Create new prompt files following the pattern:
+Create prompt files in `prompts/` following the pattern:
 - File naming: `promptName@v1.prompt`
-- Include YAML frontmatter with provider and model
+- Include YAML frontmatter with model
 - Use LiquidJS syntax for variables: `{{ variableName }}`
 
 Example prompt file:
 ```
 ---
-provider: anthropic
-model: claude-3-5-sonnet-latest
+model: anthropic/claude-sonnet-4-20250514
 ---
 
 {{ userInput }}
@@ -195,19 +225,10 @@ To test your workflow:
 
 Example execution:
 ```bash
-curl -X POST http://localhost:3001/workflow \
-  -H "Content-Type: application/json" \
-  -d '{
-    "workflowName": "{{workflowName}}",
-    "input": {
-      "prompt": "Tell me about workflows",
-      "data": { "value": 42, "type": "example" }
-    }
-  }'
+npx output workflow run {{workflowName}} --input '{"prompt": "Hello"}'
 ```
 
 ## Resources
 
-- [Output SDK Documentation](https://github.com/growthxai/output-sdk)
+- [Output SDK Documentation](https://docs.output.ai)
 - [Temporal Documentation](https://docs.temporal.io)
-- [AI SDK Documentation](https://sdk.vercel.ai/docs)

package/dist/templates/workflow/evaluators.ts.template

@@ -0,0 +1,23 @@
+import { evaluator, z } from '@output.ai/core';
+
+// Example evaluator - customize for your workflow
+export const evaluate{{WorkflowName}} = evaluator( {
+  name: 'evaluate_{{workflowName}}',
+  description: 'Evaluate the quality of {{workflowName}} output',
+  inputSchema: z.object( {
+    input: z.any(),
+    output: z.any()
+  } ),
+  outputSchema: z.object( {
+    score: z.number().min( 0 ).max( 100 ).describe( 'Quality score 0-100' ),
+    feedback: z.string().describe( 'Feedback on the output quality' )
+  } ),
+  fn: async () => {
+    // TODO: Implement evaluation logic
+    // Use LLM or custom logic to score the output quality
+    return {
+      score: 100,
+      feedback: 'Evaluation not yet implemented'
+    };
+  }
+} );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/cli",
-  "version": "0.7.9",
+  "version": "0.7.11-dev.pr263-8f8e94a",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",

package/dist/templates/project/src/workflows/example_question/prompts/answer_question@v1.prompt.template

@@ -1,13 +0,0 @@
----
-provider: anthropic
-model: claude-opus-4-1-20250805
-temperature: 0.7
----
-
-<system>
-You are a helpful assistant. Answer the user's question concisely and clearly.
-</system>
-
-<user>
-Answer the following question: \{{ question }}
-</user>

package/dist/templates/project/src/workflows/example_question/scenarios/question_ada_lovelace.json.template

@@ -1,3 +0,0 @@
-{
-  "question": "who really is ada lovelace?"
-}

package/dist/templates/project/src/workflows/example_question/steps.ts.template

@@ -1,16 +0,0 @@
-import { step, z } from '@output.ai/core';
-import { generateText } from '@output.ai/llm';
-
-export const answerQuestion = step( {
-  name: 'answerQuestion',
-  description: 'Answer a question using an LLM',
-  inputSchema: z.string(),
-  outputSchema: z.string(),
-  fn: async question => {
-    const { result } = await generateText( {
-      prompt: 'answer_question@v1',
-      variables: { question }
-    } );
-    return result;
-  }
-} );

package/dist/templates/project/src/workflows/example_question/workflow.ts.template

@@ -1,22 +0,0 @@
-import { workflow, z } from '@output.ai/core';
-import { answerQuestion } from './steps.js';
-
-export default workflow( {
-  name: 'example_question',
-  description: '{{description}}',
-  inputSchema: z.object( {
-    question: z.string().describe( 'A question to answer' )
-  } ),
-  outputSchema: z.object( {
-    answer: z.string().describe( 'The answer to the question' )
-  } ),
-  fn: async input => {
-    const answer = await answerQuestion( input.question );
-    return { answer };
-  },
-  options: {
-    retry: {
-      maximumAttempts: 3
-    }
-  }
-} );