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

package/libs/typesafe/libraries/typesafe/transport_test.go

@@ -0,0 +1,163 @@
+package typesafe
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// These tests use a real HTTP server: fakes do not reproduce the headers/body lifecycle.
+
+func withServer(t *testing.T, h http.HandlerFunc, run func(baseURL string)) {
+	t.Helper()
+	s := httptest.NewServer(h)
+	defer func() {
+		s.CloseClientConnections()
+		s.Close()
+	}()
+	run(s.URL)
+}
+
+// countingDoer wraps the real client and counts responses whose headers arrived.
+type countingDoer struct {
+	inner   *http.Client
+	headers atomic.Int32
+	after   func()
+}
+
+func (c *countingDoer) Do(req *http.Request) (*http.Response, error) {
+	resp, err := c.inner.Do(req)
+	if err == nil {
+		c.headers.Add(1)
+		if c.after != nil {
+			c.after()
+		}
+	}
+	return resp, err
+}
+
+func TestNativeTransport_SendsOneAuthorizationContentTypeAndOverridingCustomHeaderOnTheWire(t *testing.T) {
+	twin(t, "native-transport.test.ts | native response transport sends one authorization, content type and overriding custom header on the wire")
+	var observed http.Header
+	withServer(t, func(w http.ResponseWriter, r *http.Request) {
+		observed = r.Header.Clone()
+		_, _ = w.Write([]byte("{}"))
+	}, func(baseURL string) {
+		c, err := NewClient(Config{APIKey: "test", BaseURL: baseURL, Getenv: noEnv, DefaultHeaders: map[string]string{"authorization": "bad", "X-Team": "default", "content-type": "bad"}})
+		noErr(t, err)
+		_, err = c.SystemOne(ctxBG(), SystemOneRequest{State: Text("s"), Questions: Questions{Ask("q", Noul("?"))}}, &RequestOptions{Headers: map[string]string{"x-team": "call"}})
+		noErr(t, err)
+	})
+	eq(t, observed.Values("Authorization"), []string{"Bearer test"})
+	eq(t, observed.Values("X-Team"), []string{"call"})
+	eq(t, observed.Values("Content-Type"), []string{"application/json"})
+}
+
+func TestNativeTransport_TimesOutAStalledBodyOnParsedWithResponseAndRawPaths(t *testing.T) {
+	twin(t,
+		"native-transport.test.ts | native response transport times out a stalled 200 body on parsed, withResponse and raw paths",
+		"native-transport.test.ts | native response transport times out a stalled 503 body on parsed, withResponse and raw paths")
+	for _, status := range []int{200, 503} {
+		withServer(t, func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(status)
+			w.(http.Flusher).Flush()
+			<-r.Context().Done()
+		}, func(baseURL string) {
+			doer := &countingDoer{inner: &http.Client{}}
+			c, err := NewClient(Config{APIKey: "k", BaseURL: baseURL, Getenv: noEnv, Timeout: 200 * time.Millisecond, Retry: RetryOverrides{MaxRetries: Ptr(0)}, HTTPClient: doer})
+			noErr(t, err)
+			_, err = c.Models().List(ctxBG(), nil)
+			mustAs[*APITimeoutError](t, err)
+			_, err = c.Models().ListWithResponse(ctxBG(), nil)
+			mustAs[*APITimeoutError](t, err)
+			_, err = c.Models().ListRaw(ctxBG(), nil)
+			mustAs[*APITimeoutError](t, err)
+			eq(t, int(doer.headers.Load()), 3)
+		})
+	}
+}
+
+func TestNativeTransport_HonorsCallerCancellationAfterHeadersAndNeverRetries(t *testing.T) {
+	twin(t,
+		"native-transport.test.ts | native response transport honors caller cancellation after 200 headers and never retries",
+		"native-transport.test.ts | native response transport honors caller cancellation after 503 headers and never retries")
+	for _, status := range []int{200, 503} {
+		var attempts atomic.Int32
+		withServer(t, func(w http.ResponseWriter, r *http.Request) {
+			attempts.Add(1)
+			w.Header().Set("Content-Type", "application/json")
+			w.WriteHeader(status)
+			w.(http.Flusher).Flush()
+			<-r.Context().Done()
+		}, func(baseURL string) {
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			doer := &countingDoer{inner: &http.Client{}, after: func() { time.AfterFunc(10*time.Millisecond, cancel) }}
+			c, err := NewClient(Config{APIKey: "k", BaseURL: baseURL, Getenv: noEnv, HTTPClient: doer})
+			noErr(t, err)
+			_, err = c.Models().List(ctx, nil)
+			mustAs[*APIUserAbortError](t, err)
+			eq(t, int(attempts.Load()), 1)
+		})
+	}
+}
+
+func TestNativeTransport_RetriesABrokenBodyAndExposesTheSuccessfulResponseMetadata(t *testing.T) {
+	twin(t,
+		"native-transport.test.ts | native response transport retries a broken 200 body and exposes the successful response metadata",
+		"native-transport.test.ts | native response transport retries a broken 503 body and exposes the successful response metadata")
+	for _, status := range []int{200, 503} {
+		var attempts atomic.Int32
+		withServer(t, func(w http.ResponseWriter, r *http.Request) {
+			n := attempts.Add(1)
+			w.Header().Set("Content-Type", "application/json")
+			w.Header().Set("X-Typesafe-Request-Id", "req_"+string(rune('0'+n)))
+			if n == 1 {
+				w.WriteHeader(status)
+				_, _ = w.Write([]byte("["))
+				w.(http.Flusher).Flush()
+				time.Sleep(10 * time.Millisecond)
+				panic(http.ErrAbortHandler) // closes the connection mid-body
+			}
+			_, _ = w.Write([]byte(`{"models":[]}`))
+		}, func(baseURL string) {
+			c, err := NewClient(Config{APIKey: "k", BaseURL: baseURL, Getenv: noEnv, Retry: RetryOverrides{MaxRetries: Ptr(1), BackoffInitial: Ptr(time.Duration(0))}})
+			noErr(t, err)
+			res, err := c.Models().ListWithResponse(ctxBG(), nil)
+			noErr(t, err)
+			eq(t, res.Data, []ModelCard{})
+			eq(t, int(attempts.Load()), 2)
+			eq(t, res.RequestID, "req_2")
+			eq(t, res.URL, baseURL+"/v1/models")
+		})
+	}
+}
+
+func TestNativeTransport_BuffersDelayedChunksBeforeRawHandoffAndPreservesAReadableBodyAfterCancellation(t *testing.T) {
+	twin(t, "native-transport.test.ts | native response transport buffers delayed chunks before raw handoff and preserves a readable body after cancellation")
+	var completed atomic.Bool
+	withServer(t, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte("["))
+		w.(http.Flusher).Flush()
+		time.Sleep(20 * time.Millisecond)
+		completed.Store(true)
+		_, _ = w.Write([]byte("]"))
+	}, func(baseURL string) {
+		ctx, cancel := context.WithCancel(context.Background())
+		c, err := NewClient(Config{APIKey: "k", BaseURL: baseURL, Getenv: noEnv})
+		noErr(t, err)
+		raw, err := c.Models().ListRaw(ctx, nil)
+		noErr(t, err)
+		if !completed.Load() {
+			t.Fatal("the raw response was handed over before the body finished")
+		}
+		eq(t, raw.URL, baseURL+"/v1/models")
+		cancel()
+		eq(t, string(raw.Body), "[]")
+	})
+}

