APIs that work everywhere.

from telepact import FunctionRouter, Message, Server, TelepactSchema

schema = TelepactSchema.from_directory('./api')

async def divide(function_name: str, request_message: Message) -> Message:
    args = request_message.body[function_name]
    x, y = args['x'], args['y']
    if y == 0:
        return Message({}, {'ErrorCannotDivideByZero': {}})
    return Message({}, {'Ok_': {'result': x / y}})

options = Server.Options()
options.auth_required = False
function_router = FunctionRouter({'fn.divide': divide})
server = Server(schema, function_router, options)

# Plug into any framework — Starlette, Flask, FastAPI...
async def http_handler(request):
    response = await server.process(await request.body())
    return Response(content=response.bytes)

// No Telepact library required

const request = [
  {},
  {
    "fn.divide": {
      x: 10,
      y: 2,
    },
  },
];

const response = await fetch("/api/telepact", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify(request),
});

const [headers, body] = await response.json();

if (body.Ok_) {
  console.log(body.Ok_.result);
} else {
  console.error(headers, body);
}

import io.github.telepact.Client;
import io.github.telepact.Message;
import io.github.telepact.Serializer;

BiFunction<Message, Serializer, Future<Message>> adapter = (message, serializer) ->
    CompletableFuture.supplyAsync(() -> {
        var requestBytes = serializer.serialize(message);
        var responseBytes = transport.send(requestBytes);
        return serializer.deserialize(responseBytes);
    });

var client = new Client(adapter, new Client.Options());
var request = new Message(
    Map.of(),
    Map.of("fn.divide", Map.of("x", 10, "y", 2))
);
var response = client.request(request);

if ("Ok_".equals(response.getBodyTarget())) {
    System.out.println(response.getBodyPayload().get("result"));
}

// First generate bindings from the schema:
// telepact codegen --schema-dir ./api --lang go --package calcclient --out ./gen

package main

import (
    "context"
    "log"

    calcclient "example.com/project/gen"
    telepact "github.com/telepact/telepact/lib/go"
)

func main() {
    adapter := func(ctx context.Context, request telepact.Message, serializer *telepact.Serializer) (telepact.Message, error) {
        requestBytes, err := serializer.Serialize(request)
        if err != nil {
            return telepact.Message{}, err
        }

        responseBytes, err := transport.Send(ctx, requestBytes)
        if err != nil {
            return telepact.Message{}, err
        }

        return serializer.Deserialize(responseBytes)
    }

    client, err := calcclient.NewClient(adapter, telepact.NewClientOptions())
    if err != nil {
        log.Fatal(err)
    }

    response, err := client.Divide(context.Background(), calcclient.FnDivideArgs{
        X: 10,
        Y: 2,
    })
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("result=%v", response.Ok.Result)
}