@opensoha/contracts 0.1.14 → 0.1.16

package/fixtures/openapi/PortalLaunchRequest/invalid/unknown-surface.json

@@ -0,0 +1,3 @@
+{
+  "surface": "mobile"
+}

package/fixtures/openapi/PortalLaunchRequest/valid/default-web.json

@@ -0,0 +1 @@
+{}

package/fixtures/openapi/PortalLaunchRequest/valid/desktop.json

@@ -0,0 +1,3 @@
+{
+  "surface": "desktop"
+}

package/fixtures/openapi/PortalSecuritySummaryEnvelope/invalid/missing-session-count.json

@@ -0,0 +1,15 @@
+{
+  "data": {
+    "principal": {
+      "userId": "user-1",
+      "userName": "OpenSoha",
+      "email": "opensoha@example.com",
+      "roles": [],
+      "teams": [],
+      "projects": [],
+      "tags": []
+    },
+    "mfaEnabled": false,
+    "linkedSources": []
+  }
+}

package/fixtures/openapi/PortalSecuritySummaryEnvelope/valid/minimal.json

@@ -0,0 +1,16 @@
+{
+  "data": {
+    "principal": {
+      "userId": "user-1",
+      "userName": "OpenSoha",
+      "email": "opensoha@example.com",
+      "roles": [],
+      "teams": [],
+      "projects": [],
+      "tags": []
+    },
+    "mfaEnabled": false,
+    "linkedSources": [],
+    "activeSession": 1
+  }
+}

package/fixtures/openapi/ScopeGrantInput/invalid/delivery-missing-business-line.json

@@ -0,0 +1,7 @@
+{
+  "subjectType": "user",
+  "subjectId": "user-123",
+  "scopeType": "delivery",
+  "role": "developer",
+  "enabled": true
+}

package/fixtures/openapi/ScopeGrantInput/invalid/platform-missing-clusters.json

@@ -0,0 +1,7 @@
+{
+  "subjectType": "team",
+  "subjectId": "team-123",
+  "scopeType": "platform",
+  "role": "operator",
+  "enabled": true
+}

package/fixtures/openapi/ScopeGrantInput/valid/platform.json

@@ -0,0 +1,8 @@
+{
+  "subjectType": "team",
+  "subjectId": "team-123",
+  "scopeType": "platform",
+  "clusterIds": ["cluster-123"],
+  "role": "operator",
+  "enabled": true
+}

package/fixtures/openapi/SoftwarePackage/valid/software-package.json

@@ -5,6 +5,10 @@
   "description": "Command-line client for Soha.",
   "publisher": "OpenSoha",
   "category": "Developer Tools",
+  "tenantId": "default",
+  "workspaceId": "default",
+  "visibility": "workspace",
+  "status": "ready",
   "version": "0.1.0",
   "platform": "darwin",
   "arch": "arm64",
@@ -12,6 +16,8 @@
   "sizeBytes": 1048576,
   "sha256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
   "downloadPath": "/api/v1/software/packages/pkg-01j9z3m4w8n2/download",
+  "downloadCount": 12,
+  "storageIntegrationId": "software-object-storage",
   "createdAt": "2026-08-08T00:00:00Z",
   "updatedAt": "2026-08-08T00:00:00Z"
 }

package/fixtures/openapi/SoftwarePackageDownloadRecord/invalid/negative-duration.json

@@ -0,0 +1,6 @@
+{
+  "id": "audit-01j9z3m4w8n2",
+  "actorId": "user-01j9z3m4w8n2",
+  "downloadedAt": "2026-08-27T08:00:00Z",
+  "durationMs": -1
+}

package/fixtures/openapi/SoftwarePackageDownloadRecord/valid/software-package-download-record.json

@@ -0,0 +1,8 @@
+{
+  "id": "audit-01j9z3m4w8n2",
+  "actorId": "user-01j9z3m4w8n2",
+  "actorName": "OpenSoha",
+  "downloadedAt": "2026-08-27T08:00:00Z",
+  "durationMs": 245,
+  "sourceIp": "127.0.0.1"
+}

package/fixtures/openapi/SoftwarePackageURLImportRequest/valid/software-package-url-import-request.json

@@ -4,9 +4,13 @@
   "description": "Desktop client for Soha.",
   "publisher": "OpenSoha",
   "category": "Developer Tools",
+  "tenantId": "default",
+  "workspaceId": "default",
+  "visibility": "workspace",
   "version": "0.2.0",
   "platform": "darwin",
   "arch": "arm64",
+  "storageIntegrationId": "software-object-storage",
   "url": "https://downloads.opensoha.dev/soha-desktop-0.2.0-arm64.dmg",
   "fileName": "soha-desktop-0.2.0-arm64.dmg"
 }

package/fixtures/openapi/SoftwareStorage/invalid/software-storage.json

