@pi-in-go/pigpen-pi-typesafe 0.1.0

package/libs/typesafe/libraries/typesafe/api_response_test.go

@@ -0,0 +1,113 @@
+package typesafe
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+)
+
+func clientWith(t *testing.T, resp func() *http.Response) (*Client, *mockDoer) {
+	m := always(resp)
+	return newClient(t, m, func(c *Config) { c.Retry = RetryOverrides{MaxRetries: Ptr(0)} }), m
+}
+
+func TestAPIPromise_IsReturnedFromClientMethodsAndIsARealPromise(t *testing.T) {
+	skipTwin(t, "JavaScript Promise subclass; Go returns (value, error) and the *Response types are TestAPIPromise_WithResponse*",
+		"api-promise.test.ts | APIPromise is returned from client methods and is a real Promise")
+}
+
+func TestAPIPromise_AwaitsToTheParsedData(t *testing.T) {
+	twin(t, "api-promise.test.ts | APIPromise awaits to the parsed data")
+	c, _ := clientWith(t, func() *http.Response { return textResp(200, modelsBody, "content-type", "application/json") })
+	got, err := c.Models().List(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, got, modelCards)
+}
+
+func TestAPIPromise_WithResponseReturnsDataResponseAndRequestID(t *testing.T) {
+	twin(t, "api-promise.test.ts | APIPromise withResponse() returns data, response, and requestId")
+	c, _ := clientWith(t, func() *http.Response {
+		return textResp(200, modelsBody, "content-type", "application/json", "x-typesafe-request-id", "req_abc")
+	})
+	res, err := c.Models().ListWithResponse(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, res.Data, modelCards)
+	eq(t, res.Status, 200)
+	eq(t, res.Header.Get("x-typesafe-request-id"), "req_abc")
+	eq(t, res.RequestID, "req_abc")
+}
+
+func TestAPIPromise_WithResponseHasUndefinedRequestIDWhenTheHeaderIsAbsent(t *testing.T) {
+	twin(t, "api-promise.test.ts | APIPromise withResponse() has undefined requestId when the header is absent")
+	c, _ := clientWith(t, func() *http.Response { return textResp(200, modelsBody, "content-type", "application/json") })
+	res, err := c.Models().ListWithResponse(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, res.RequestID, "")
+}
+
+func TestAPIPromise_AsResponseReturnsTheRawResponseWithAnUnconsumedBody(t *testing.T) {
+	// Adapted: the raw response carries the buffered body bytes.
+	twin(t, "api-promise.test.ts | APIPromise asResponse() returns the raw Response with an unconsumed body")
+	c, _ := clientWith(t, func() *http.Response { return textResp(200, modelsBody, "content-type", "application/json") })
+	raw, err := c.Models().ListRaw(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, raw.Status, 200)
+	var got map[string]any
+	noErr(t, json.Unmarshal(raw.Body, &got))
+	eq(t, len(got["models"].([]any)), 1)
+}
+
+func TestAPIPromise_ParsesTheBodyOnlyOnceAcrossMultipleConsumers(t *testing.T) {
+	skipTwin(t, "promise sharing across several consumers; a Go call returns its single result, and TestAPIPromise_OneRequestPerCall shows one request per call",
+		"api-promise.test.ts | APIPromise parses the body only once across multiple consumers")
+}
+
+func TestAPIPromise_OneRequestPerCall(t *testing.T) {
+	c, m := clientWith(t, func() *http.Response { return textResp(200, modelsBody, "content-type", "application/json") })
+	_, err := c.Models().ListWithResponse(ctxBG(), nil)
+	noErr(t, err)
+	eq(t, m.count(), 1)
+}
+
+func TestAPIPromise_RejectsWithAPIErrorOnEveryPath(t *testing.T) {
+	twin(t, "api-promise.test.ts | APIPromise rejects with APIError on every path")
+	c, _ := clientWith(t, func() *http.Response { return jsonResp(404, map[string]any{"message": "nope"}) })
+	_, err := c.Models().List(ctxBG(), nil)
+	mustAs[*NotFoundError](t, err)
+	mustAs[*APIError](t, err)
+	_, err = c.Models().ListWithResponse(ctxBG(), nil)
+	mustAs[*NotFoundError](t, err)
+	_, err = c.Models().ListRaw(ctxBG(), nil)
+	mustAs[*NotFoundError](t, err)
+}
+
+func TestAPIPromise_MapTransformsTheDataWhileSharingTheResponseAndParsingOnce(t *testing.T) {
+	twin(t, "api-promise.test.ts | APIPromise map() transforms the data while sharing the response and parsing once")
+	c, m := clientWith(t, func() *http.Response {
+		return textResp(200, modelsBody, "content-type", "application/json", "x-typesafe-request-id", "req_m")
+	})
+	res, err := c.Models().ListWithResponse(ctxBG(), nil)
+	noErr(t, err)
+	names := MapResponse(res, func(cards []ModelCard) []string {
+		var out []string
+		for _, c := range cards {
+			out = append(out, c.Name)
+		}
+		return out
+	})
+	eq(t, names.Data, []string{"m"})
+	eq(t, names.RequestID, "req_m")
+	eq(t, names.Status, 200)
+	eq(t, res.Data, modelCards)
+	eq(t, m.count(), 1)
+}
+
+func TestAPIPromise_SupportsThenCatchFinallyChaining(t *testing.T) {
+	skipTwin(t, "JavaScript thenable chaining; Go uses ordinary error returns",
+		"api-promise.test.ts | APIPromise supports then/catch/finally chaining")
+}
+
+func TestAPIPromise_DoesNotIssueTheRequestUntilConstructedButDoesNotRequireAwaitingToSend(t *testing.T) {
+	skipTwin(t, "a Go call is synchronous: the request is sent when the method is called and there is no unawaited promise",
+		"api-promise.test.ts | APIPromise does not issue the request until constructed, but does not require awaiting to send")
+}

