@output.ai/cli 0.7.11 → 0.7.12

package/README.md

@@ -18,7 +18,7 @@ cd <project-name>
 npx output dev
 
 # Run a workflow
-npx output workflow run example_question --input '{"question": "who is ada lovelace?"}'
+npx output workflow run blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json
 ```
 
 ## Environment Configuration

package/dist/generated/sdk_versions.json

@@ -1,6 +1,6 @@
 {
-    "core": "0.2.4",
-    "llm": "0.2.8",
+    "core": "0.3.0",
+    "llm": "0.2.9",
     "http": "0.1.1",
-    "cli": "0.7.11"
+    "cli": "0.7.12"
 }

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 blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json',
         note: 'Execute in a new terminal after services are running'
     }, {
         step: 'Monitor workflows',
@@ -321,7 +321,7 @@ ${createSectionHeader('RUN A WORKFLOW', '🚀')}
 
   ${ux.colorize('white', 'In a new terminal, execute:')}
 
-    ${formatCommand('npx output workflow run example_question --input \'{"question": "Hello!"}\'')}
+    ${formatCommand('npx output workflow run blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json')}
 
 ${divider}
 

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., jina.ts)
+│   └── utils/                 # Utility functions (e.g., string.ts)
+└── workflows/                 # Workflow definitions
+    └── blog_evaluator/        # 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 blog_evaluator --input src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json
 ```
 
 ### 5. Stop Services

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

@@ -0,0 +1,30 @@
+import { httpClient } from '@output.ai/http';
+
+export interface JinaReaderResponse {
+  code: number;
+  status: number;
+  data: {
+    title: string;
+    description: string;
+    url: string;
+    content: string;
+    usage: { tokens: number };
+  };
+}
+
+const jinaClient = httpClient( {
+  prefixUrl: 'https://r.jina.ai',
+  timeout: 30000
+} );
+
+export async function fetchBlogContent( url: string ): Promise<JinaReaderResponse> {
+  const response = await jinaClient.post( '', {
+    json: { url },
+    headers: {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json',
+      'X-Return-Format': 'markdown'
+    }
+  } );
+  return response.json() as Promise<JinaReaderResponse>;
+}

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/shared/utils/url.ts.template