@@ -1,5 +1,5 @@
 {
-  "backend": "filesystem",
+  "backend": "s3",
   "objectCount": -1,
   "totalBytes": -1,
   "items": []

package/fixtures/openapi/SoftwareStorage/valid/software-storage.json

@@ -1,5 +1,12 @@
 {
-  "backend": "filesystem",
+  "backend": "s3",
+  "integrationId": "software-object-storage",
+  "providerType": "s3",
+  "endpoint": "https://minio.example.com",
+  "bucket": "soha-software",
+  "region": "us-east-1",
+  "healthStatus": "healthy",
+  "lastCheckedAt": "2026-08-25T00:00:00Z",
   "objectCount": 1,
   "totalBytes": 1048576,
   "items": [
@@ -8,6 +15,10 @@
       "softwareId": "soha-cli",
       "name": "Soha CLI",
       "publisher": "OpenSoha",
+      "tenantId": "default",
+      "workspaceId": "default",
+      "visibility": "workspace",
+      "status": "ready",
       "version": "0.1.0",
       "platform": "darwin",
       "arch": "arm64",
@@ -15,6 +26,7 @@
       "sizeBytes": 1048576,
       "sha256": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
       "downloadPath": "/api/v1/software/packages/pkg-01j9z3m4w8n2/download",
+      "storageIntegrationId": "software-object-storage",
       "createdAt": "2026-08-08T00:00:00Z",
       "updatedAt": "2026-08-08T00:00:00Z"
     }

package/fixtures/openapi/SystemIntegrationCreateRequest/invalid/s3-storage-missing-name.json

@@ -0,0 +1,5 @@
+{
+  "category": "storage",
+  "providerType": "s3",
+  "enabled": true
+}

package/fixtures/openapi/SystemIntegrationCreateRequest/valid/s3-software-storage.json

@@ -0,0 +1,18 @@
+{
+  "category": "storage",
+  "providerType": "s3",
+  "name": "Software object storage",
+  "description": "S3-compatible storage for managed software packages.",
+  "enabled": true,
+  "configuration": [
+    { "key": "endpoint", "value": "https://minio.example.com" },
+    { "key": "bucket", "value": "soha-software" },
+    { "key": "region", "value": "us-east-1" },
+    { "key": "path_style", "value": "true" },
+    { "key": "allow_private", "value": "false" }
+  ],
+  "credentials": [
+    { "key": "access_key_id", "value": "fixture-access-key" },
+    { "key": "secret_access_key", "value": "fixture-secret-key" }
+  ]
+}

package/fixtures/openapi/UpdateProfileRequest/invalid/invalid-avatar-fit.json

@@ -0,0 +1,5 @@
+{
+  "displayName": "Ada Lovelace",
+  "email": "ada@example.com",
+  "avatarFit": "stretch"
+}

package/fixtures/openapi/UpdateProfileRequest/invalid/missing-email.json

@@ -0,0 +1,3 @@
+{
+  "displayName": "Ada Lovelace"
+}

package/fixtures/openapi/UpdateProfileRequest/valid/profile.json

@@ -0,0 +1,7 @@
+{
+  "displayName": "Ada Lovelace",
+  "email": "ada@example.com",
+  "phone": "+86 138 0013 8000",
+  "avatarUrl": "https://example.com/avatar.png",
+  "avatarFit": "contain"
+}

package/fixtures/openapi/WorkbenchAgentRunListEnvelope/invalid/callback-token.json

@@ -0,0 +1,17 @@
+{
+  "items": [
+    {
+      "id": "run-1",
+      "providerId": "external-agent",
+      "providerKind": "general",
+      "capabilityId": "root-cause-analysis",
+      "createdBy": "user-1",
+      "status": "running",
+      "callbackToken": "must-not-cross-the-user-api-boundary",
+      "timeoutSeconds": 600,
+      "queuedAt": "2026-08-19T08:00:00Z",
+      "createdAt": "2026-08-19T08:00:00Z",
+      "updatedAt": "2026-08-19T08:01:00Z"
+    }
+  ]
+}

package/fixtures/openapi/WorkbenchAgentRunListEnvelope/valid/session-scoped.json

@@ -0,0 +1,17 @@
+{
+  "items": [
+    {
+      "id": "run-1",
+      "providerId": "external-agent",
+      "providerKind": "general",
+      "capabilityId": "root-cause-analysis",
+      "sessionId": "session-1",
+      "createdBy": "user-1",
+      "status": "running",
+      "timeoutSeconds": 600,
+      "queuedAt": "2026-08-19T08:00:00Z",
+      "createdAt": "2026-08-19T08:00:00Z",
+      "updatedAt": "2026-08-19T08:01:00Z"
+    }
+  ]
+}

package/fixtures/openapi/WorkbenchSessionEnvelope/invalid/missing-owner.json

@@ -0,0 +1,8 @@
+{
+  "data": {
+    "id": "session-1",
+    "title": "Investigate checkout latency",
+    "createdAt": "2026-08-19T08:00:00Z",
+    "updatedAt": "2026-08-19T08:01:00Z"
+  }
+}

package/fixtures/openapi/WorkbenchSessionEnvelope/valid/current.json

@@ -0,0 +1,17 @@
+{
+  "data": {
+    "id": "session-1",
+    "title": "Investigate checkout latency",
+    "createdBy": "user-1",
+    "metadata": {
+      "mode": "root_cause",
+      "status": "active",
+      "scope": {
+        "clusterId": "prod",
+        "namespace": "checkout"
+      }
+    },
+    "createdAt": "2026-08-19T08:00:00Z",
+    "updatedAt": "2026-08-19T08:01:00Z"
+  }
+}

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.14"
+const defaultUserAgent = "opensoha-contracts/0.1.16"
 
 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)