package/libs/typesafe/libraries/typesafe/batch.go

@@ -0,0 +1,80 @@
+package typesafe
+
+import (
+	"context"
+	"sync"
+)
+
+// BatchItem is one request of a batch.
+type BatchItem struct {
+	Request SystemOneRequest
+	Options *RequestOptions
+}
+
+// BatchResult is the outcome of one item; exactly one of Result and Err is set.
+type BatchResult struct {
+	// Index is the position of the item in the input.
+	Index  int
+	Result *SystemOneResult
+	Err    error
+}
+
+// BatchOptions configure [EvaluateBatch].
+type BatchOptions struct {
+	// Concurrency is the number of requests in flight; zero means DefaultBatchConcurrency.
+	Concurrency int
+}
+
+// DefaultBatchConcurrency is the number of in-flight requests when none is set.
+const DefaultBatchConcurrency = 4
+
+// EvaluateBatch runs the items through ev with bounded concurrency and returns one
+// result per item, in input order. An item's failure is its own Err and does not stop
+// the others; when ctx ends, items not yet started get an *APIUserAbortError. A
+// panic in ev becomes that item's error. The TypeScript SDK has no batch call: this
+// is a helper added for the extensions' batched evaluate tools.
+func EvaluateBatch(ctx context.Context, ev Evaluator, items []BatchItem, opts BatchOptions) []BatchResult {
+	results := make([]BatchResult, len(items))
+	for i := range results {
+		results[i].Index = i
+	}
+	concurrency := opts.Concurrency
+	if concurrency <= 0 {
+		concurrency = DefaultBatchConcurrency
+	}
+	sem := make(chan struct{}, concurrency)
+	var wg sync.WaitGroup
+	abortFrom := func(i int) {
+		for ; i < len(items); i++ {
+			results[i].Err = newAbortError(context.Cause(ctx))
+		}
+	}
+loop:
+	for i := range items {
+		select {
+		case sem <- struct{}{}:
+		case <-ctx.Done():
+			abortFrom(i)
+			break loop
+		}
+		if ctx.Err() != nil {
+			<-sem
+			abortFrom(i)
+			break loop
+		}
+		wg.Add(1)
+		go func(i int) {
+			defer wg.Done()
+			defer func() { <-sem }()
+			defer func() {
+				if r := recover(); r != nil {
+					results[i].Result = nil
+					results[i].Err = errorf("The evaluator panicked: %v", r)
+				}
+			}()
+			results[i].Result, results[i].Err = ev.SystemOne(ctx, items[i].Request, items[i].Options)
+		}(i)
+	}
+	wg.Wait()
+	return results
+}

