@pi-in-go/pigpen-jev 0.1.0

package/extensions/jev/backend.go

@@ -0,0 +1,128 @@
+package jev
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+	"github.com/MichaelKinsy/pigpen/components/typesafe/libraries/ownmodel"
+	"github.com/MichaelKinsy/pigpen/components/typesafe/libraries/pigmodel"
+	"github.com/MichaelKinsy/pigpen/components/typesafe/libraries/typesafe"
+)
+
+// A backend answers typed questions about a state. Two exist, both in the shared
+// client (components/typesafe): the TypeSafe API, and the model PiG is configured
+// with. The extension decides what to ask, what leaves the machine and what a
+// verdict means; it does not speak HTTP or build model prompts.
+type backend struct {
+	kind   string
+	dest   string
+	client *typesafe.Client // typesafe backend
+	model  pigmodel.Ref     // own-model backend
+	cfg    config
+}
+
+func (b *backend) Destination() string { return b.dest }
+
+// normalizeEndpoint takes the API root. The original's setting was the full
+// request URL, so a trailing /v1/systemone is accepted and removed.
+func normalizeEndpoint(raw string) string {
+	raw = strings.TrimRight(raw, "/")
+	return strings.TrimSuffix(raw, "/v1/systemone")
+}
+
+// newBackend builds the backend for c, or explains why none is available. The
+// TypeSafe client gets an empty environment: only the user's config chooses where
+// the key travels, never TYPESAFE_BASE_URL (PORT.md C2).
+func newBackend(c config, sctx sdk.Context) (*backend, error) {
+	if c.Backend == backendTypeSafe {
+		if c.Endpoint == "" {
+			return nil, errors.New("the typesafe backend needs \"endpoint\" in your pi-jev.json (there is no built-in default)")
+		}
+		if c.Model == "" {
+			return nil, errors.New("the typesafe backend needs \"model\" in your pi-jev.json")
+		}
+		base := normalizeEndpoint(c.Endpoint)
+		if err := checkEndpoint(base); err != nil {
+			return nil, err
+		}
+		if c.Key == "" {
+			return nil, fmt.Errorf("no key. Set %s or apiKeyFile in pi-jev.json; the gate is inactive until then.", apiKeyEnv)
+		}
+		client, err := typesafe.NewClient(typesafe.Config{
+			APIKey: c.Key, BaseURL: base, DefaultModel: c.Model,
+			Timeout: time.Duration(c.TimeoutMs) * time.Millisecond,
+			Retry:   typesafe.RetryOverrides{MaxRetries: typesafe.Ptr(c.Retries)},
+			Getenv:  func(string) string { return "" },
+			Logger:  discardLogger{}, LogLevel: typesafe.LogOff,
+		})
+		if err != nil {
+			return nil, err
+		}
+		return &backend{kind: backendTypeSafe, dest: base + " (model " + c.Model + ")", client: client, cfg: c}, nil
+	}
+	ref := pigmodel.Ref{}
+	if c.Model != "" {
+		provider, id, ok := strings.Cut(c.Model, "/")
+		if !ok {
+			return nil, fmt.Errorf("\"model\" must be provider/model (got %q)", c.Model)
+		}
+		ref = pigmodel.Ref{Provider: provider, ID: id}
+	} else if info, err := sctx.GetModelInfo(); err == nil && info != nil {
+		ref = pigmodel.Ref{Provider: info.Provider, ID: info.ID}
+	}
+	if ref.ID == "" {
+		return nil, errors.New("the model backend needs a model: none is selected in PiG and none is set as \"model\" in pi-jev.json")
+	}
+	name := ref.Provider + "/" + ref.ID
+	return &backend{kind: backendModel, model: ref, cfg: c,
+		dest: "the model " + name + " (through PiG, the provider that already receives your conversation)"}, nil
+}
+
+// evaluator returns what answers questions for one call. The own-model backend is
+// bound to the call's context, so it is built per call.
+func (b *backend) evaluator(sctx sdk.Context) (typesafe.Evaluator, error) {
+	if b.kind == backendTypeSafe {
+		return b.client, nil
+	}
+	m, err := pigmodel.New(sctx.ModelRegistry(), b.model)
+	if err != nil {
+		return nil, err
+	}
+	return ownmodel.New(ownmodel.Options{Model: m, AnswerMode: ownmodel.Probabilities, NormalizeProbabilities: true, MalformedRetries: 1})
+}
+
+// Ask sends state (a JSON document, or text when text is true) with the questions.
+func (b *backend) Ask(ctx context.Context, sctx sdk.Context, state []byte, text bool, qs []question) (*response, error) {
+	if err := validateQuestions(qs); err != nil {
+		return nil, err
+	}
+	ev, err := b.evaluator(sctx)
+	if err != nil {
+		return nil, err
+	}
+	req := typesafe.SystemOneRequest{Questions: toTypeSafe(qs)}
+	if text {
+		var s string
+		_ = json.Unmarshal(state, &s)
+		req.State = typesafe.Text(s)
+	} else {
+		req.State = typesafe.Value(json.RawMessage(state))
+	}
+	res, err := ev.SystemOne(ctx, req, nil)
+	if err != nil {
+		return nil, err
+	}
+	return fromResult(res, qs)
+}
+
+type discardLogger struct{}
+
+func (discardLogger) Debug(string, ...any) {}
+func (discardLogger) Info(string, ...any)  {}
+func (discardLogger) Warn(string, ...any)  {}
+func (discardLogger) Error(string, ...any) {}

