Skip to content

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.

4.9 KB
Raw Blame
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})
}