package/libs/typesafe/libraries/typesafe/twins_test.go

@@ -0,0 +1,127 @@
+package typesafe
+
+import (
+	"bufio"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// TestEveryUpstreamCaseHasATwinOrANamedSkip proves the 1:1 mapping of the TypeScript SDK
+// suite: every case in port/twins/typesafe-sdk-js.txt is claimed by exactly one Go test
+// through twin(...) (ported, possibly adapted) or skipTwin(...) (with a reason), and no Go
+// test claims a case that does not exist.
+func TestEveryUpstreamCaseHasATwinOrANamedSkip(t *testing.T) {
+	cases := readCaseList(t, filepath.Join("..", "..", "port", "twins", "typesafe-sdk-js.txt"))
+	ported, skipped := scanTwinClaims(t, ".")
+	claimed := map[string]int{}
+	for id := range ported {
+		claimed[id]++
+	}
+	for id := range skipped {
+		claimed[id]++
+	}
+	var missing, dup, unknown []string
+	for _, id := range cases {
+		switch claimed[id] {
+		case 0:
+			missing = append(missing, id)
+		case 1:
+		default:
+			dup = append(dup, id)
+		}
+	}
+	known := map[string]bool{}
+	for _, id := range cases {
+		known[id] = true
+	}
+	for id := range claimed {
+		if !known[id] {
+			unknown = append(unknown, id)
+		}
+	}
+	sort.Strings(unknown)
+	if len(missing)+len(dup)+len(unknown) > 0 {
+		t.Fatalf("%d upstream cases have no twin:\n%s\nclaimed twice:\n%s\nunknown ids:\n%s",
+			len(missing), strings.Join(missing, "\n"), strings.Join(dup, "\n"), strings.Join(unknown, "\n"))
+	}
+	t.Logf("typesafe-sdk-js: %d cases, %d ported twins, %d named skips", len(cases), len(ported), len(skipped))
+}
+
+func readCaseList(t *testing.T, path string) []string {
+	t.Helper()
+	f, err := os.Open(path)
+	noErr(t, err)
+	defer f.Close()
+	var out []string
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		line := strings.TrimRight(sc.Text(), "\r\n")
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		out = append(out, line)
+	}
+	noErr(t, sc.Err())
+	return out
+}
+
+// scanTwinClaims returns the ids claimed by twin(t, ids...) and skipTwin(t, reason, ids...)
+// calls in the package's test files, with skip reasons required to be non-empty.
+func scanTwinClaims(t *testing.T, dir string) (ported, skipped map[string]string) {
+	t.Helper()
+	ported, skipped = map[string]string{}, map[string]string{}
+	files, err := filepath.Glob(filepath.Join(dir, "*_test.go"))
+	noErr(t, err)
+	fset := token.NewFileSet()
+	for _, file := range files {
+		f, err := parser.ParseFile(fset, file, nil, 0)
+		noErr(t, err)
+		ast.Inspect(f, func(n ast.Node) bool {
+			call, ok := n.(*ast.CallExpr)
+			if !ok {
+				return true
+			}
+			id, ok := call.Fun.(*ast.Ident)
+			if !ok || (id.Name != "twin" && id.Name != "skipTwin") {
+				return true
+			}
+			args := call.Args[1:]
+			reason := ""
+			if id.Name == "skipTwin" {
+				reason = strLit(t, args[0])
+				if strings.TrimSpace(reason) == "" {
+					t.Fatalf("%s: skipTwin needs a reason", fset.Position(call.Pos()))
+				}
+				args = args[1:]
+			}
+			for _, a := range args {
+				key := strLit(t, a)
+				dst := ported
+				if id.Name == "skipTwin" {
+					dst = skipped
+				}
+				dst[key] = reason
+			}
+			return true
+		})
+	}
+	return ported, skipped
+}
+
+func strLit(t *testing.T, e ast.Expr) string {
+	t.Helper()
+	lit, ok := e.(*ast.BasicLit)
+	if !ok || lit.Kind != token.STRING {
+		t.Fatalf("twin ids and reasons must be string literals, got %T", e)
+	}
+	s, err := strconv.Unquote(lit.Value)
+	noErr(t, err)
+	return s
+}

