TypeScript SDK

import { createClient } from "@vadyl/sdk";

export const vadyl = createClient({
  apiUrl:  "https://api.vadyl.app/v1",
  token:   process.env.VADYL_TOKEN!,
  tenant:  "acme",
  project: "billing",
  // optional — pin to a feature branch
  branch:  process.env.VADYL_BRANCH,
});

// Typed filter, sort, pagination, and relation expansion
const recent = await vadyl.orders.list({
  filter: {
    status:    { in: ["paid", "fulfilled"] },
    total:     { gt: 100 },
    createdAt: { gte: "now-30d" },
  },
  sort:     [{ field: "createdAt", direction: "desc" }],
  pageSize: 50,
  include:  ["customer", "items.product"],
});

// recent.data: Order[]
// recent.page: { number, size, totalCount?, next?, prev? }
console.log(recent.data.length, recent.page.next);

// Idempotent create — safe to retry
const customer = await vadyl.customers.create((
  { email: "ada@example.com", name: "Ada Lovelace" },
  { idempotencyKey: `signup:${session.id}` },
));

// Update with optimistic concurrency
const updated = await vadyl.customers.update(
  customer.id,
  { name: "Ada L." },
  { ifMatch: customer.concurrencyToken },
);

// Delete (soft delete on entities with that lifecycle)
await vadyl.customers.delete(customer.id);

// WebSocket subscription with the same filter AST as queries
const sub = vadyl.orders.subscribe({
  filter: { status: { eq: "paid" } },
  kinds:  ["created", "updated"],
});

for await (const evt of sub.events()) {
  // evt: { kind, entityId, changedFields, occurredAt }
  // Field NAMES only — never values (defense-in-depth)
  const order = await vadyl.orders.read(evt.entityId);
  console.log("paid:", order);
}

// Start a durable workflow
const run = await vadyl.workflows.fulfillOrder.start({
  orderId: "ord_abc",
});

// Send a signal (e.g. from a webhook)
await vadyl.workflows.fulfillOrder.signal(run.id, "shipped", {
  trackingNumber: "1Z...",
});

// Query run state
const state = await vadyl.workflows.fulfillOrder.query(run.id);

// Run an agent — typed plan IR, capability-aware model routing
const run = await vadyl.agents.SupportAgent.run({
  prompt: "Refund order #12345 due to defect",
  userId: session.userId,
  budget: { maxTokens: 50_000, maxToolCalls: 30 },
});

// Stream the run
for await (const step of run.stream()) {
  console.log(step.kind, step.summary);
}

// Recall memory for an agent
const facts = await vadyl.agents.SupportAgent.memory.recall({
  kind: "preference",
  subject: session.userId,
});

import {
  VadylError,
  VadylAccessDeniedError,
  VadylValidationError,
  VadylConflictError,
  VadylQuotaExceededError,
} from "@vadyl/sdk";

try {
  await vadyl.orders.update(id, { status: "refunded" });
} catch (err) {
  if (err instanceof VadylAccessDeniedError) {
    console.warn(err.reasonCode, err.correlationId);
  } else if (err instanceof VadylConflictError) {
    // optimistic-concurrency mismatch — re-read and retry
  } else if (err instanceof VadylError) {
    console.error(err.code, err.message);
  } else {
    throw err;
  }
}

import { handler } from "@vadyl/sdk";

export default handler.core(async (ctx, input: { orderId: string }) => {
  const order = await ctx.entities.Order.read(input.orderId);

  const charge = await ctx.connections.stripe.createCharge({
    amount: order.total,
    currency: order.currency,
    idempotencyKey: `charge:${order.id}`,
  });

  await ctx.entities.Order.update(order.id, {
    status: "paid",
    chargeId: charge.id,
  });

  await ctx.events.emit("order.paid", { orderId: order.id });
  return { ok: true, chargeId: charge.id };
});