Building Workflows

type StrictReviewer struct{}

func (w *StrictReviewer) Name() string        { return "strict-reviewer" }
func (w *StrictReviewer) Description() string { return "Review a patch with a hard review contract" }

func (w *StrictReviewer) SystemPrompt() string {
    return `You are a strict software reviewer.
Only report concrete defects, risks, or missing tests.
Do not praise code. Do not speculate without evidence.`
}

func (w *StrictReviewer) Run(ctx context.Context, session *sdk.Session) error {
    _, err := session.SubmitMessage(ctx, "Review the current repository diff.")
    return err
}

type DailyDigest struct {
    Topic string
}

func (w *DailyDigest) Name() string        { return "daily-digest" }
func (w *DailyDigest) Description() string { return "Produce a concise digest for one topic" }

func (w *DailyDigest) Run(ctx context.Context, session *sdk.Session) error {
    prompt := fmt.Sprintf(
        "Produce a markdown digest about %s with the 5 most relevant updates and why they matter.",
        w.Topic,
    )

    _, err := session.SubmitMessage(ctx, prompt)
    return err
}

func main() {
    ctx := context.Background()

    runnerCfg, err := automation.RunnerConfigFromEnv("anthropic:claude-sonnet-4-6")
    if err != nil {
        log.Fatal(err)
    }

    executor, err := automation.NewExecutor(automation.ExecutorConfig{
        RunnerConfig: runnerCfg,
        Sinks: []automation.Sink{
            &automation.StdoutSink{},
        },
    })
    if err != nil {
        log.Fatal(err)
    }
    defer executor.Close()

    opts := automation.DefaultOptions().WithTimeout(15 * time.Minute)
    result, err := executor.Run(ctx, &DailyDigest{Topic: "open-source Go agents"}, opts)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(result.Output)
}

state, err := automation.NewFileStateStore("./var/automation-state")
if err != nil {
    log.Fatal(err)
}

executor, err := automation.NewExecutor(automation.ExecutorConfig{
    RunnerConfig: runnerCfg,
    Middleware: []automation.Middleware{
        automation.WithLogging(nil),
        automation.WithTimeout(20 * time.Minute),
        automation.WithRetry(2, 10 * time.Second),
        automation.WithMetrics(func(result automation.Result) {
            fmt.Printf("workflow=%s success=%v duration=%s\n",
                result.WorkflowName,
                result.Success(),
                result.Duration.Round(time.Second),
            )
        }),
    },
    Sinks: []automation.Sink{
        &automation.StdoutSink{},
        &automation.FileSink{Dir: "./var/workflow-runs", Format: "json"},
        automation.NewWebhookSink("https://ops.example.com/hooks/seshat"),
    },
    State: state,
})
if err != nil {
    log.Fatal(err)
}

executor, err := automation.NewExecutor(automation.ExecutorConfig{
    RunnerConfig: runnerCfg,
    Middleware: []automation.Middleware{
        automation.WithLogging(nil),
        automation.WithRetry(3, 15 * time.Second),
    },
    Sinks: []automation.Sink{
        &automation.StdoutSink{},
        &automation.FileSink{Dir: "./var/digests"},
    },
    State: state,
})
if err != nil {
    log.Fatal(err)
}
defer executor.Close()

scheduler := automation.NewScheduler(executor).
    Add(
        &DailyDigest{Topic: "AI agents and orchestration"},
        automation.MustCron("0 */6 * * *"),
        automation.DefaultOptions().WithTimeout(20*time.Minute),
    ).
    Add(
        &DailyDigest{Topic: "Go runtime engineering"},
        automation.Every(12*time.Hour),
        automation.DefaultOptions().WithRetry(2, 20*time.Second),
    )

for _, item := range scheduler.Next() {
    fmt.Printf("%s -> %s (%s)\n", item.WorkflowName, item.NextRun.Format(time.RFC3339), item.Schedule)
}

log.Fatal(scheduler.Run(ctx))

client, err := sdk.NewClient(&sdk.ClientConfig{
    Model: sdk.ModelIdentifier{
        Provider: sdk.APIProviderAnthropic,
        Model:    "claude-sonnet-4-20250514",
    },
    APIKey:          os.Getenv("ANTHROPIC_API_KEY"),
    PermissionMode:  sdk.PermissionModeOnRequest,
    PersistSessions: true,
    EnableMemory:    true,
})
if err != nil {
    log.Fatal(err)
}
defer client.Close()

session, err := client.CreateSession(ctx)
if err != nil {
    log.Fatal(err)
}
defer session.Close()

session.SetAppendSystemPrompt("You are the billing operations agent for this company.")
session.SetPermissionMode(sdk.PermissionModeOnRequest)

_, err = session.SubmitMessage(ctx, "Investigate the invoice mismatch and ask for approval before changing files.")
if err != nil {
    log.Fatal(err)
}