package/libs/typesafe/libraries/typesafe/types_test.go

@@ -0,0 +1,165 @@
+package typesafe
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+)
+
+const allAnswersJSON = `{"model":"m","answers":{
+  "a":{"type":"noul","noul":0.25},
+  "b":{"type":"choice","choice":"yes","confidence":0.5,"probabilities":{"yes":0.75,"no":0.25}},
+  "c":{"type":"score","score":0.5,"confidence":0.4,"legend":{"0":"bad","1":"ok"},"probabilities":{"0":0.5,"1":0.5}}},
+  "usage":{"input_tokens":3,"output_tokens":4}}`
+
+func decodeResult(t *testing.T, s string) *SystemOneResult {
+	t.Helper()
+	var r SystemOneResult
+	noErr(t, json.Unmarshal([]byte(s), &r))
+	return &r
+}
+
+func TestTypes_MapsEachQuestionToItsResponseTypeWithLiteralCriteriaKeys(t *testing.T) {
+	// Adapted: TypeScript infers the answer type from the question literals; Go returns
+	// concrete answer types from typed accessors, and a wrong name or type is an error.
+	twin(t, "types.test-d.ts | test/types.test-d.ts systemOne result inference maps each question to its response type with literal criteria keys")
+	r := decodeResult(t, allAnswersJSON)
+	var noul NoulAnswer
+	var choice ChoiceAnswer
+	var score ScoreAnswer
+	var err error
+	noul, err = r.Noul("a")
+	noErr(t, err)
+	choice, err = r.Choice("b")
+	noErr(t, err)
+	score, err = r.Score("c")
+	noErr(t, err)
+	var _ float64 = noul.Noul
+	var _ string = choice.Choice
+	var _ map[string]float64 = choice.Probabilities
+	var _ float64 = score.Score
+	eq(t, choice.Probabilities, map[string]float64{"yes": 0.75, "no": 0.25})
+	if _, err = r.Choice("d"); err == nil {
+		t.Fatal("an unknown answer name must be an error")
+	}
+	if _, err = r.Noul("b"); err == nil {
+		t.Fatal("a type mismatch must be an error")
+	}
+	contains(t, err.Error(), `"b"`)
+}
+
+func TestTypes_TypesScoreListsByIndexWithTheLegendKeyedByScore(t *testing.T) {
+	twin(t, "types.test-d.ts | test/types.test-d.ts systemOne result inference types score lists by index, with the legend keyed by score")
+	r := decodeResult(t, `{"model":"m","answers":{"c":{"type":"score","score":1,"confidence":1,"legend":{"0":"bad","1":"ok","2":{"rich":"great"}},"probabilities":{"0":0,"1":0,"2":1}}},"usage":{"input_tokens":0,"output_tokens":0}}`)
+	s, err := r.Score("c")
+	noErr(t, err)
+	eq(t, s.Probabilities, map[int]float64{0: 0, 1: 0, 2: 1})
+	eq(t, s.Legend[2], any(map[string]any{"rich": "great"}))
+	eq(t, s.Legend[0], any("bad"))
+	if _, has := s.Legend[3]; has {
+		t.Fatal("score 3 was not defined")
+	}
+}
+
+func TestTypes_TypeLevelInference(t *testing.T) {
+	skipTwin(t, "TypeScript conditional-type inference and readonly modifiers have no Go counterpart: non-literal score lists, readonly results and client settings (the accessors return copies, TestRetryPolicy_IsolatesThe...), and the APIPromise type",
+		"types.test-d.ts | test/types.test-d.ts systemOne result inference degrades to numeric indexing for non-literal score lists",
+		"types.test-d.ts | test/types.test-d.ts systemOne result inference results are readonly",
+		"types.test-d.ts | test/types.test-d.ts systemOne result inference client settings are readonly",
+		"types.test-d.ts | test/types.test-d.ts APIPromise client methods return APIPromise")
+}
+
+func TestTypes_AcceptsAPartialRetryPolicyOnTheClientAndPerCall(t *testing.T) {
+	twin(t, "types.test-d.ts | test/types.test-d.ts systemOne result inference accepts a partial retry policy on the client and per call")
+	partial := RetryOverrides{MaxRetries: Ptr(1), HTTPStatuses: []int{503}}
+	c := newClient(t, modelsOK(), func(cfg *Config) { cfg.Retry = partial })
+	_, err := c.Models().List(ctxBG(), &RequestOptions{Retry: RetryOverrides{HTTPStatuses: []int{503}, BackoffJitter: Ptr(0.0)}})
+	noErr(t, err)
+}
+
+func TestTypes_CriteriaShapes(t *testing.T) {
+	skipTwin(t, "compile-time rejections (a label list for choice, a numeric-keyed map or a short list for score) are properties of the TypeScript types; in Go Choice takes []Option and Score takes a list, and the runtime rules are Questions.Validate and ParseQuestions",
+		"types.test-d.ts | test/types.test-d.ts criteria shapes rejects label-list shorthand for choice",
+		"types.test-d.ts | test/types.test-d.ts criteria shapes rejects numeric-keyed maps for score")
+}
+
+func TestTypes_ConstrainsDescriptionsWhileAllowingNullForEveryQuestionType(t *testing.T) {
+	// Adapted: numbers are not valid descriptions; Go reports them when the request is built.
+	twin(t, "types.test-d.ts | test/types.test-d.ts question helpers constrains descriptions while allowing null for every question type")
+	for _, q := range []Question{
+		Score("q", "ok", nil), Noul(nil).Yes(nil).No(nil), Noul(nil).NullCriteria(), Noul(nil), Choice(nil, Opt("yes", nil)), Score(nil, nil, nil),
+		Choice("q", Opt("yes", nil), Opt("no", "ok"), Opt("maybe", map[string]any{"detail": "rich"})),
+		Score("q", "bad", "ok", map[string]any{"detail": "rich"}), Noul("q").Yes(map[string]any{"detail": "rich"}), Noul("q").No("only one side"),
+	} {
+		if _, err := json.Marshal(q); err != nil {
+			t.Fatalf("%T: %v", q, err)
+		}
+	}
+	for _, q := range []Question{Choice("q", Opt("yes", 1)), Score("q", 1, 2), Noul("q").Yes(true)} {
+		_, err := json.Marshal(q)
+		if err == nil {
+			t.Fatalf("%T: a number or boolean description must not marshal", q)
+		}
+		mustAs[*TypeSafeError](t, unwrapMarshal(err))
+	}
+}
+
+// unwrapMarshal digs the *TypeSafeError out of a json.MarshalerError.
+func unwrapMarshal(err error) error {
+	var me *json.MarshalerError
+	if asErr(err, &me) {
+		return me.Err
+	}
+	return err
+}
+
+func TestTypes_PreservesResultInferenceWithNullsArraysAndOmittedInstructions(t *testing.T) {
+	twin(t, "types.test-d.ts | test/types.test-d.ts question helpers preserves result inference with nulls, arrays, and omitted instructions")
+	r := decodeResult(t, `{"model":"m","answers":{
+	  "noul":{"type":"noul","noul":1},
+	  "choice":{"type":"choice","choice":"yes","confidence":1,"probabilities":{"yes":1,"no":0}},
+	  "list":{"type":"score","score":1,"confidence":1,"legend":{"0":null,"1":"high"},"probabilities":{"0":0,"1":1}}},"usage":{"input_tokens":0,"output_tokens":0}}`)
+	l, err := r.Score("list")
+	noErr(t, err)
+	eq(t, l.Legend, map[int]any{0: nil, 1: "high"})
+	eq(t, l.Probabilities, map[int]float64{0: 0, 1: 1})
+	c, err := r.Choice("choice")
+	noErr(t, err)
+	eq(t, c.Choice, "yes")
+	_, err = json.Marshal(Questions{
+		Ask("q", Noul([]any{nil, "instructions"}).Yes([]any{nil, "criterion"})),
+		Ask("c", Choice([]any{"instructions"}, Opt("yes", []any{nil, "criterion"}))),
+		Ask("s", Score([]any{"instructions"}, []any{nil, "criterion"}, nil)),
+	})
+	noErr(t, err)
+}
+
+func TestTypes_AreAllAssignableToQuestion(t *testing.T) {
+	twin(t, "types.test-d.ts | test/types.test-d.ts question helpers are all assignable to Question")
+	var _ Question = Noul("x")
+	var _ Question = Choice("x", Opt("a", nil))
+	var _ Question = Choice("x", Opt("a", nil), Opt("b", nil))
+	var _ Question = Score("x", "a", "b")
+	eq(t, Noul("x").QuestionType(), TypeNoul)
+	eq(t, Choice("x").QuestionType(), TypeChoice)
+	eq(t, Score("x").QuestionType(), TypeScore)
+}
+
+func TestTypes_AwaitingYieldsThePlainResult(t *testing.T) {
+	twin(t, "types.test-d.ts | test/types.test-d.ts APIPromise awaiting yields the plain result")
+	m := always(func() *http.Response {
+		return jsonResp(200, decode(t, allAnswersJSON), "x-typesafe-request-id", "req_1")
+	})
+	c := newClient(t, m)
+	res, err := c.SystemOne(ctxBG(), SystemOneRequest{State: Text("s"), Questions: Questions{Ask("a", Noul("x"))}}, nil)
+	noErr(t, err)
+	var _ *SystemOneResult = res
+	a, err := res.Noul("a")
+	noErr(t, err)
+	eq(t, a.Noul, 0.25)
+	wr, err := c.SystemOneWithResponse(ctxBG(), SystemOneRequest{State: Text("s"), Questions: Questions{Ask("a", Noul("x"))}}, nil)
+	noErr(t, err)
+	var _ string = wr.RequestID
+	eq(t, wr.RequestID, "req_1")
+	eq(t, wr.Data.Usage, Usage{InputTokens: 3, OutputTokens: 4})
+}