package/extensions/jev/bench_test.go

@@ -0,0 +1,64 @@
+package jev
+
+import (
+	"strings"
+	"testing"
+)
+
+// The judge path runs once per tool call when Jev is on: build the state document, ask, apply the thresholds.
+// Building the document is the part that scales with the call's arguments; asking is a network call.
+//
+//	go test -run xxx -bench . -benchmem
+func benchInput(bodyBytes int) map[string]any {
+	return map[string]any{
+		"path":    "/home/user/project/src/internal/module/file.go",
+		"content": strings.Repeat("line of source code with some words in it\n", bodyBytes/42),
+		"edits":   []any{map[string]any{"oldText": strings.Repeat("a", 300), "newText": strings.Repeat("b", 300)}},
+	}
+}
+
+func BenchmarkGateStateSmallCall(b *testing.B) {
+	input := map[string]any{"command": "go test ./... -count=1"}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		gateStateJSON("/work/repo", "bash", input, "please run the tests", 400, 8000)
+	}
+}
+
+func BenchmarkGateStateWrite50KB(b *testing.B) {
+	input := benchInput(50_000)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		gateStateJSON("/work/repo", "write", input, strings.Repeat("please write this file. ", 80), 400, 8000)
+	}
+}
+
+// A document that never fits drives fitState through every shrink step.
+func BenchmarkGateStateDoesNotFit(b *testing.B) {
+	wide := map[string]any{}
+	for i := 0; i < 200; i++ {
+		wide[strings.Repeat("k", i%17+1)+string(rune('a'+i%26))+strings.Repeat("z", i/26)] = strings.Repeat("v", 90)
+	}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		gateStateJSON("/work/repo", "write", wide, "do the thing", 400, 2000)
+	}
+}
+
+func BenchmarkEvaluateGate(b *testing.B) {
+	cfg := defaultConfig()
+	r := &response{Answers: map[string]answer{"destructive": {Noul: 0.4}, "exfiltration": {Noul: 0.1}, "beyond_scope": {Noul: 0.2}, "impact": {Type: "score", Score: 1.2, Confidence: 0.9, HasConfidence: true}}}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		evaluateGate(r, cfg)
+	}
+}
+
+// The memo key of one call (what is asked is memoised for CacheSeconds, so repeated calls cost one judge request).
+func BenchmarkGateKeyWrite50KB(b *testing.B) {
+	input := benchInput(50_000)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		gateKey("write", input, "/work/repo", "please write this file")
+	}
+}

package/extensions/jev/boundaries_test.go

