C# SDK

using Vadyl.Client;

var vadyl = new VadylClient(new VadylClientOptions
{
    ApiUrl  = "https://api.vadyl.app/v1",
    Token   = Environment.GetEnvironmentVariable("VADYL_TOKEN"),
    Tenant  = "acme",
    Project = "billing",
    // optional — pin to a feature branch
    Branch  = Environment.GetEnvironmentVariable("VADYL_BRANCH"),
});

// Or with DI:
//   services.AddVadylClient(opts => { opts.ApiUrl = "..."; ... });
//   IVadylClient vadyl = sp.GetRequiredService<IVadylClient>();

// Typed filter, sort, pagination, and relation expansion
var recent = await vadyl.Orders.ListAsync(new ListOrderRequest
{
    Filter = new OrderFilter
    {
        Status    = OrderStatus.Paid | OrderStatus.Fulfilled,
        Total     = OrderFilter.Gt(100m),
        CreatedAt = OrderFilter.SinceNow("-30d"),
    },
    Sort     = [new Sort("createdAt", SortDir.Desc)],
    PageSize = 50,
    Include  = ["customer", "items.product"],
});

// recent.Data: IReadOnlyList<Order>
// recent.Page: { Number, Size, TotalCount?, Next?, Prev? }
Console.WriteLine($"{recent.Data.Count} orders, next: {recent.Page.Next}");

// Idempotent create — safe to retry
var customer = await vadyl.Customers.CreateAsync(
    new CustomerCreateInput { Email = "ada@example.com", Name = "Ada Lovelace" },
    idempotencyKey: $"signup:{session.Id}");

// Update with optimistic concurrency
var updated = await vadyl.Customers.UpdateAsync(
    customer.Id,
    new CustomerUpdateInput { Name = "Ada L." },
    ifMatch: customer.ConcurrencyToken);

// Delete (soft-delete on entities with that lifecycle)
await vadyl.Customers.DeleteAsync(customer.Id);

// IAsyncEnumerable streaming subscription with the same filter AST as queries
await foreach (var evt in vadyl.Orders
    .Subscribe(
        new OrderFilter { Status = OrderStatus.Paid },
        kinds: [ChangeKind.Created, ChangeKind.Updated])
    .ReadAllAsync(ct))
{
    // evt.Kind, evt.EntityId, evt.ChangedFields, evt.OccurredAt
    // Field NAMES only — re-read for values
    var order = await vadyl.Orders.ReadAsync(evt.EntityId, ct);
    Console.WriteLine($"paid: {order.Id}");
}

// Start a durable workflow
var run = await vadyl.Workflows.FulfillOrder.StartAsync(
    new FulfillOrderInput { OrderId = "ord_abc" });

// Send a signal (e.g. from a webhook)
await vadyl.Workflows.FulfillOrder.SignalAsync(
    run.Id,
    "shipped",
    new { TrackingNumber = "1Z..." });

// Query run state
var state = await vadyl.Workflows.FulfillOrder.QueryAsync(run.Id);

// Run an agent — typed plan IR, capability-aware model routing
var run = await vadyl.Agents.SupportAgent.RunAsync(new AgentRunInput
{
    Prompt  = "Refund order #12345 due to defect",
    UserId  = session.UserId,
    Budget  = new AgentBudget { MaxTokens = 50_000, MaxToolCalls = 30 },
});

// Stream the run
await foreach (var step in run.StreamAsync(ct))
    Console.WriteLine($"{step.Kind}: {step.Summary}");

// Recall memory
var facts = await vadyl.Agents.SupportAgent.Memory.RecallAsync(new RecallRequest
{
    Kind    = "preference",
    Subject = session.UserId,
});

try
{
    await vadyl.Orders.UpdateAsync(id, new OrderUpdateInput { Status = OrderStatus.Refunded });
}
catch (VadylAccessDeniedException ex)
{
    Console.WriteLine($"{ex.ReasonCode} ({ex.CorrelationId})");
}
catch (VadylConflictException)
{
    // optimistic-concurrency mismatch — re-read and retry
}
catch (VadylValidationException ex)
{
    foreach (var e in ex.FieldErrors) Console.WriteLine($"{e.Field}: {e.ReasonCode}");
}
catch (VadylException ex)
{
    Console.WriteLine($"{ex.Code}: {ex.Message}");
}

using Vadyl.Authoring;

public class ChargeOrderHandler : ICoreHandler<ChargeInput, ChargeResult>
{
    public async Task<ChargeResult> InvokeAsync(IRuntimeContext ctx, ChargeInput input, CancellationToken ct)
    {
        var order  = await ctx.Entities.Order.ReadAsync(input.OrderId, ct);
        var charge = await ctx.Connections.Stripe.CreateChargeAsync(new StripeChargeInput
        {
            Amount         = order.Total,
            Currency       = order.Currency,
            IdempotencyKey = $"charge:{order.Id}",
        }, ct);

        await ctx.Entities.Order.UpdateAsync(order.Id, new OrderUpdate
        {
            Status   = OrderStatus.Paid,
            ChargeId = charge.Id,
        }, ct);

        await ctx.Events.EmitAsync("order.paid", new { OrderId = order.Id }, ct);
        return new ChargeResult(true, charge.Id);
    }
}