Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
package main
import (
"context"
"encoding/base64"
"encoding/json"
"flag"
"fmt"
"io"
"log"
"net/http"
"os"
"os/signal"
"strings"
"syscall"
"github.com/byte-sat/three.ws-chat-tools/schema"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/go-chi/cors"
"github.com/nirholas/server/guard"
"github.com/nirholas/server/toolfns"
)
var (
password = flag.String("password", "", "Password for auth. A random token is generated and printed when omitted.")
port = flag.Int("port", 8081, "Port to listen on (loopback only).")
origins = flag.String("origins", "", "Comma-separated extra web origins allowed by CORS (localhost and three.ws are always allowed).")
filesPath = flag.String("files", ".", "Path to the directory we're working with")
)
func main() {
flag.Parse()
if *password == "" {
token, err := guard.NewToken()
if err != nil {
log.Fatal(err)
}
*password = token
fmt.Println("No -password given. Generated token (enter it as the password in Settings):", token)
}
allowedOrigins := append([]string{}, guard.DefaultOrigins...)
for _, o := range strings.Split(*origins, ",") {
if o = strings.TrimSpace(o); o != "" {
allowedOrigins = append(allowedOrigins, o)
}
}
r := chi.NewRouter()
r.Use(cors.Handler(cors.Options{
AllowOriginFunc: func(_ *http.Request, origin string) bool { return guard.OriginAllowed(allowedOrigins, origin) },
AllowedMethods: []string{"GET", "POST", "OPTIONS"},
AllowedHeaders: []string{"Authorization", "Content-Type"},
}))
r.Use(guard.Auth(*password))
r.Use(middleware.RequestID)
r.Use(middleware.RealIP)
r.Use(middleware.Logger)
r.Use(middleware.Recoverer)
th := &ToolHandler{Groups: toolfns.ToolGroups}
r.Get("/tool_schema", th.ToolSchema)
r.Post("/tool", th.InvokeTool)
r.Get("/list_directory", ListDirectory)
r.Get("/read_file", ReadFile)
r.Post("/api/tts/google", TTSHandler)
addr := guard.LoopbackAddr(*port)
fmt.Println("Tool server running at http://" + addr)
httpServer := &http.Server{Addr: addr, Handler: r}
go func() {
if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatal(err)
}
}()
// Signal handling
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt, syscall.SIGTERM)
<-c // Block until a signal is received.
// Graceful shutdown
if err := httpServer.Shutdown(context.Background()); err != nil {
log.Fatal(err)
}
}
func TTSHandler(w http.ResponseWriter, r *http.Request) {
apiKey := os.Getenv("GOOGLE_TTS_API_KEY")
if apiKey == "" {
writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "TTS not configured"})
return
}
body, err := io.ReadAll(r.Body)
if err != nil {
writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
return
}
url := "https://texttospeech.googleapis.com/v1/text:synthesize?key=" + apiKey
resp, err := http.Post(url, "application/json", strings.NewReader(string(body)))
if err != nil {
writeJSON(w, http.StatusBadGateway, map[string]string{"error": err.Error()})
return
}
defer resp.Body.Close()
var result struct {
AudioContent string `json:"audioContent"`
}
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
writeJSON(w, http.StatusBadGateway, map[string]string{"error": err.Error()})
return
}
audio, err := base64.StdEncoding.DecodeString(result.AudioContent)
if err != nil {
writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()})
return
}
w.Header().Set("Content-Type", "audio/mpeg")
w.WriteHeader(http.StatusOK)
w.Write(audio)
}
func writeJSON(w http.ResponseWriter, status int, v any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(v)
}
type ToolHandler struct {
Groups []*toolfns.Group
}
func (tr *ToolHandler) ToolSchema(w http.ResponseWriter, r *http.Request) {
type encodedGroup struct {
Name string `json:"name"`
Schema []schema.Function `json:"schema"`
}
var encodedGroups []encodedGroup
for _, group := range tr.Groups {
encodedGroups = append(encodedGroups, encodedGroup{
Name: group.Name,
Schema: group.Repo.Schema(),
})
}
writeJSON(w, http.StatusOK, encodedGroups)
}
func (tr *ToolHandler) InvokeTool(w http.ResponseWriter, r *http.Request) {
var call struct {
ChatID string `json:"chat_id"`
Name string `json:"name"`
Args map[string]any `json:"arguments"`
}
if err := json.NewDecoder(r.Body).Decode(&call); err != nil {
writeJSON(w, http.StatusBadRequest, map[string]any{"error": err.Error()})
return
}
for _, group := range tr.Groups {
out, err := group.Repo.Invoke(nil, call.Name, call.Args)
if err != nil {
if strings.HasPrefix(err.Error(), "tool not found") {
continue
}
writeJSON(w, http.StatusInternalServerError, map[string]any{"error": err.Error()})
return
}
writeJSON(w, http.StatusOK, out)
return
}
writeJSON(w, http.StatusNotFound, map[string]any{"error": "tool not found: " + call.Name})
}