@@ -0,0 +1,159 @@
+package jev_test
+
+import (
+	"strconv"
+	"testing"
+)
+
+// Thresholds are inclusive (>=), each one, and the confidence floors too. The
+// original's comparisons are all >=; a >= that became > would not show in the
+// scenarios because their values sit well away from every threshold.
+
+func TestGate_EachThresholdIsInclusive(t *testing.T) {
+	cases := map[string]struct {
+		body map[string]any
+		want string
+	}{
+		"destructive":  {gateBody(0.9, 0, 0, 0, 0.9), "jev: destructive 0.90"},
+		"exfiltration": {gateBody(0, 0.7, 0, 0, 0.9), "jev: exfiltration 0.70"},
+		"beyond_scope": {gateBody(0, 0, 0.85, 0, 0.9), "jev: beyond_scope 0.85"},
+		"impact":       {gateBody(0, 0, 0, 2.5, 0.9), "jev: impact 2.50/3 at confidence 0.90"},
+		"impact conf":  {gateBody(0, 0, 0, 3, 0.5), "jev: impact 3.00/3 at confidence 0.50"},
+	}
+	for name, c := range cases {
+		t.Run(name, func(t *testing.T) {
+			e := newEnv(t)
+			t.Setenv("TYPESAFE_API_KEY", testKey)
+			srv := newFakeJev(t, always(c.body))
+			e.writeGlobal(t, jevConfig(srv, nil))
+			h := start(t, e, newHostState(), HostOptions{})
+			h.toolCall("bash", bash("x"))
+			if got := h.lastStatus(); got != c.want {
+				t.Errorf("status = %q, want %q", got, c.want)
+			}
+		})
+	}
+}
+
+func TestGate_JustBelowEachThresholdIsClear(t *testing.T) {
+	for name, body := range map[string]map[string]any{
+		"destructive":  gateBody(0.89, 0, 0, 0, 0.9),
+		"exfiltration": gateBody(0, 0.69, 0, 0, 0.9),
+		"beyond_scope": gateBody(0, 0, 0.84, 0, 0.9),
+		"impact":       gateBody(0, 0, 0, 2.49, 0.9),
+	} {
+		e := newEnv(t)
+		t.Setenv("TYPESAFE_API_KEY", testKey)
+		srv := newFakeJev(t, always(body))
+		e.writeGlobal(t, jevConfig(srv, nil))
+		h := start(t, e, newHostState(), HostOptions{})
+		h.toolCall("bash", bash("x"))
+		if got := h.lastStatus(); got != "jev: clear (shadow)" {
+			t.Errorf("%s: status = %q", name, got)
+		}
+	}
+}
+
+func TestOutput_ClassConfidenceFloorIsInclusive(t *testing.T) {
+	h, _ := outputHost(t, outBody(0.01, "environment", 0.6), nil)
+	if _, none := h.toolResult("bash", bash("x"), text("boom"), true); none {
+		t.Fatal("confidence exactly at output.minConfidence must give advice")
+	}
+}
+
+func TestErrors_ChoiceOutsideItsOptionsIsAnError(t *testing.T) {
+	h, _ := errorHost(t, always(outBody(0.01, "brand_new_class", 1.0)), nil)
+	h.toolResult("bash", bash("x"), text("out"), false)
+	if !h.anyNotification("not one of its options") || !h.anyNotification("(failing open)") {
+		t.Errorf("notifications = %q", h.notifications())
+	}
+}
+
+func TestCommand_CheckNeedsJevOn(t *testing.T) {
+	e := newEnv(t)
+	t.Setenv("TYPESAFE_API_KEY", testKey)
+	srv := newFakeJev(t, always(clearGate()))
+	cfg := jevConfig(srv, nil)
+	delete(cfg, "enabled")
+	e.writeGlobal(t, cfg)
+	h := start(t, e, newHostState(), HostOptions{})
+	h.Command("jev", "check some text")
+	if srv.count() != 0 {
+		t.Fatal("/jev check sent text while Jev is off")
+	}
+	mustContain(t, "note", lastNote(h), "off", "/jev on")
+}
+
+func TestCorrection_TypeSafeEnvironmentCannotRedirectTheKey(t *testing.T) {
+	e := newEnv(t)
+	t.Setenv("TYPESAFE_API_KEY", testKey)
+	trusted := newFakeJev(t, always(clearGate()))
+	attacker := newFakeJev(t, always(clearGate()))
+	t.Setenv("TYPESAFE_BASE_URL", attacker.srv.URL)
+	t.Setenv("TYPESAFE_DEFAULT_MODEL", "attacker-model")
+	e.writeGlobal(t, jevConfig(trusted, nil))
+	h := start(t, e, newHostState(), HostOptions{})
+	h.toolCall("bash", bash("ls"))
+	if attacker.count() != 0 || trusted.count() != 1 {
+		t.Fatalf("attacker got %d requests, trusted got %d", attacker.count(), trusted.count())
+	}
+}
+
+func TestGate_CacheHoldsSixtyFourVerdicts(t *testing.T) {
+	e := newEnv(t)
+	t.Setenv("TYPESAFE_API_KEY", testKey)
+	srv := newFakeJev(t, always(clearGate()))
+	e.writeGlobal(t, jevConfig(srv, nil))
+	h := start(t, e, newHostState(), HostOptions{})
+	for i := 0; i < 70; i++ {
+		h.toolCall("bash", bash("cmd "+strconv.Itoa(i)))
+	}
+	if srv.count() != 70 {
+		t.Fatalf("requests = %d", srv.count())
+	}
+	h.toolCall("bash", bash("cmd 69")) // recent: still cached
+	if srv.count() != 70 {
+		t.Errorf("a recent verdict was not cached: %d requests", srv.count())
+	}
+	h.toolCall("bash", bash("cmd 0")) // evicted beyond 64 entries
+	if srv.count() != 71 {
+		t.Errorf("the cache grew past its 64 entries: %d requests", srv.count())
+	}
+}
+
+func TestGate_ExpiredVerdictIsJudgedAgain(t *testing.T) {
+	e := newEnv(t)
+	t.Setenv("TYPESAFE_API_KEY", testKey)
+	srv := newFakeJev(t, always(clearGate()))
+	e.writeGlobal(t, jevConfig(srv, map[string]any{"gate": map[string]any{"cacheSeconds": 1}}))
+	h := start(t, e, newHostState(), HostOptions{})
+	h.toolCall("bash", bash("ls"))
+	sleepMs(1300)
+	h.toolCall("bash", bash("ls"))
+	if srv.count() != 2 {
+		t.Errorf("requests = %d, want 2 after the window", srv.count())
+	}
+}
+
+// The original's endpoint was the full request URL; the shared client wants the API
+// root, so a trailing /v1/systemone (and slash) is accepted and removed (PORT.md D1).
+func TestConfig_EndpointMayBeTheFullRequestURL(t *testing.T) {
+	for _, suffix := range []string{"", "/", "/v1/systemone", "/v1/systemone/"} {
+		e := newEnv(t)
+		t.Setenv("TYPESAFE_API_KEY", testKey)
+		srv := newFakeJev(t, always(clearGate()))
+		cfg := jevConfig(srv, nil)
+		cfg["endpoint"] = srv.srv.URL + suffix
+		e.writeGlobal(t, cfg)
+		h := start(t, e, newHostState(), HostOptions{})
+		h.toolCall("bash", bash("ls"))
+		if srv.count() != 1 || srv.first(t).Path != "/v1/systemone" {
+			t.Errorf("endpoint %q: %d requests, path %q", suffix, srv.count(), func() string {
+				if srv.count() == 0 {
+					return ""
+				}
+				return srv.first(t).Path
+			}())
+		}
+	}
+}