package/libs/typesafe/libraries/typesafe/version.go

@@ -0,0 +1,10 @@
+package typesafe
+
+// Version is the version of the TypeScript SDK this package ports (@typesafe-ai/sdk).
+const Version = "0.6.0"
+
+// Default values used when neither the configuration nor the environment set one.
+const (
+	DefaultBaseURL = "https://api.typesafe.ai"
+	DefaultModel   = "jev-latest"
+)

package/libs/typesafe/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@pi-in-go/pigpen-typesafe",
+  "version": "0.1.0",
+  "description": "Shared Go client for the TypeSafe AI API (a port of the official TypeScript SDK) with an own-model backend that answers the same typed questions with the model PiG is configured with. Libraries only, no extension of its own.",
+  "keywords": [
+    "pig-package",
+    "typesafe",
+    "llm",
+    "evaluation",
+    "library",
+    "pigpen"
+  ],
+  "license": "MIT",
+  "author": "Michael Kinsy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MichaelKinsy/pigpen.git",
+    "directory": "components/typesafe"
+  },
+  "homepage": "https://github.com/MichaelKinsy/pigpen/tree/main/components/typesafe#readme",
+  "bugs": {
+    "url": "https://github.com/MichaelKinsy/pigpen/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "libraries",
+    "port",
+    "go.mod",
+    "CONTRACT.md",
+    "README.md",
+    "LICENSE",
+    "CREDITS.md",
+    "provenance.json"
+  ]
+}

