Graph Workflow

import { Agent, BaseNode, Graph, next, output } from "jsr:@vibesjs/sdk";
import { anthropic } from "npm:@ai-sdk/anthropic";

// --- State type ---
type PipelineState = {
  topic: string;
  outline?: string;
  article?: string;
};

// --- Agents ---
const outlineAgent = new Agent({
  model: anthropic("claude-haiku-4-5-20251001"),
  systemPrompt: "Create a concise 3-point outline for a short article. Return only the outline.",
});

const writeAgent = new Agent({
  model: anthropic("claude-sonnet-4-6"),
  systemPrompt: "Write a short 3-paragraph article based on the outline provided.",
});

// --- Graph nodes ---
class OutlineNode extends BaseNode<PipelineState, string> {
  readonly id = "outline";

  async run(state: PipelineState) {
    const result = await outlineAgent.run(`Create an outline for: ${state.topic}`);
    // Transition to the "write" node with updated state
    return next<PipelineState, string>("write", { ...state, outline: result.output });
  }
}

class WriteNode extends BaseNode<PipelineState, string> {
  readonly id = "write";

  async run(state: PipelineState) {
    const result = await writeAgent.run(
      `Outline:\n${state.outline}\n\nWrite the article.`
    );
    // Terminal - return the final article
    return output<PipelineState, string>(result.output);
  }
}

// --- Compose and run ---
const graph = new Graph<PipelineState, string>([
  new OutlineNode(),
  new WriteNode(),
]);

const article = await graph.run({ topic: "The future of AI agents" }, "outline");
console.log(article);

deno run --allow-net --allow-env graph-workflow.ts

// With explicit generics (recommended for type safety)
return next<PipelineState, string>("write", newState);

// Without generics (TypeScript infers the types)
return next("write", newState);

// With explicit generics
return output<PipelineState, string>(result.output);

// Without generics (TypeScript infers from BaseNode type parameters)
return output(result.output);