@opensoha/contracts 0.1.15 → 0.1.17

package/gen/go/sohaapi/client.go

@@ -2,8 +2,10 @@
 package sohaapi
 
 import (
+	"bufio"
 	"bytes"
 	"context"
+	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -14,7 +16,7 @@ import (
 	"time"
 )
 
-const defaultUserAgent = "opensoha-contracts/0.1.15"
+const defaultUserAgent = "opensoha-contracts/0.1.17"
 
 type Client struct {
 	BaseURL    string
@@ -544,6 +546,97 @@ func (c *Client) queryLogs(ctx context.Context, path string, query LogQuery) (Lo
 	return out.Data, nil
 }
 
+func (c *Client) GetComputeCapabilities(ctx context.Context) (ComputeCapabilityManifest, error) {
+	var out ComputeCapabilityManifestEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, "/compute/capabilities", true, nil, &out); err != nil {
+		return ComputeCapabilityManifest{}, err
+	}
+	return out.Data, nil
+}
+
+func (c *Client) GetComputeOverview(ctx context.Context) (ComputeOverview, error) {
+	var out ComputeOverviewEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, "/compute/overview", true, nil, &out); err != nil {
+		return ComputeOverview{}, err
+	}
+	return out.Data, nil
+}
+
+func (c *Client) ListComputeAccessSources(ctx context.Context, params ListComputeAccessSourcesParams) (ComputeAccessSourceListEnvelope, error) {
+	var out ComputeAccessSourceListEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, "/compute/access-sources"+computeAccessSourceQuery(params), true, nil, &out); err != nil {
+		return ComputeAccessSourceListEnvelope{}, err
+	}
+	return out, nil
+}
+
+func (c *Client) ListComputeProviders(ctx context.Context, params ListComputeProvidersParams) (ComputeProviderListEnvelope, error) {
+	var out ComputeProviderListEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, "/compute/providers"+computeProviderQuery(params), true, nil, &out); err != nil {
+		return ComputeProviderListEnvelope{}, err
+	}
+	return out, nil
+}
+
+func (c *Client) ListComputeProviderInstances(ctx context.Context, params ListComputeProviderInstancesParams) (ComputeProviderInstanceListEnvelope, error) {
+	var out ComputeProviderInstanceListEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, "/compute/provider-instances"+computeProviderInstanceQuery(params), true, nil, &out); err != nil {
+		return ComputeProviderInstanceListEnvelope{}, err
+	}
+	return out, nil
+}
+
+func (c *Client) GetComputeProviderInstance(ctx context.Context, domain ComputeProviderDomain, providerKey, instanceRef string) (ComputeProviderInstance, error) {
+	var out ComputeProviderInstanceEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, computeProviderInstancePath(domain, providerKey, instanceRef), true, nil, &out); err != nil {
+		return ComputeProviderInstance{}, err
+	}
+	return out.Data, nil
+}
+
+func (c *Client) CheckComputeProviderInstanceHealth(ctx context.Context, domain ComputeProviderDomain, providerKey, instanceRef, idempotencyKey string, req ComputeProviderReadRequest) (ComputeTaskView, error) {
+	return c.mutateComputeProviderInstance(ctx, domain, providerKey, instanceRef, "health-checks", idempotencyKey, req)
+}
+
+func (c *Client) DiscoverComputeProviderInstance(ctx context.Context, domain ComputeProviderDomain, providerKey, instanceRef, idempotencyKey string, req ComputeProviderDiscoverRequest) (ComputeTaskView, error) {
+	return c.mutateComputeProviderInstance(ctx, domain, providerKey, instanceRef, "discoveries", idempotencyKey, req)
+}
+
+func (c *Client) mutateComputeProviderInstance(ctx context.Context, domain ComputeProviderDomain, providerKey, instanceRef, action, idempotencyKey string, req any) (ComputeTaskView, error) {
+	var out ComputeTaskEnvelope
+	path := computeProviderInstancePath(domain, providerKey, instanceRef) + "/" + action
+	if err := c.doJSONWithHeaders(ctx, http.MethodPost, path, true, req, &out, idempotencyHeader(idempotencyKey)); err != nil {
+		return ComputeTaskView{}, err
+	}
+	return out.Data, nil
+}
+
+func (c *Client) GetComputeResource(ctx context.Context, domain ComputeDomain, kind ComputeResourceKind, resourceID string) (AnyValue, error) {
+	var out GenericDataEnvelope
+	if err := c.doJSON(ctx, http.MethodGet, computeResourcePath(domain, kind, resourceID), true, nil, &out); err != nil {
+		return nil, err
+	}
+	return out.Data, nil
+}
+
+func (c *Client) ListComputeResourceRelations(ctx context.Context, domain ComputeDomain, kind ComputeResourceKind, resourceID string, params ListComputeResourceRelationsParams) (ComputeResourceRelations, error) {
+	var out ComputeResourceRelationListEnvelope
+	path := computeResourcePath(domain, kind, resourceID) + "/relations" + computeRelationQuery(params)
+	if err := c.doJSON(ctx, http.MethodGet, path, true, nil, &out); err != nil {
+		return ComputeResourceRelations{}, err
+	}
+	return out.Data, nil
+}
+
+func (c *Client) ExecuteComputeResourceAction(ctx context.Context, domain ComputeDomain, kind ComputeResourceKind, resourceID, action, idempotencyKey string, req ComputeResourceActionRequest) (ComputeTaskView, error) {
+	var out ComputeTaskEnvelope
+	path := computeResourcePath(domain, kind, resourceID) + "/actions/" + url.PathEscape(strings.TrimSpace(action))
+	if err := c.doJSONWithHeaders(ctx, http.MethodPost, path, true, req, &out, idempotencyHeader(idempotencyKey)); err != nil {
+		return ComputeTaskView{}, err
+	}
+	return out.Data, nil
+}
+
 func (c *Client) ListComputeTasks(ctx context.Context, params ListComputeTasksParams) (ComputeTaskListEnvelope, error) {
 	var out ComputeTaskListEnvelope
 	if err := c.doJSON(ctx, http.MethodGet, "/compute/tasks"+computeTaskQuery(params), true, nil, &out); err != nil {
@@ -569,22 +662,80 @@ func (c *Client) ListComputeTaskLogs(ctx context.Context, domain ComputeTaskDoma
 }
 
 func (c *Client) CancelComputeTask(ctx context.Context, domain ComputeTaskDomain, taskID string, req ComputeTaskMutationRequest) (ComputeTaskView, error) {
-	return c.mutateComputeTask(ctx, domain, taskID, "cancel", req)
+	return c.CancelComputeTaskWithKey(ctx, domain, taskID, computeMutationKey(domain, taskID, "cancel", req), req)
 }
 
 func (c *Client) RetryComputeTask(ctx context.Context, domain ComputeTaskDomain, taskID string, req ComputeTaskMutationRequest) (ComputeTaskView, error) {
-	return c.mutateComputeTask(ctx, domain, taskID, "retry", req)
+	return c.RetryComputeTaskWithKey(ctx, domain, taskID, computeMutationKey(domain, taskID, "retry", req), req)
+}
+
+func (c *Client) CancelComputeTaskWithKey(ctx context.Context, domain ComputeTaskDomain, taskID, idempotencyKey string, req ComputeTaskMutationRequest) (ComputeTaskView, error) {
+	return c.mutateComputeTask(ctx, domain, taskID, "cancel", idempotencyKey, req)
 }
 
-func (c *Client) mutateComputeTask(ctx context.Context, domain ComputeTaskDomain, taskID, action string, req ComputeTaskMutationRequest) (ComputeTaskView, error) {
+func (c *Client) RetryComputeTaskWithKey(ctx context.Context, domain ComputeTaskDomain, taskID, idempotencyKey string, req ComputeTaskMutationRequest) (ComputeTaskView, error) {
+	return c.mutateComputeTask(ctx, domain, taskID, "retry", idempotencyKey, req)
+}
+
+func (c *Client) mutateComputeTask(ctx context.Context, domain ComputeTaskDomain, taskID, action, idempotencyKey string, req ComputeTaskMutationRequest) (ComputeTaskView, error) {
 	var out ComputeTaskEnvelope
 	path := computeTaskPath(domain, taskID) + "/" + action
-	if err := c.doJSON(ctx, http.MethodPost, path, true, req, &out); err != nil {
+	if err := c.doJSONWithHeaders(ctx, http.MethodPost, path, true, req, &out, idempotencyHeader(idempotencyKey)); err != nil {
 		return ComputeTaskView{}, err
 	}
 	return out.Data, nil
 }
 
+func (c *Client) StreamComputeTask(ctx context.Context, domain ComputeTaskDomain, taskID string, handle func(ComputeTaskStreamEvent) error) error {
+	if handle == nil {
+		return fmt.Errorf("compute task stream handler is required")
+	}
+	endpoint, err := c.endpoint(computeTaskPath(domain, taskID) + "/stream")
+	if err != nil {
+		return err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Accept", "text/event-stream")
+	if c.UserAgent != "" {
+		req.Header.Set("User-Agent", c.UserAgent)
+	}
+	if strings.TrimSpace(c.Token) != "" {
+		req.Header.Set("Authorization", "Bearer "+strings.TrimSpace(c.Token))
+	}
+	client := c.HTTPClient
+	if client == nil {
+		client = http.DefaultClient
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= http.StatusBadRequest {
+		raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+		return fmt.Errorf("GET %s failed: %s: %s", computeTaskPath(domain, taskID)+"/stream", resp.Status, responseErrorMessage(raw))
+	}
+	scanner := bufio.NewScanner(resp.Body)
+	scanner.Buffer(make([]byte, 64<<10), 1<<20)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if !strings.HasPrefix(line, "data:") {
+			continue
+		}
+		var event ComputeTaskStreamEvent
+		if err := json.Unmarshal([]byte(strings.TrimSpace(strings.TrimPrefix(line, "data:"))), &event); err != nil {
+			return fmt.Errorf("decode compute task stream event: %w", err)
+		}
+		if err := handle(event); err != nil {
+			return err
+		}
+	}
+	return scanner.Err()
+}
+
 func (c *Client) ListAIGatewayAuditLogs(ctx context.Context, params ListAIGatewayAuditLogsParams) ([]AuditLog, error) {
 	var out AuditLogListEnvelope
 	if err := c.doJSON(ctx, http.MethodGet, "/ai-gateway/audit-logs"+auditLogQuery(params), true, nil, &out); err != nil {
@@ -959,6 +1110,48 @@ func computeTaskPath(domain ComputeTaskDomain, taskID string) string {
 	return "/compute/tasks/" + url.PathEscape(string(domain)) + "/" + url.PathEscape(strings.TrimSpace(taskID))
 }
 
+func computeProviderInstancePath(domain ComputeProviderDomain, providerKey, instanceRef string) string {
+	return "/compute/provider-instances/" + url.PathEscape(string(domain)) + "/" + url.PathEscape(strings.TrimSpace(providerKey)) + "/" + url.PathEscape(strings.TrimSpace(instanceRef))
+}
+
+func computeResourcePath(domain ComputeDomain, kind ComputeResourceKind, resourceID string) string {
+	return "/compute/resources/" + url.PathEscape(string(domain)) + "/" + url.PathEscape(string(kind)) + "/" + url.PathEscape(strings.TrimSpace(resourceID))
+}
+
+func computeAccessSourceQuery(params ListComputeAccessSourcesParams) string {
+	values := url.Values{}
+	addQueryString(values, "sourceType", string(params.SourceType))
+	addQueryString(values, "providerKey", params.ProviderKey)
+	addQueryString(values, "cursor", string(params.Cursor))
+	addQueryInt(values, "limit", int(params.Limit))
+	return encodeQuery(values)
+}
+
+func computeProviderQuery(params ListComputeProvidersParams) string {
+	values := url.Values{}
+	addQueryString(values, "domain", string(params.Domain))
+	addQueryString(values, "source", string(params.Source))
+	addQueryString(values, "cursor", string(params.Cursor))
+	addQueryInt(values, "limit", int(params.Limit))
+	return encodeQuery(values)
+}
+
+func computeProviderInstanceQuery(params ListComputeProviderInstancesParams) string {
+	values := url.Values{}
+	addQueryString(values, "domain", string(params.Domain))
+	addQueryString(values, "providerKey", params.ProviderKey)
+	addQueryString(values, "cursor", string(params.Cursor))
+	addQueryInt(values, "limit", int(params.Limit))
+	return encodeQuery(values)
+}
+
+func computeRelationQuery(params ListComputeResourceRelationsParams) string {
+	values := url.Values{}
+	addQueryString(values, "cursor", string(params.Cursor))
+	addQueryInt(values, "limit", int(params.Limit))
+	return encodeQuery(values)
+}
+
 func computeTaskQuery(params ListComputeTasksParams) string {
 	values := url.Values{}
 	addQueryString(values, "domain", string(params.Domain))
@@ -967,11 +1160,23 @@ func computeTaskQuery(params ListComputeTasksParams) string {
 	addQueryString(values, "category", string(params.Category))
 	addQueryString(values, "resourceKind", params.ResourceKind)
 	addQueryString(values, "resourceId", params.ResourceID)
+	addQueryString(values, "sortBy", params.SortBy)
+	addQueryString(values, "sortOrder", string(params.SortOrder))
 	addQueryString(values, "cursor", string(params.Cursor))
 	addQueryInt(values, "limit", int(params.Limit))
 	return encodeQuery(values)
 }
 
+func idempotencyHeader(key string) http.Header {
+	return http.Header{"Idempotency-Key": []string{strings.TrimSpace(key)}}
+}
+
+func computeMutationKey(domain ComputeTaskDomain, taskID, action string, req ComputeTaskMutationRequest) string {
+	payload, _ := json.Marshal(req)
+	sum := sha256.Sum256([]byte(string(domain) + "\x00" + strings.TrimSpace(taskID) + "\x00" + action + "\x00" + string(payload)))
+	return fmt.Sprintf("compute-%x", sum)
+}
+
 func addQueryString(values url.Values, key, value string) {
 	if value != "" {
 		values.Set(key, value)

package/gen/go/sohaapi/client_test.go

@@ -6,6 +6,7 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 	"time"
 )
@@ -155,9 +156,9 @@ func TestExchangeDockerHostAgentEnrollmentIsPublicAndReturnsCredentials(t *testi
 		w.WriteHeader(http.StatusCreated)
 		writeJSON(t, w, map[string]any{"data": map[string]any{
 			"hostId": "host-1", "operationId": "operation-1", "agentId": "host-1",
-			"agentBearerToken": "agent-secret-012345678901234567890",
+			"agentBearerToken":   "agent-secret-012345678901234567890",
 			"runtimeBearerToken": "runtime-secret-012345678901234567",
-			"issuedAt": issuedAt,
+			"issuedAt":           issuedAt,
 		}})
 	})
 
@@ -331,7 +332,7 @@ func TestComputeTaskCenterClientSurface(t *testing.T) {
 		case 1:
 			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/tasks")
 			assertQuery(t, r, map[string]string{
-				"domain": "virtualization", "resourceKind": "cluster", "resourceId": "cluster-1", "limit": "1",
+				"domain": "virtualization", "resourceKind": "cluster", "resourceId": "cluster-1", "sortBy": "status", "sortOrder": "desc", "limit": "1",
 			})
 			writeJSON(t, w, map[string]any{"items": []any{}})
 		case 2:
@@ -344,12 +345,18 @@ func TestComputeTaskCenterClientSurface(t *testing.T) {
 			}}})
 		case 4:
 			assertCommonRequest(t, r, http.MethodPost, "/api/v1/compute/tasks/virtualization/task%2Fone/cancel")
+			if key := r.Header.Get("Idempotency-Key"); !strings.HasPrefix(key, "compute-") {
+				t.Fatalf("cancel Idempotency-Key = %q", key)
+			}
 			if body := decodeJSONRequestBody[ComputeTaskMutationRequest](t, r); body.Reason != "operator request" {
 				t.Fatalf("cancel reason = %q", body.Reason)
 			}
 			writeJSON(t, w, computeTaskEnvelopeFixture("task/one"))
 		case 5:
 			assertCommonRequest(t, r, http.MethodPost, "/api/v1/compute/tasks/virtualization/task%2Fone/retry")
+			if key := r.Header.Get("Idempotency-Key"); key != "retry-key-1" {
+				t.Fatalf("retry Idempotency-Key = %q", key)
+			}
 			writeJSON(t, w, computeTaskEnvelopeFixture("task/two"))
 		default:
 			t.Fatalf("unexpected request %s %s", r.Method, r.URL.Path)
@@ -357,7 +364,7 @@ func TestComputeTaskCenterClientSurface(t *testing.T) {
 	})
 
 	items, err := client.ListComputeTasks(context.Background(), ListComputeTasksParams{
-		Domain: ComputeTaskDomainVirtualization, ResourceKind: "cluster", ResourceID: "cluster-1", Limit: 1,
+		Domain: ComputeTaskDomainVirtualization, ResourceKind: "cluster", ResourceID: "cluster-1", SortBy: "status", SortOrder: ListComputeTasksParamsSortOrder("desc"), Limit: 1,
 	})
 	if err != nil || len(items.Items) != 0 {
 		t.Fatalf("ListComputeTasks = %#v, %v", items, err)
@@ -371,11 +378,127 @@ func TestComputeTaskCenterClientSurface(t *testing.T) {
 	if _, err := client.CancelComputeTask(context.Background(), ComputeTaskDomainVirtualization, "task/one", ComputeTaskMutationRequest{Reason: "operator request"}); err != nil {
 		t.Fatalf("CancelComputeTask returned error: %v", err)
 	}
-	if task, err := client.RetryComputeTask(context.Background(), ComputeTaskDomainVirtualization, "task/one", ComputeTaskMutationRequest{}); err != nil || task.ID != "task/two" {
+	if task, err := client.RetryComputeTaskWithKey(context.Background(), ComputeTaskDomainVirtualization, "task/one", "retry-key-1", ComputeTaskMutationRequest{}); err != nil || task.ID != "task/two" {
 		t.Fatalf("RetryComputeTask = %#v, %v", task, err)
 	}
 }
 
+func TestComputeInventoryClientSurface(t *testing.T) {
+	requests := 0
+	client := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
+		requests++
+		switch requests {
+		case 1:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/capabilities")
+			writeJSON(t, w, map[string]any{"data": map[string]any{"generation": 1, "features": []any{}}})
+		case 2:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/overview")
+			writeJSON(t, w, map[string]any{"data": map[string]any{"attention": []any{}, "providerHealth": []any{}, "partial": false, "warnings": []any{}}})
+		case 3:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/access-sources")
+			assertQuery(t, r, map[string]string{"sourceType": "virtualization_connection", "providerKey": "pve", "cursor": "next", "limit": "10"})
+			writeJSON(t, w, map[string]any{"items": []any{}})
+		case 4:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/providers")
+			assertQuery(t, r, map[string]string{"domain": "virtualization", "source": "builtin", "limit": "10"})
+			writeJSON(t, w, map[string]any{"items": []any{}})
+		case 5:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/provider-instances")
+			assertQuery(t, r, map[string]string{"domain": "virtualization", "providerKey": "pve", "limit": "10"})
+			writeJSON(t, w, map[string]any{"items": []any{}})
+		case 6:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/provider-instances/virtualization/pve/connection%2Fone")
+			writeJSON(t, w, map[string]any{"data": map[string]any{}})
+		case 7:
+			assertCommonRequest(t, r, http.MethodPost, "/api/v1/compute/provider-instances/virtualization/pve/connection%2Fone/health-checks")
+			if key := r.Header.Get("Idempotency-Key"); key != "health-key-1" {
+				t.Fatalf("health Idempotency-Key = %q", key)
+			}
+			writeJSON(t, w, computeTaskEnvelopeFixture("health-task"))
+		case 8:
+			assertCommonRequest(t, r, http.MethodPost, "/api/v1/compute/provider-instances/virtualization/pve/connection%2Fone/discoveries")
+			if key := r.Header.Get("Idempotency-Key"); key != "discover-key-1" {
+				t.Fatalf("discover Idempotency-Key = %q", key)
+			}
+			writeJSON(t, w, computeTaskEnvelopeFixture("discover-task"))
+		case 9:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/resources/virtualization/vm/vm%2Fone")
+			writeJSON(t, w, map[string]any{"data": map[string]any{"id": "vm/one"}})
+		case 10:
+			assertCommonRequest(t, r, http.MethodGet, "/api/v1/compute/resources/virtualization/vm/vm%2Fone/relations")
+			assertQuery(t, r, map[string]string{"cursor": "next", "limit": "20"})
+			writeJSON(t, w, map[string]any{"data": map[string]any{"resource": map[string]any{"domain": "virtualization", "kind": "vm", "id": "vm/one", "displayName": "vm-one"}, "relations": []any{}}})
+		case 11:
+			assertCommonRequest(t, r, http.MethodPost, "/api/v1/compute/resources/virtualization/vm/vm%2Fone/actions/start")
+			if key := r.Header.Get("Idempotency-Key"); key != "action-key-1" {
+				t.Fatalf("action Idempotency-Key = %q", key)
+			}
+			writeJSON(t, w, computeTaskEnvelopeFixture("action-task"))
+		default:
+			t.Fatalf("unexpected request %s %s", r.Method, r.URL.Path)
+		}
+	})
+
+	ctx := context.Background()
+	if _, err := client.GetComputeCapabilities(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.GetComputeOverview(ctx); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.ListComputeAccessSources(ctx, ListComputeAccessSourcesParams{SourceType: ComputeAccessSourceTypeVirtualizationConnection, ProviderKey: "pve", Cursor: "next", Limit: 10}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.ListComputeProviders(ctx, ListComputeProvidersParams{Domain: ComputeProviderDomainVirtualization, Source: ComputeProviderSourceBuiltin, Limit: 10}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.ListComputeProviderInstances(ctx, ListComputeProviderInstancesParams{Domain: ComputeProviderDomainVirtualization, ProviderKey: "pve", Limit: 10}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.GetComputeProviderInstance(ctx, ComputeProviderDomainVirtualization, "pve", "connection/one"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.CheckComputeProviderInstanceHealth(ctx, ComputeProviderDomainVirtualization, "pve", "connection/one", "health-key-1", ComputeProviderReadRequest{ExpectedGeneration: 1}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.DiscoverComputeProviderInstance(ctx, ComputeProviderDomainVirtualization, "pve", "connection/one", "discover-key-1", ComputeProviderDiscoverRequest{ExpectedGeneration: 1}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.GetComputeResource(ctx, ComputeDomainVirtualization, ComputeResourceKindVM, "vm/one"); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.ListComputeResourceRelations(ctx, ComputeDomainVirtualization, ComputeResourceKindVM, "vm/one", ListComputeResourceRelationsParams{Cursor: "next", Limit: 20}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := client.ExecuteComputeResourceAction(ctx, ComputeDomainVirtualization, ComputeResourceKindVM, "vm/one", "start", "action-key-1", ComputeResourceActionRequest{}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestStreamComputeTask(t *testing.T) {
+	client := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodGet || r.URL.EscapedPath() != "/api/v1/compute/tasks/virtualization/task%2Fone/stream" {
+			t.Fatalf("request = %s %s", r.Method, r.URL.EscapedPath())
+		}
+		if accept := r.Header.Get("Accept"); accept != "text/event-stream" {
+			t.Fatalf("Accept = %q", accept)
+		}
+		if r.Header.Get("Authorization") != "Bearer test-token" || r.Header.Get("User-Agent") != "sohaapi-test" {
+			t.Fatalf("unexpected authenticated stream headers: %#v", r.Header)
+		}
+		_, _ = io.WriteString(w, "event: snapshot\ndata: {\"type\":\"snapshot\",\"observedAt\":\"2026-08-24T12:00:00Z\",\"sequence\":1}\n\n")
+	})
+
+	var events []ComputeTaskStreamEvent
+	err := client.StreamComputeTask(context.Background(), ComputeTaskDomainVirtualization, "task/one", func(event ComputeTaskStreamEvent) error {
+		events = append(events, event)
+		return nil
+	})
+	if err != nil || len(events) != 1 || events[0].Sequence != 1 {
+		t.Fatalf("StreamComputeTask events=%#v err=%v", events, err)
+	}
+}
+
 func TestResourceLogClientSurface(t *testing.T) {
 	requests := []string{
 		"/api/v1/clusters/cluster%2Fone/logs/query",