Ship Functions.
Agents Trust Them.

// functionfly.jsonc
// {"name": "forward-email", "runtime": "go", "capabilities": ["email:send"]\}

package functionfly

import (
  "context"
  "encoding/json"
  fly "github.com/functionfly/functionfly/sdk/go"
)

type Input struct {
  To      string `json:"to"`
  Subject string `json:"subject"`
  Body    string `json:"body"`
}

func Handle(ctx context.Context, input Input) (any, error) {
  return map[string]any{
    "sent":   true,
    "to":     input.To,
    "msg_id": ctx.Value(fly.TraceIDKey),
  }, nil
}

// functionfly.jsonc
// {"name": "mnemonic-check", "runtime": "wasm", "capabilities": []\}

use functionfly::prelude::*;

#[fnfly::function]
pub fn validate_mnemonic(phrase: String) -> MnemonicResult {
  let words: Vec<String> = phrase.split_whitespace().map(String::from).collect();
  MnemonicResult {
    valid: words.len() == 24 && words.iter().all(is_valid_word),
    word_count: words.len() as u32,
  }
}

// functionfly.config.jsonc
// {"name": "scrape-metadata", "runtime": "node20", "capabilities": ["fetch:read"]\}

export async function handle(input) {
  const { url } = input;
  const res = await fetch(url);
  const html = await res.text();
  return {
    title: extract("<title>(.*?)</title>", html),
    description: extract(`<meta name="description" content="(.*?)">`, html),
  };
}

// functionfly.config.jsonc
// {"name": "raroc-calculate", "runtime": "node20", "capabilities": ["kv:read", "kv:write"]\}

import { kv } from "functionfly";

interface RAROCInput {
  pd: number;
  lgd: number;
  ead: number;
  corr: number;
}

export async function handle(input: RAROCInput): Promise<RAROCResult> {
  const key = `raroc:${hash(input)}`;
  const cached = await kv.get(key);
  if (cached) return JSON.parse(cached);
  const result = computeRAROC(input);
  await kv.set(key, JSON.stringify(result), { ttl: 3600 });
  return result;
}