HTTP / PubSub / Cron / S3
                                  |
                          +-------v--------+
                          |    Gateway     |
                          | (api.hanzo.ai) |
                          +-------+--------+
                                  |
                    +-------------v--------------+
                    |     Function Controller     |
                    |  scheduling, scaling, routing|
                    +------+--------+--------+----+
                           |        |        |
                    +------v-+ +---v----+ +-v------+
                    | Worker | | Worker | | Worker |
                    | Pod 1  | | Pod 2  | | Pod N  |
                    +--------+ +--------+ +--------+
                         |          |          |
                    +----v----------v----------v----+
                    |        Hanzo Platform          |
                    |  KMS  IAM  PubSub  O11y  SQL  |
                    +-------------------------------+

from hanzo.functions import function, Context

@function(trigger="pubsub", subject="orders.created")
async def on_order(ctx: Context, event: dict) -> dict:
    order_id = event["id"]

    # Access KMS secrets via context
    api_key = ctx.secret("PAYMENT_API_KEY")

    # Call other services with scoped IAM identity
    result = await ctx.call("payment.charge", {
        "order_id": order_id,
        "amount": event["total"],
    })

    return {"status": "processed", "charge_id": result["id"]}

package main

import (
    "context"
    "github.com/hanzoai/functions-go"
)

func HandleOrder(ctx context.Context, event functions.Event) (*functions.Response, error) {
    var order Order
    if err := event.Decode(&order); err != nil {
        return nil, err
    }

    apiKey, err := functions.Secret(ctx, "PAYMENT_API_KEY")
    if err != nil {
        return nil, err
    }

    // Process order...
    return &functions.Response{Status: "processed"}, nil
}

func main() {
    functions.Register("on-order", HandleOrder,
        functions.WithTrigger("pubsub", "orders.created"),
        functions.WithConcurrency(10),
    )
    functions.Start()
}

import { defineFunction } from '@hanzo/functions';

export default defineFunction({
  trigger: { type: 'http', method: 'POST', path: '/process' },
  concurrency: 50,

  async handler(ctx, req) {
    const apiKey = await ctx.secret('PAYMENT_API_KEY');

    const result = await fetch('https://api.payment.com/charge', {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${apiKey}` },
      body: JSON.stringify(req.body),
    });

    return { status: 'ok', data: await result.json() };
  },
});

# Deploy a function from source
hanzo fn deploy --name on-order \
  --trigger pubsub:orders.created \
  --runtime python3.12 \
  --source ./handler.py \
  --secrets PAYMENT_API_KEY

# Deploy from a container image
hanzo fn deploy --name processor \
  --trigger http:POST:/process \
  --image ghcr.io/myorg/processor:v1.2.0 \
  --concurrency 50 \
  --min-scale 1

# List deployed functions
hanzo fn list

# View logs
hanzo fn logs on-order --follow

# Invoke directly
hanzo fn invoke on-order --data '{"id":"order-123","total":59.99}'

# hanzo-functions.yaml
functions:
  - name: on-order
    runtime: python3.12
    handler: handler.on_order
    trigger:
      type: pubsub
      subject: orders.created
    environment:
      ORDER_SERVICE_URL: https://api.hanzo.ai/v1/orders
    secrets:
      - PAYMENT_API_KEY
    resources:
      memory: 256Mi
      cpu: 100m
    scaling:
      min: 0
      max: 100
      concurrency: 10
      cooldown: 300s