package opencode import ( "context" "encoding/json" "os" "testing" "time" ) // This test does no inference and never uses or copies the user's login. func TestStableNativeSessionContractLive(t *testing.T) { executable := os.Getenv("PIPELINES_TEST_OPENCODE_V1") if executable == "" { t.Skip("set PIPELINES_TEST_OPENCODE_V1 for no-inference stable CLI contract test") } home := t.TempDir() t.Setenv("HOME", home) t.Setenv("XDG_CONFIG_HOME", home+"/config") t.Setenv("XDG_DATA_HOME", home+"/data") t.Setenv("XDG_CACHE_HOME", home+"/cache") t.Setenv("XDG_STATE_HOME", home+"/state") ctx, cancel := context.WithTimeout(context.Background(), 40*time.Second) defer cancel() c, err := Open(ctx, executable, home, "") if err != nil { t.Fatal(err) } defer c.Close() if c.Backend != "v1" { t.Fatal("expected native serve backend") } data, err := c.Call(ctx, "post", "/api/session", map[string]any{"title": "Pipelines contract test", "model": map[string]string{"providerID": "opencode-go", "id": "deepseek-v4.1-flash"}, "permissions": []map[string]string{{"action": "*", "resource": "*", "effect": "deny"}, {"action": "read", "resource": "*", "effect": "allow"}, {"action": "shell", "resource": "go test ./...", "effect": "allow"}}}) if err != nil { t.Fatal(err) } var result struct { Data struct { ID string `json:"id"` } `json:"data"` } json.Unmarshal(data, &result) defer c.Call(context.Background(), "delete", "/api/session/"+result.Data.ID, nil) data, err = c.Native(ctx, "get", "/session/"+result.Data.ID, nil) if err != nil { t.Fatal(err) } var session struct { Permission []map[string]string `json:"permission"` } json.Unmarshal(data, &session) if len(session.Permission) != 3 || session.Permission[2]["permission"] != "bash" { t.Fatal("scoped native permission contract not retained", string(data)) } // Validate the complete POST -> retained GET contract, not merely POST // acceptance. The probe itself never runs a model or tools. format, _ := json.Marshal(map[string]any{"type": "json_schema", "retryCount": 0, "schema": map[string]any{"type": "object", "required": []string{"outcome", "output"}, "additionalProperties": false, "properties": map[string]any{"outcome": map[string]any{"type": "string", "enum": []string{"success", "error"}}, "output": map[string]any{"type": "object", "additionalProperties": true}}}}) supported, err := c.supportsFormat(ctx, format) if err != nil { t.Fatal("native format capability probe failed", err) } payload := map[string]any{"noReply": true, "parts": []map[string]string{{"type": "text", "text": "No inference; validate retained message readback."}}} if supported { payload["format"] = json.RawMessage(format) } _, err = c.Native(ctx, "post", "/session/"+result.Data.ID+"/message", payload) if err != nil { t.Fatal("native schema request rejected", err) } if _, err = c.Native(ctx, "get", "/session/"+result.Data.ID+"/message", nil); err != nil { t.Fatal("effective format breaks retained-message readback", err) } t.Logf("schema mode supported: %v; retained compatibility probe: %s", supported, c.FormatProbe.SessionID) if !supported { recovered, exportErr := c.Messages(ctx, c.FormatProbe.SessionID) if exportErr != nil || !json.Valid(recovered) || c.MessageReadbackDiagnostic == "" { t.Fatal("cannot recover old format-bearing messages via read-only export", exportErr, string(recovered)) } } ref, err := c.Reference() if err != nil { t.Fatal(err) } defer os.Remove(ref) recovered, err := FromReference(ref) if err != nil { t.Fatal(err) } if _, err = recovered.Call(ctx, "post", "/api/session/"+result.Data.ID+"/interrupt", nil); err != nil { t.Fatal("cannot abort same owned service via durable reference", err) } }