Scope

from agentica import agentic
from dataclasses import dataclass
from typing import Literal

@dataclass
class PaymentRequest:
    amount: float
    currency: Literal["USD", "EUR", "GBP"]
    customer_email: str

    def __post_init__(self):
        if self.amount <= 0:
            raise ValueError("Amount must be positive")
        if "@" not in self.customer_email:
            raise ValueError("Invalid email address")

@agentic(PaymentRequest)
async def extract_payment_info(invoice_text: str) -> PaymentRequest:
    """Parse invoice and return a validated PaymentRequest"""
    ...

import { agentic } from '@symbolica/agentica';

type Currency = 'USD' | 'EUR' | 'GBP';

class PaymentRequest {
  amount: number;
  currency: Currency;
  customerEmail: string;

  constructor(amount: number, currency: Currency, customerEmail: string) {
    if (amount <= 0) {
      throw new Error("Amount must be positive");
    }
    if (!customerEmail.includes("@")) {
      throw new Error("Invalid email address");
    }
    this.amount = amount;
    this.currency = currency;
    this.customerEmail = customerEmail;
  }
}

async function extractPaymentInfo(invoiceText: string): Promise<PaymentRequest> {
  return agentic<PaymentRequest>(
    "Parse invoice and return a validated PaymentRequest",
    { invoiceText, PaymentRequest }
  );
}

from agentica import agentic

# Your existing classes
class OrderResult: ...
class CustomerTier: ...
# Your existing functions
def get_customer_tier(name: str) -> CustomerTier: ...
def calculate_price(tier: CustomerTier, base_price: float) -> float: ...

@agentic(get_customer_tier, calculate_price)
async def process_order(customer_name: str, base_price: float) -> OrderResult:
    """Look up customer tier, calculate price, and create order"""
    ...

import { agentic } from '@symbolica/agentica';

// Your existing classes
class OrderResult { ... }
class CustomerTier { ... }
// Your existing functions
function getCustomerTier(name: string): CustomerTier { ... }
function calculateDiscount(tier: CustomerTier): number { ... }

async function processOrder(customerName: string, basePrice: number): Promise<OrderResult> {
  return agentic<OrderResult>(
    "Look up customer tier, calculate price, and create order",
    { customerName, basePrice, getCustomerTier, calculateDiscount }
  );
}

from agentica import agentic
import numpy as np
import sqlite3

db = sqlite3.connect("inventory.db")

# Stateful resources that agentic function can interact with
resources = dict(
  db=db,
  cache=RedisClient(url="redis://localhost"),
  current_user=User(id="123", tier="gold")
)

# Pass entire modules and live connections directly
@agentic(np, scope=resources)
async def reorder_check(threshold: float) -> list[str]:
    """Query the products table for items whose stock is below
    `threshold` standard deviations from the mean, and return
    their names."""
    ...

low_stock = await reorder_check(1.5)

import { agentic } from '@symbolica/agentica';

// Your existing class
class Product { ... }
// Stateful objects that can't be serialized
const dbConnection = new DatabaseConnection({ host: "prod-db" });
const cache = new RedisClient({ url: "redis://localhost" });
const currentUser = new User({ id: "123", tier: "gold" });

async function getPersonalizedRecommendations(): Promise<Product[]> {
  return agentic<Product[]>(
    "Query database for user's history, check cache, and generate recommendations",
    { dbConnection, cache, currentUser }
  );
}