@@ -0,0 +1,15 @@
+export function isValidUrl( urlString: string ): boolean {
+  try {
+    const url = new URL( urlString );
+    return url.protocol === 'http:' || url.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+export function validateUrl( urlString: string ): string {
+  if ( !isValidUrl( urlString ) ) {
+    throw new Error( `Invalid URL: ${urlString}` );
+  }
+  return urlString;
+}

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

@@ -0,0 +1,33 @@
+import { evaluator, z, EvaluationNumberResult } from '@output.ai/core';
+import { generateObject } from '@output.ai/llm';
+import type { BlogContent } from './types.js';
+
+const blogContentSchema = z.object( {
+  title: z.string(),
+  url: z.string(),
+  content: z.string(),
+  tokenCount: z.number()
+} );
+
+export const evaluateSignalToNoise = evaluator( {
+  name: 'evaluate_signal_to_noise',
+  description: 'Evaluate the signal-to-noise ratio of blog content',
+  inputSchema: blogContentSchema,
+  fn: async ( input: BlogContent ) => {
+    const { result } = await generateObject( {
+      prompt: 'signal_noise@v1',
+      variables: {
+        title: input.title,
+        content: input.content
+      },
+      schema: z.object( {
+        score: z.number().min( 0 ).max( 100 ).describe( 'Signal-to-noise score 0-100' )
+      } )
+    } );
+
+    return new EvaluationNumberResult( {
+      value: result.score,
+      confidence: 0.85
+    } );
+  }
+} );

package/dist/templates/project/src/workflows/blog_evaluator/prompts/signal_noise@v1.prompt.template

@@ -0,0 +1,28 @@
+---
+provider: anthropic
+model: claude-haiku-4-5
+temperature: 0.3
+maxTokens: 256
+---
+
+<system>
+You are an expert content analyst. Evaluate blog posts for their signal-to-noise ratio.
+</system>
+
+<user>
+Analyze this blog post for signal-to-noise ratio.
+
+Title: \{{ title }}
+
+Content:
+\{{ content }}
+
+Score 0-100 where:
+- 0-20: Mostly filler/noise
+- 21-40: More noise than signal
+- 41-60: Balanced
+- 61-80: Good signal, minimal noise
+- 81-100: Exceptional, dense valuable content
+
+Return only the score.
+</user>

package/dist/templates/project/src/workflows/blog_evaluator/scenarios/paulgraham_hwh.json.template

@@ -0,0 +1,3 @@
+{
+  "url": "https://paulgraham.com/hwh.html"
+}

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

@@ -0,0 +1,27 @@
+import { step, z } from '@output.ai/core';
+import { fetchBlogContent } from '../../shared/clients/jina.js';
+
+const blogContentSchema = z.object( {
+  title: z.string(),
+  url: z.string(),
+  content: z.string(),
+  tokenCount: z.number()
+} );
+
+export const fetchContent = step( {
+  name: 'fetch_blog_content',
+  description: 'Fetch blog content from URL using Jina Reader API',
+  inputSchema: z.object( {
+    url: z.string().url()
+  } ),
+  outputSchema: blogContentSchema,
+  fn: async ( { url } ) => {
+    const response = await fetchBlogContent( url );
+    return {
+      title: response.data.title,
+      url: response.data.url,
+      content: response.data.content,
+      tokenCount: response.data.usage.tokens
+    };
+  }
+} );

package/dist/templates/project/src/workflows/blog_evaluator/types.ts.template

@@ -0,0 +1,24 @@
+import { z } from '@output.ai/core';
+
+export const blogContentSchema = z.object( {
+  title: z.string(),
+  url: z.string(),
+  content: z.string(),
+  tokenCount: z.number()
+} );
+
+export const workflowInputSchema = z.object( {
+  url: z.string().url().describe( 'URL of the blog post to evaluate' )
+} );
+
+export const workflowOutputSchema = z.object( {
+  url: z.string(),
+  title: z.string(),
+  signalToNoiseScore: z.number().min( 0 ).max( 100 ),
+  confidence: z.number().min( 0 ).max( 1 ),
+  summary: z.string()
+} );
+
+export type BlogContent = z.infer<typeof blogContentSchema>;
+export type WorkflowInput = z.infer<typeof workflowInputSchema>;
+export type WorkflowOutput = z.infer<typeof workflowOutputSchema>;

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

@@ -0,0 +1,12 @@
+export function createWorkflowOutput(
+  blogContent: { url: string; title: string },
+  score: number
+) {
+  return {
+    url: blogContent.url,
+    title: blogContent.title,
+    signalToNoiseScore: score,
+    confidence: 0.85,
+    summary: `Signal-to-noise score: ${score}/100`
+  };
+}

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

@@ -0,0 +1,25 @@
+import { workflow, z } from '@output.ai/core';
+import { validateUrl } from '../../shared/utils/url.js';
+import { fetchContent } from './steps.js';
+import { evaluateSignalToNoise } from './evaluators.js';
+import { createWorkflowOutput } from './utils.js';
+import { workflowInputSchema, workflowOutputSchema } from './types.js';
+
+export default workflow( {
+  name: 'blog_evaluator',
+  description: '{{description}}',
+  inputSchema: workflowInputSchema,
+  outputSchema: workflowOutputSchema,
+  fn: async ( input ) => {
+    const validatedUrl = validateUrl( input.url );
+    const blogContent = await fetchContent( { url: validatedUrl } );
+    const evaluation = await evaluateSignalToNoise( blogContent );
+
+    return createWorkflowOutput( blogContent, 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.11",
+  "version": "0.7.12",
   "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
-    }
-  }
-} );