package/extensions/jev/command.go

@@ -0,0 +1,224 @@
+package jev
+
+import (
+	"fmt"
+	"strings"
+
+	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
+)
+
+func (x *ext) note(ctx sdk.Context, level, plain, rich string) {
+	if x.plain() {
+		ctx.Notify(plain, level)
+		return
+	}
+	ctx.Notify(rich, level)
+}
+
+func (x *ext) command(ctx sdk.Context, args string) error {
+	trimmed := strings.TrimSpace(args)
+	fields := strings.Fields(strings.ToLower(trimmed))
+	sub, value := "", ""
+	if len(fields) > 0 {
+		sub = fields[0]
+	}
+	if len(fields) > 1 {
+		value = fields[1]
+	}
+	switch sub {
+	case "on":
+		x.turnOn(ctx)
+	case "off":
+		x.mu.Lock()
+		x.on, x.gateOn, x.outputOn = false, false, false
+		x.mu.Unlock()
+		x.setStatus(ctx, "", "off")
+		x.note(ctx, "info", "pi-jev: gate off", "pi-jev: gate off")
+	case "mode":
+		x.setMode(ctx, value)
+	case "last":
+		x.showLast(ctx)
+	case "output":
+		x.showOutput(ctx)
+	case "check":
+		x.check(ctx, strings.TrimSpace(trimmed[len("check"):]))
+	default:
+		x.status(ctx)
+	}
+	return nil
+}
+
+func (x *ext) turnOn(ctx sdk.Context) {
+	s := x.snapshot()
+	if s.be == nil {
+		reason := "Jev cannot start"
+		x.mu.Lock()
+		if x.beEr != nil {
+			reason = x.beEr.Error()
+		}
+		x.mu.Unlock()
+		ctx.Notify("pi-jev: "+x.redact(reason), "warning")
+		return
+	}
+	if !s.cfg.Enabled && !s.on {
+		// Turning it on sends content off the machine: ask, with the disclosure.
+		ok, err := ctx.Confirm("Turn on Jev for this session?", disclosure(s.cfg, s.be.Destination())+"\n\nTurn Jev on?")
+		if err != nil || !ok {
+			ctx.Notify("pi-jev: still off; nothing is sent", "info")
+			return
+		}
+	}
+	x.mu.Lock()
+	x.on, x.gateOn, x.outputOn = true, true, true
+	x.mu.Unlock()
+	x.baseStatus(ctx)
+	x.registerAsk(ctx)
+	x.note(ctx, "info", "pi-jev: gate on", "pi-jev: gate on")
+}
+
+func (x *ext) setMode(ctx sdk.Context, value string) {
+	if value != "shadow" && value != "enforce" {
+		s := x.snapshot()
+		ctx.Notify(fmt.Sprintf("pi-jev: mode is %s (usage: /jev mode shadow|enforce)", s.mode), "warning")
+		return
+	}
+	x.mu.Lock()
+	x.mode = value
+	x.mu.Unlock()
+	x.baseStatus(ctx)
+	tail := " (asks before running flagged calls)"
+	if value == "shadow" {
+		tail = " (reports, never blocks)"
+	}
+	ctx.Notify("pi-jev: "+value+tail, "info")
+}
+
+func (x *ext) showLast(ctx sdk.Context) {
+	x.mu.Lock()
+	l, fail := x.last, x.lastFailure
+	x.mu.Unlock()
+	if l == nil {
+		msg := "pi-jev: no verdicts yet"
+		if fail != "" {
+			msg += " (the last attempt failed: " + fail + ")"
+		}
+		ctx.Notify(msg, "info")
+		return
+	}
+	ctx.Notify(fmt.Sprintf("pi-jev: %s - %s | %s", l.tool, l.verdict.summary(), describeAnswers(l.verdict.Resp, gateQuestions)), "info")
+}
+
+func (x *ext) showOutput(ctx sdk.Context) {
+	x.mu.Lock()
+	l := x.lastOutput
+	x.mu.Unlock()
+	if l == nil {
+		ctx.Notify("pi-jev: no tool output judged yet", "info")
+		return
+	}
+	v := l.verdict
+	class, conf := v.FailureClass, "n/a"
+	if class == "" {
+		class = "none"
+	}
+	if v.HasClass {
+		conf = toFixed2(v.ClassConfidence)
+	}
+	ctx.Notify(fmt.Sprintf("pi-jev output: %s - %s | leak %s | class %s at %s", l.tool, v.Kind, toFixed2(v.LeaksSecret), class, conf), "info")
+}
+
+// check runs the gate questions against text the user supplies. It sends that text
+// to the judge, so it needs the same opt-in as everything else.
+func (x *ext) check(ctx sdk.Context, text string) {
+	s := x.snapshot()
+	if text == "" {
+		ctx.Notify("pi-jev: usage /jev check <text>", "warning")
+		return
+	}
+	if s.be == nil || !s.on {
+		reason := "Jev is off (run /jev on first: /jev check sends your text to the judge)"
+		x.mu.Lock()
+		if s.on && x.beEr != nil {
+			reason = x.beEr.Error()
+		}
+		x.mu.Unlock()
+		ctx.Notify("pi-jev: "+x.redact(reason), "warning")
+		return
+	}
+	gctx, cancel := goContext(ctx)
+	defer cancel()
+	resp, err := s.be.Ask(gctx, ctx, jsonString(text), true, gateQuestions)
+	if err != nil {
+		ctx.Notify("pi-jev: "+x.redact(err.Error()), "error")
+		return
+	}
+	v := evaluateGate(resp, s.cfg)
+	x.mu.Lock()
+	x.last = &lastGate{"check", v}
+	x.mu.Unlock()
+	ctx.Notify(fmt.Sprintf("pi-jev check: %s | %s", v.summary(), describeAnswers(resp, gateQuestions)), "info")
+}
+
+// status is /jev with no argument.
+func (x *ext) status(ctx sdk.Context) {
+	s := x.snapshot()
+	x.mu.Lock()
+	beErr, last, lastOut, fail := x.beEr, x.last, x.lastOutput, x.lastFailure
+	x.mu.Unlock()
+	onOff := func(b bool) string {
+		if b {
+			return "on"
+		}
+		return "off"
+	}
+	if s.cfg.Display == "plain" {
+		keySource := s.cfg.KeySource
+		if keySource == "" {
+			keySource = "missing (" + apiKeyEnv + ")"
+		}
+		ctx.Notify(fmt.Sprintf("pi-jev: %s, out %s, mode %s, model %s, key %s, judging %s, out tools %s, cache %d/%d",
+			onOff(s.gateOn), onOff(s.outputOn), s.mode, s.cfg.Model, keySource,
+			strings.Join(s.cfg.Gate.Tools, "/"), strings.Join(s.cfg.Output.Tools, "/"), x.gateMemo.size(), x.outMemo.size()), "info")
+		return
+	}
+	var b strings.Builder
+	dest := ""
+	if s.be != nil {
+		dest = s.be.Destination()
+	}
+	if !s.on {
+		b.WriteString("Jev is off. Nothing is judged and nothing is sent.\n")
+		b.WriteString("Content sent for judgment would leave this machine; /jev on shows exactly what, and where, before it turns anything on.\n")
+		if beErr != nil {
+			fmt.Fprintf(&b, "Setup: %s\n", x.redact(beErr.Error()))
+		} else if dest != "" {
+			fmt.Fprintf(&b, "Judge: %s\n", dest)
+		}
+		ctx.Notify(strings.TrimRight(b.String(), "\n"), "info")
+		return
+	}
+	fmt.Fprintf(&b, "Jev is ON — %s mode, output judge %s\n", s.mode, onOff(s.outputOn))
+	fmt.Fprintf(&b, "  Judge     %s\n", dest)
+	if s.cfg.Backend == backendTypeSafe {
+		ks := s.cfg.KeySource
+		if ks == "" {
+			ks = "missing"
+		}
+		fmt.Fprintf(&b, "  Key       %s\n", ks)
+	}
+	fmt.Fprintf(&b, "  Gate      %s (%s)\n", strings.Join(s.cfg.Gate.Tools, ", "), onOff(s.gateOn))
+	fmt.Fprintf(&b, "  Output    %s (%s)\n", strings.Join(s.cfg.Output.Tools, ", "), onOff(s.outputOn))
+	b.WriteString("  Sends     working directory, tool name, your last message, tool arguments, tool output, jev_ask text — cut to your limits\n")
+	b.WriteString("  If down   tool calls run unjudged (fails open)\n")
+	if last != nil {
+		fmt.Fprintf(&b, "  Last      %s: %s\n", last.tool, last.verdict.summary())
+	}
+	if lastOut != nil {
+		fmt.Fprintf(&b, "  Output    %s: %s\n", lastOut.tool, lastOut.verdict.Kind)
+	}
+	if fail != "" {
+		fmt.Fprintf(&b, "  Failure   %s\n", fail)
+	}
+	b.WriteString("  Commands  /jev on|off · /jev mode shadow|enforce · /jev last · /jev output · /jev check <text>")
+	ctx.Notify(b.String(), "info")
+}