package/libs/typesafe/libraries/typesafe/batch_test.go

@@ -0,0 +1,133 @@
+package typesafe
+
+import (
+	"context"
+	"errors"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+type evalFunc func(ctx context.Context, req SystemOneRequest, opts *RequestOptions) (*SystemOneResult, error)
+
+func (f evalFunc) SystemOne(ctx context.Context, req SystemOneRequest, opts *RequestOptions) (*SystemOneResult, error) {
+	return f(ctx, req, opts)
+}
+
+func batchItems(n int) []BatchItem {
+	items := make([]BatchItem, n)
+	for i := range items {
+		items[i] = BatchItem{Request: SystemOneRequest{Model: string(rune('a' + i)), Questions: Questions{Ask("q", Noul("?"))}}}
+	}
+	return items
+}
+
+func TestEvaluateBatch_ReturnsOneResultPerItemInInputOrder(t *testing.T) {
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, _ *RequestOptions) (*SystemOneResult, error) {
+		// Later items finish first.
+		time.Sleep(time.Duration(10-int(req.Model[0]-'a')) * time.Millisecond)
+		return &SystemOneResult{Model: req.Model}, nil
+	})
+	out := EvaluateBatch(context.Background(), ev, batchItems(8), BatchOptions{Concurrency: 8})
+	eq(t, len(out), 8)
+	for i, r := range out {
+		eq(t, r.Index, i)
+		noErr(t, r.Err)
+		eq(t, r.Result.Model, string(rune('a'+i)))
+	}
+}
+
+func TestEvaluateBatch_BoundsConcurrency(t *testing.T) {
+	var inflight, peak atomic.Int32
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, _ *RequestOptions) (*SystemOneResult, error) {
+		n := inflight.Add(1)
+		for {
+			p := peak.Load()
+			if n <= p || peak.CompareAndSwap(p, n) {
+				break
+			}
+		}
+		time.Sleep(5 * time.Millisecond)
+		inflight.Add(-1)
+		return &SystemOneResult{}, nil
+	})
+	EvaluateBatch(context.Background(), ev, batchItems(12), BatchOptions{Concurrency: 3})
+	if peak.Load() > 3 || peak.Load() < 2 {
+		t.Fatalf("peak concurrency %d, want 2..3", peak.Load())
+	}
+	peak.Store(0)
+	EvaluateBatch(context.Background(), ev, batchItems(20), BatchOptions{})
+	if peak.Load() > DefaultBatchConcurrency {
+		t.Fatalf("default concurrency exceeded: %d", peak.Load())
+	}
+}
+
+func TestEvaluateBatch_AnItemsFailureDoesNotStopTheOthers(t *testing.T) {
+	boom := errors.New("boom")
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, _ *RequestOptions) (*SystemOneResult, error) {
+		if req.Model == "b" {
+			return nil, boom
+		}
+		return &SystemOneResult{Model: req.Model}, nil
+	})
+	out := EvaluateBatch(context.Background(), ev, batchItems(3), BatchOptions{Concurrency: 1})
+	noErr(t, out[0].Err)
+	if !errors.Is(out[1].Err, boom) || out[1].Result != nil {
+		t.Fatalf("item 1: %+v", out[1])
+	}
+	noErr(t, out[2].Err)
+}
+
+func TestEvaluateBatch_ContextEndAbortsItemsNotYetStarted(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	var started atomic.Int32
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, _ *RequestOptions) (*SystemOneResult, error) {
+		if started.Add(1) == 1 {
+			cancel()
+		}
+		return &SystemOneResult{}, nil
+	})
+	out := EvaluateBatch(ctx, ev, batchItems(6), BatchOptions{Concurrency: 1})
+	noErr(t, out[0].Err)
+	for _, r := range out[1:] {
+		mustAs[*APIUserAbortError](t, r.Err)
+		if !errors.Is(r.Err, context.Canceled) {
+			t.Fatalf("abort must carry the context error: %v", r.Err)
+		}
+	}
+	eq(t, int(started.Load()), 1)
+}
+
+func TestEvaluateBatch_APanicBecomesTheItemsError(t *testing.T) {
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, _ *RequestOptions) (*SystemOneResult, error) {
+		if req.Model == "a" {
+			panic("kaboom")
+		}
+		return &SystemOneResult{}, nil
+	})
+	out := EvaluateBatch(context.Background(), ev, batchItems(2), BatchOptions{})
+	if out[0].Err == nil {
+		t.Fatal("panic swallowed")
+	}
+	contains(t, out[0].Err.Error(), "kaboom")
+	noErr(t, out[1].Err)
+}
+
+func TestEvaluateBatch_EmptyAndPerItemOptions(t *testing.T) {
+	eq(t, len(EvaluateBatch(context.Background(), evalFunc(nil), nil, BatchOptions{})), 0)
+	var seen sync.Map
+	ev := evalFunc(func(ctx context.Context, req SystemOneRequest, o *RequestOptions) (*SystemOneResult, error) {
+		seen.Store(req.Model, o)
+		return &SystemOneResult{}, nil
+	})
+	items := batchItems(2)
+	items[1].Options = &RequestOptions{Timeout: time.Second}
+	EvaluateBatch(context.Background(), ev, items, BatchOptions{})
+	if o, _ := seen.Load("a"); o.(*RequestOptions) != nil {
+		t.Fatal("no options for item a")
+	}
+	if o, _ := seen.Load("b"); o.(*RequestOptions).Timeout != time.Second {
+		t.Fatal("options for item b not passed")
+	}
+}