package/libs/typesafe/provenance.json

@@ -0,0 +1,49 @@
+{
+  "origin": "ported",
+  "authors": [
+    "Michael Kinsy"
+  ],
+  "license": "MIT",
+  "licenseFile": "LICENSE",
+  "upstreams": [
+    {
+      "name": "typesafe-sdk-js",
+      "authors": [
+        "TypeSafe",
+        "evinism"
+      ],
+      "url": "https://github.com/typesafe-ai/typesafe-sdk-js",
+      "revision": "66880ccded6cb642dc1809620c2b108c33730214",
+      "path": "port/oracle/typesafe-sdk-js",
+      "license": "MIT",
+      "licenseFile": "port/oracle/typesafe-sdk-js/LICENSE",
+      "attributionFile": "CREDITS.md"
+    },
+    {
+      "name": "system-one-adapter-python",
+      "authors": [
+        "TypeSafe AI",
+        "Erik Gafni",
+        "Daniel Gafni"
+      ],
+      "url": "https://github.com/typesafe-ai/system-one-adapter-python",
+      "revision": "e1d4cc938204b22fc5a3c3aca7044072fe3f712d",
+      "path": "port/oracle/system-one-adapter-python",
+      "license": "MIT",
+      "licenseFile": "port/oracle/system-one-adapter-python/LICENSE",
+      "attributionFile": "CREDITS.md"
+    },
+    {
+      "name": "WorkflowEvals",
+      "authors": [
+        "Sam"
+      ],
+      "url": "https://github.com/typesafe-ai/WorkflowEvals",
+      "revision": "0ac3b8ad845429f0d8e064ecfb2430a47c5a25cb",
+      "path": "port/oracle/WorkflowEvals",
+      "license": "Apache-2.0",
+      "licenseFile": "port/oracle/WorkflowEvals/LICENSE",
+      "attributionFile": "CREDITS.md"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@pi-in-go/pigpen-pi-typesafe",
+  "version": "0.1.0",
+  "description": "Go port of pi-typesafe's extension: the batched typesafe_evaluate tool, the /typesafe command (login, consent, usage, sample test, playground) and result renderers. Off until the operator enables it. Content goes to api.typesafe.ai unless the own-model backend (the model PiG is configured with) is selected.",
+  "keywords": [
+    "pig-package",
+    "pig-extension",
+    "typesafe",
+    "jev",
+    "structured-decisions",
+    "pigpen",
+    "extension"
+  ],
+  "license": "MIT",
+  "author": "Michael Kinsy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MichaelKinsy/pigpen.git",
+    "directory": "components/pi-typesafe"
+  },
+  "homepage": "https://github.com/MichaelKinsy/pigpen/tree/main/components/pi-typesafe#readme",
+  "bugs": {
+    "url": "https://github.com/MichaelKinsy/pigpen/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "extensions",
+    "port",
+    "README.md",
+    "LICENSE",
+    "CREDITS.md",
+    "provenance.json",
+    "libs"
+  ],
+  "pi": {
+    "extensions": [
+      "extensions/pi-typesafe"
+    ]
+  }
+}