feat: add tools/ai/wasmtrans

Updates #1454

Signed-off-by: Aofei Sheng <[email protected]>

Author: aofei

tools/ai/wasmtrans/promise.go

@@ -0,0 +1,59 @@
+//go:build js && wasm
+
+package wasmtrans
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"syscall/js"
+)
+
+// awaitPromise waits for a JavaScript Promise to resolve or reject.
+func awaitPromise(ctx context.Context, promise js.Value) (js.Value, error) {
+	if promise.IsUndefined() || promise.IsNull() {
+		return js.Undefined(), errors.New("promise is undefined or null")
+	}
+	if promise.Type() != js.TypeObject || promise.Get("then").Type() != js.TypeFunction {
+		return js.Undefined(), errors.New("value is not a Promise")
+	}
+
+	resultChan := make(chan js.Value, 1)
+	then := js.FuncOf(func(this js.Value, args []js.Value) any {
+		result := js.Undefined()
+		if len(args) > 0 {
+			result = args[0]
+		}
+		resultChan <- result
+		return nil
+	})
+	defer then.Release()
+
+	errChan := make(chan error, 1)
+	catch := js.FuncOf(func(this js.Value, args []js.Value) any {
+		errMsg := "promise rejected"
+		if len(args) > 0 {
+			errVal := args[0]
+			if errVal.Type() == js.TypeObject && errVal.Get("message").Type() == js.TypeString {
+				errMsg = fmt.Sprintf("promise rejected: %s", errVal.Get("message"))
+			} else if errVal.Type() == js.TypeString {
+				errMsg = fmt.Sprintf("promise rejected: %s", errVal)
+			} else {
+				errMsg = fmt.Sprintf("promise rejected: %v", errVal)
+			}
+		}
+		errChan <- errors.New(errMsg)
+		return nil
+	})
+	defer catch.Release()
+
+	promise.Call("then", then).Call("catch", catch)
+	select {
+	case result := <-resultChan:
+		return result, nil
+	case err := <-errChan:
+		return js.Undefined(), err
+	case <-ctx.Done():
+		return js.Undefined(), fmt.Errorf("context cancelled while waiting for promise: %w", ctx.Err())
+	}
+}

tools/ai/wasmtrans/wasmtrans.go

@@ -0,0 +1,116 @@
+//go:build js && wasm
+
+// Package wasmtrans provides a Transport implementation for AI interactions
+// within a WebAssembly (Wasm) environment, typically running in a browser.
+package wasmtrans
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"syscall/js"
+
+	"github.com/goplus/builder/tools/ai"
+)
+
+// wasmTransport implements [ai.Transport] using JavaScript's fetch API.
+type wasmTransport struct {
+	// endpoint is the URL for the AI interaction API.
+	endpoint string
+
+	// tokenProvider is a function that returns the auth token (without "Bearer ").
+	// It's called before each request. If it returns "", no auth header is sent.
+	tokenProvider func() string
+}
+
+// Option is a function type for configuring the [wasmTransport].
+type Option func(*wasmTransport)
+
+// WithEndpoint sets a custom endpoint for the AI interaction API.
+func WithEndpoint(endpoint string) Option {
+	return func(t *wasmTransport) {
+		t.endpoint = endpoint
+	}
+}
+
+// WithTokenProvider sets a function that provides the Bearer token for
+// Authorization. The provider function will be called before each request to
+// get the current token. If the provider returns an empty string, no
+// Authorization header will be sent.
+func WithTokenProvider(provider func() string) Option {
+	return func(t *wasmTransport) {
+		t.tokenProvider = provider
+	}
+}
+
+// New creates a new [ai.Transport] suitable for Wasm environments. It uses
+// JavaScript interop (syscall/js) to make network requests. By default, it
+// uses "/api/ai/interaction" endpoint and sends no Authorization token.
+func New(opts ...Option) ai.Transport {
+	t := &wasmTransport{
+		endpoint:      "/api/ai/interaction",
+		tokenProvider: func() string { return "" },
+	}
+	for _, opt := range opts {
+		opt(t)
+	}
+	return t
+}
+
+// Interact implements [ai.Transport].
+func (t *wasmTransport) Interact(ctx context.Context, req ai.Request) (ai.Response, error) {
+	reqBody, err := json.Marshal(req)
+	if err != nil {
+		return ai.Response{}, fmt.Errorf("failed to marshal request: %w", err)
+	}
+
+	headers := map[string]any{
+		"Content-Type": "application/json",
+	}
+	if t.tokenProvider != nil {
+		if token := t.tokenProvider(); token != "" {
+			headers["Authorization"] = "Bearer " + token
+		}
+	}
+
+	jsAbortController := js.Global().Get("AbortController").New()
+	defer context.AfterFunc(ctx, func() {
+		jsAbortController.Call("abort")
+	})()
+	jsAbortSignal := jsAbortController.Get("signal")
+
+	jsResp, err := awaitPromise(ctx, js.Global().Call("fetch", t.endpoint+"/turn", map[string]any{
+		"method":  "POST",
+		"headers": headers,
+		"body":    string(reqBody),
+		"signal":  jsAbortSignal,
+	}))
+	if err != nil {
+		return ai.Response{}, fmt.Errorf("failed to fetch: %w", err)
+	}
+
+	if !jsResp.Get("ok").Bool() {
+		status := jsResp.Get("status").Int()
+		statusText := jsResp.Get("statusText").String()
+
+		bodyPromise := jsResp.Call("text")
+		bodyTextVal, bodyErr := awaitPromise(ctx, bodyPromise)
+		if bodyErr != nil {
+			return ai.Response{}, fmt.Errorf("failed to fetch with status %d %s (and failed to read error body: %w)", status, statusText, bodyErr)
+		}
+
+		bodyText := bodyTextVal.String()
+		return ai.Response{}, fmt.Errorf("failed to fetch with status %d %s: %s", status, statusText, bodyText)
+	}
+	jsJSON, err := awaitPromise(ctx, jsResp.Call("json"))
+	if err != nil {
+		return ai.Response{}, fmt.Errorf("failed to process json response: %w", err)
+	}
+	jsonString := js.Global().Get("JSON").Call("stringify", jsJSON).String()
+
+	var aiResp ai.Response
+	if err := json.Unmarshal([]byte(jsonString), &aiResp); err != nil {
+		return ai.Response{}, fmt.Errorf("failed to unmarshal response json: %w", err)
+	}
+	return aiResp, nil
+}