package/libs/typesafe/libraries/typesafe/bench_test.go

@@ -0,0 +1,71 @@
+package typesafe
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// One SystemOne round trip against a local server: request build and validation, header merge, the HTTP call,
+// response parse. The network is the dominant cost in production; these benchmarks are about what the client
+// itself adds per call (and whether the default log level, warn, makes logging free).
+//
+//	go test -run xxx -bench . -benchmem
+const benchResponse = `{"model":"jev-1","answers":{"destructive":{"type":"noul","noul":0.4},"exfiltration":{"type":"noul","noul":0.1},"beyond_scope":{"type":"noul","noul":0.2},"impact":{"type":"score","score":1.2,"confidence":0.9,"probabilities":{"0":0.1,"1":0.7,"2":0.15,"3":0.05}}},"usage":{"input_tokens":120,"output_tokens":4}}`
+
+func benchClient(b *testing.B, level LogLevel) *Client {
+	b.Helper()
+	s := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, _ = w.Write([]byte(benchResponse))
+	}))
+	b.Cleanup(func() { s.CloseClientConnections(); s.Close() })
+	c, err := NewClient(Config{APIKey: "test", BaseURL: s.URL, Getenv: noEnv, LogLevel: level})
+	if err != nil {
+		b.Fatal(err)
+	}
+	return c
+}
+
+func benchRequest() SystemOneRequest {
+	return SystemOneRequest{
+		State: Text(`{"cwd":"/work","tool":"bash","arguments":{"command":"go test ./..."},"platform":"linux"}`),
+		Questions: Questions{
+			Ask("destructive", Noul("Is this action destructive?")),
+			Ask("exfiltration", Noul("Does this action send local data to a network destination?")),
+			Ask("beyond_scope", Noul("Does this action affect anything beyond what was asked?")),
+		},
+	}
+}
+
+func BenchmarkSystemOneLogOff(b *testing.B) {
+	c, req := benchClient(b, LogOff), benchRequest()
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := c.SystemOne(ctxBG(), req, nil); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkSystemOneLogWarn(b *testing.B) {
+	c, req := benchClient(b, LogWarn), benchRequest()
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := c.SystemOne(ctxBG(), req, nil); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func BenchmarkSystemOnePayload(b *testing.B) {
+	c, req := benchClient(b, LogOff), benchRequest()
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		if _, err := c.systemOnePayload(req); err != nil {
+			b.Fatal(err)
+		}
+	}
+}