Go SDK

package main

import (
    "context"
    "log"
    "os"

    sdk "go.vadyl.dev/sdk"
)

func main() {
    vadyl := sdk.New(sdk.Options{
        APIURL:  "https://api.vadyl.app/v1",
        Token:   os.Getenv("VADYL_TOKEN"),
        Tenant:  "acme",
        Project: "billing",
        Branch:  os.Getenv("VADYL_BRANCH"), // optional
    })

    ctx := context.Background()
    me, err := vadyl.Identity.Me(ctx)
    if err != nil { log.Fatal(err) }
    _ = me
}

// Typed filter, sort, pagination, and relation expansion
recent, err := vadyl.Orders.List(ctx, sdk.OrderListReq{
    Filter: sdk.OrderFilter{
        Status:    sdk.In("paid", "fulfilled"),
        Total:     sdk.Gt(100),
        CreatedAt: sdk.Gte("now-30d"),
    },
    Sort:     []sdk.Sort{{Field: "createdAt", Direction: "desc"}},
    PageSize: 50,
    Include:  []string{"customer", "items.product"},
})
if err != nil { return err }

// recent.Data: []Order
// recent.Page: { Number, Size, TotalCount, Next, Prev }
fmt.Printf("%d orders, next: %s\n", len(recent.Data), recent.Page.Next)

// Idempotent create — safe to retry
customer, err := vadyl.Customers.Create(ctx, sdk.CustomerCreateInput{
    Email: "ada@example.com",
    Name:  "Ada Lovelace",
}, sdk.WithIdempotencyKey(fmt.Sprintf("signup:%s", session.ID)))
if err != nil { return err }

// Update with optimistic concurrency
updated, err := vadyl.Customers.Update(ctx, customer.ID,
    sdk.CustomerUpdate{Name: sdk.Ptr("Ada L.")},
    sdk.WithIfMatch(customer.ConcurrencyToken))

// Delete (soft-delete on entities with that lifecycle)
err = vadyl.Customers.Delete(ctx, customer.ID)

// Channel-based subscription with the same filter AST as queries
sub, err := vadyl.Orders.Subscribe(ctx,
    sdk.OrderFilter{Status: sdk.Eq("paid")},
    sdk.WithKinds(sdk.KindCreated, sdk.KindUpdated))
if err != nil { return err }
defer sub.Close()

for evt := range sub.Events() {
    // evt.Kind, evt.EntityID, evt.ChangedFields, evt.OccurredAt
    // Field NAMES only — re-read for values
    order, err := vadyl.Orders.Read(ctx, evt.EntityID)
    if err != nil { continue }
    log.Printf("paid: %v\n", order)
}

// Start a durable workflow
run, err := vadyl.Workflows.FulfillOrder.Start(ctx, sdk.FulfillOrderInput{
    OrderID: "ord_abc",
})
if err != nil { return err }

// Send a signal (e.g. from a webhook)
err = vadyl.Workflows.FulfillOrder.Signal(ctx, run.ID, "shipped",
    map[string]any{"trackingNumber": "1Z..."})

// Query run state
state, err := vadyl.Workflows.FulfillOrder.Query(ctx, run.ID)

// Run an agent — typed plan IR, capability-aware model routing
run, err := vadyl.Agents.SupportAgent.Run(ctx, sdk.AgentRunInput{
    Prompt: "Refund order #12345 due to defect",
    UserID: session.UserID,
    Budget: sdk.AgentBudget{MaxTokens: 50000, MaxToolCalls: 30},
})
if err != nil { return err }

// Stream the run
for step := range run.Stream(ctx) {
    log.Printf("%s: %s\n", step.Kind, step.Summary)
}

// Recall memory
facts, err := vadyl.Agents.SupportAgent.Memory.Recall(ctx, sdk.RecallReq{
    Kind:    "preference",
    Subject: session.UserID,
})

import "errors"

_, err := vadyl.Orders.Update(ctx, id,
    sdk.OrderUpdate{Status: sdk.Ptr("refunded")})

var (
    accessErr   *sdk.AccessDeniedError
    conflictErr *sdk.ConflictError
    validErr    *sdk.ValidationError
    quotaErr    *sdk.QuotaExceededError
)

switch {
case errors.As(err, &accessErr):
    log.Printf("denied: %s (%s)", accessErr.ReasonCode, accessErr.CorrelationID)
case errors.As(err, &conflictErr):
    // optimistic-concurrency mismatch — re-read and retry
case errors.As(err, &validErr):
    for _, fe := range validErr.FieldErrors { log.Printf("%s: %s", fe.Field, fe.ReasonCode) }
case errors.As(err, &quotaErr):
    log.Printf("quota %s exceeded; resets %s", quotaErr.Kind, quotaErr.ResetAt)
}

package orders

import "go.vadyl.dev/sdk/handler"

type ChargeInput  struct{ OrderID string `json:"orderId"` }
type ChargeResult struct{ OK bool; ChargeID string }

var Charge = handler.Core(func(ctx *handler.Ctx, in ChargeInput) (ChargeResult, error) {
    order, err := ctx.Entities.Order.Read(in.OrderID)
    if err != nil { return ChargeResult{}, err }

    charge, err := ctx.Connections.Stripe.CreateCharge(handler.StripeChargeInput{
        Amount:         order.Total,
        Currency:       order.Currency,
        IdempotencyKey: fmt.Sprintf("charge:%s", order.ID),
    })
    if err != nil { return ChargeResult{}, err }

    if err := ctx.Entities.Order.Update(order.ID, handler.OrderUpdate{
        Status:   handler.Ptr("paid"),
        ChargeID: handler.Ptr(charge.ID),
    }); err != nil { return ChargeResult{}, err }

    _ = ctx.Events.Emit("order.paid", map[string]any{"orderId": order.ID})
    return ChargeResult{OK: true, ChargeID: charge.ID}, nil
})