API Reference

Generated gateway API reference grouped by operationId namespace.

This page is generated from the gateway OpenAPI document that drives the JS SDK build.

What you see here is pulled from:

the checked-in OpenAPI document in packages/sdk/openapi.json
the SDK code samples embedded into that document by the gateway generator

Distro exposes the default Aster routes. Gate provides the framework contracts and generation layer. The API reference documents the resulting product API, not a separate Seed-era service.

Curated prose still belongs in the guide pages. This page is intentionally reference-first.

9 operations

Gateway

#gateway

GET /gateway/v1/internal/event

Deprecated runtime event stream

Removed legacy SSE runtime stream. Use the runtime WebSocket transport instead.

Response

{
  ok: true
  data: {
  removed: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.event.deprecated({
  ...
})

POST /gateway/v1/internal/event/socket-ticket

Deprecated runtime socket ticket

Removed legacy gateway event socket ticket endpoint. Use the runtime lease endpoint instead.

Response

{
  ok: true
  data: {
  removed: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.event.socketTicket({
  ...
})

GET /gateway/health

Gateway health

Gateway liveness check

Response

{
  ok: true
  data: GatewayHealthData = {
  status: "healthy"
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.health({
  ...
})

POST /gateway/v1/internal/managed-app-connections

Create managed app connection

Create a gateway-owned app credential for a runtime-managed plugin app.

Request

{
  appId: string
  name?: string | null | null
  appVersion?: string | null | null
  deviceName?: string | null | null
  scopes?: string[] | null
  spaceSlugs?: string[] | null
}

Response

{
  ok: true
  data: {
  connection: GatewayInternalManagedAppConnection = { ... }
  token: string
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.internal.managedAppConnection.create({
  ...
})

POST /gateway/v1/internal/managed-app-connections/{connectionId}/revoke

Revoke managed app connection

Parameters

connectionId · path · required

Response

{
  ok: true
  data: {
  connectionId: string
  revoked: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.internal.managedAppConnection.revoke({
  ...
})

POST /gateway/v1/internal/services/permission-authorize

Authorize runtime permission request

Block on a runtime-authenticated permission request until policy resolves it

Request

{
  requestId?: string | null
  permissionProviderId?: string | null
  permission: string
  patterns: unknown
  always?: string[] | null
  metadata?: { [key: string]: unknown } | null
  scope?: string | null
  timeoutMs?: unknown | null
  source?: string | null
}

Response

{
  ok: true
  data: {
  decision: "allow" | "deny"
  message?: string | null
  restartRequired?: boolean | null
  mount?: GatewayInternalAdditionalMount | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.internal.permissionAuthorize({
  ...
})

POST /gateway/v1/internal/runtime-event

Forward runtime event

Forward runtime-authenticated runtime event envelope to gateway stream subscribers

Request

{
  event: GatewayInternalRuntimeEventEnvelope = RuntimeEventEnvelope.server.connected | RuntimeEventEnvelope.server.heartbeat | RuntimeEventEnvelope.runtime.app_event.claimed | RuntimeEventEnvelope.runtime.app_event.completed | RuntimeEventEnvelope.runtime.app_event.failed | RuntimeEventEnvelope.runtime.app_ingress.dropped | RuntimeEventEnvelope.runtime.app_ingress.failed | RuntimeEventEnvelope.runtime.app_channel.outbound_message | RuntimeEventEnvelope.runtime.app_channel.outbound_typing | RuntimeEventEnvelope.runtime.configuration.updated | RuntimeEventEnvelope.runtime.mcp_status.upserted | RuntimeEventEnvelope.runtime.session.updated | RuntimeEventEnvelope.runtime.permission.asked | RuntimeEventEnvelope.runtime.permission.replied | RuntimeEventEnvelope.runtime.mcp_elicitation.asked | RuntimeEventEnvelope.runtime.mcp_elicitation.replied | RuntimeEventEnvelope.runtime.interaction.asked | RuntimeEventEnvelope.runtime.interaction.replied | RuntimeEventEnvelopeRuntimeAppEventQueued | RuntimeEventEnvelopeRuntimeIntentIngressRoutingProgress | RuntimeEventEnvelopeRuntimeInvocationStarted | RuntimeEventEnvelopeRuntimeInvocationUpdated | RuntimeEventEnvelopeRuntimeInvocationResponseFinished | RuntimeEventEnvelopeRuntimeInvocationFailedOrFinished | RuntimeEventEnvelopeResourceLiveDiff | RuntimeEventEnvelopeResourceSettledDiff
}

Response

{
  ok: true
  data: {
  accepted: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.internal.runtimeEvent({
  ...
})

POST /gateway/v1/internal/runtime-ready

Mark runtime instance ready

Store runtime-authenticated readiness for a spawned user runtime

Request

{
  runtimeInstanceId: string
  leaseSecret: string
  socket: {
  host?: string | null | null
  port: unknown & unknown
  path?: string | null | null
  maxFrameBytes?: unknown | null | null
}
}

Response

{
  ok: true
  data: {
  accepted: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.internal.runtimeReady({
  ...
})

GET /gateway/ready

Gateway readiness

Gateway readiness check

Response

{
  ok: true
  data: GatewayReadyData = {
  status: "ready"
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gateway.ready({
  ...
})

20 operations

Spaces

#spaces

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/doctrine/promotion-drafts/confirm

Confirm an unchanged host-authored Doctrine promotion draft

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "doctrine-promotion-draft.v1"
  draft: {
  schemaVersion: "doctrine-promotion-draft.v1"
  draftRef: unknown
  proposalId: ResourceDescriptorSchemaVersion = string
  expectedUpdatedAt: ResourceDescriptorSchemaVersion = string
  createdAt: ResourceDescriptorSchemaVersion = string
  expiresAt: ResourceDescriptorSchemaVersion = string
  summary: {
  sourceEntryId: ResourceDescriptorSchemaVersion
  sourceVersion: unknown
  targetScope: { ... } | { ... } | { ... }
  verifierId: ResourceDescriptorSchemaVersion
  executionClass: ResourceDescriptorSchemaVersion
  target: { ... } | { ... }
}
  command: {
  schemaVersion: "doctrine-promotion-command.v1"
  promotionId: ResourceDescriptorSchemaVersion
  evaluation: { ... }
  plan: { ... } | { ... }
}
}
}

Response

{
  ok: boolean
  data: DoctrinePromotionCommandResult = {
  schemaVersion: "doctrine-promotion-result.v1"
  promotionId: ResourceDescriptorSchemaVersion
  intentDigest: unknown
  state: "completed"
  evaluationReceiptRef: WorkEvidenceRef
  authorizationReceiptRef: WorkEvidenceRef
  plan: { ... } | { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.doctrine.promotionDrafts.confirm({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/doctrine/promotion-drafts

Plan a host-authored Doctrine promotion draft

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "doctrine-promotion-draft.v1"
  proposalId: ResourceDescriptorSchemaVersion = string
  expectedUpdatedAt: ResourceDescriptorSchemaVersion = string
  activation: {
  kind: "publish_policy"
  policy: PublishPolicy
  protectedBranch: ResourceDescriptorSchemaVersion
} | {
  kind: "standing_workflow"
  address: { ... }
  proposalId: ResourceDescriptorSchemaVersion
  recurrenceEvidenceId: ResourceDescriptorSchemaVersion
}
}

Response

{
  ok: boolean
  data: DoctrinePromotionDraft = {
  schemaVersion: "doctrine-promotion-draft.v1"
  draftRef: unknown
  proposalId: ResourceDescriptorSchemaVersion
  expectedUpdatedAt: ResourceDescriptorSchemaVersion
  createdAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  summary: { ... }
  command: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.doctrine.promotionDrafts.create({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/environment

Inspect Space environment

Parameters

spaceSlug · path · required
workId · query

Response

{
  spaceSlug: ResourceDescriptorSchemaVersion = string
  environment: {
  schemaVersion: "space-environment.v1"
  spaceId: ResourceDescriptorSchemaVersion = string
  displayName: ResourceDescriptorSchemaVersion = string
  description?: ResourceDescriptorSchemaVersion | null
  policies: {
  defaultEvidencePolicy: { ... }
  allowedAuthorities: ResourceDescriptorSchemaVersion[]
  routeTags: ResourceDescriptorSchemaVersion[]
  nonDelegable?: boolean | null
}
  roles: { ... }[]
  services: { ... }[]
  workflows: { ... }[]
  tools: { ... }[]
  exports: { ... }[]
  imports: { ... }[]
  metadata?: { [key: string]: unknown } | null
}
  importResolutions: {
  importId: ResourceDescriptorSchemaVersion
  fromSpace: ResourceDescriptorSchemaVersion
  exportRef: ResourceDescriptorSchemaVersion
  status: "resolved" | "missing" | "ambiguous"
  exportDeclaration?: { ... } | null
  diagnostics: { ... }[]
}[]
  importAuthority: {
  importId: ResourceDescriptorSchemaVersion
  fromSpace: ResourceDescriptorSchemaVersion
  exportRef: ResourceDescriptorSchemaVersion
  requiredScopes: ResourceDescriptorSchemaVersion[]
  status: "not_required" | "granted" | "missing"
  grantIds: ResourceDescriptorSchemaVersion[]
  evidenceRefs: WorkEvidenceRef[]
}[]
  callables: {
  kind: "role" | "service" | "workflow" | "tool" | "export"
  id: ResourceDescriptorSchemaVersion
  displayName: ResourceDescriptorSchemaVersion
  available: boolean
  source: "environment" | "projection"
  routeMode?: ResourceDescriptorSchemaVersion | null
  authority: { ... }[]
  tags: ResourceDescriptorSchemaVersion[]
}[]
  diagnostics: {
  code: "composition_diagnostic" | "cross_space_authority_granted" | "cross_space_authority_missing" | "space_not_found" | "work_not_found"
  severity: "info" | "warning" | "error"
  message: ResourceDescriptorSchemaVersion
  importId?: ResourceDescriptorSchemaVersion | null
  fromSpace?: ResourceDescriptorSchemaVersion | null
  exportRef?: ResourceDescriptorSchemaVersion | null
  scope?: ResourceDescriptorSchemaVersion | null
  subject?: ResourceDescriptorSchemaVersion | null
}[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.environment.get({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/evidence-search/rebuild

Rebuild Space Evidence Search

Parameters

spaceSlug · path · required

Request

{
  confirmation: "rebuild"
}

Response

{
  userId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  providerId: ResourceDescriptorSchemaVersion = string
  generation: unknown
  admitted: unknown
  skipped: unknown
  drained: unknown
  verificationQueryCount: unknown
  resultsIdentical: true
  state: {
  userId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  providerId: ResourceDescriptorSchemaVersion | null
  readiness: "disabled" | "ready" | "lagging" | "rebuilding" | "unavailable"
  generation: unknown | null
  documentCount: unknown
  lastAppliedCursor: ResourceDescriptorSchemaVersion | null
  pendingJobs: unknown
  failure: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.evidenceSearch.rebuild({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/evidence-search

Get Space Evidence Search status

Parameters

spaceSlug · path · required

Response

{
  userId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  providerId: ResourceDescriptorSchemaVersion = string | null
  readiness: "disabled" | "ready" | "lagging" | "rebuilding" | "unavailable"
  generation: unknown | null
  documentCount: unknown
  lastAppliedCursor: ResourceDescriptorSchemaVersion = string | null
  pendingJobs: unknown
  failure: {
  code: ResourceDescriptorSchemaVersion
  message: ResourceDescriptorSchemaVersion
  retryable: boolean
} | null
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.evidenceSearch.status({
  ...
})

PUT /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed

Apply an exactly reviewed Space instruction seed

Parameters

spaceSlug · path · required

Request

{
  source: string
  expectedParentVersion: unknown | null
  previewHash: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: SpaceInstructionSeedApplyResult = {
  preview: { ... }
  entry: { ... }
  applicationReceiptRef: { ... }
  activation: { ... } | { ... } | { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.apply({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed

Read authoritative Space instruction activation

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: SpaceInstructionSeedState = {
  schemaVersion: "space-instruction-seed.v1"
  spaceSlug: ResourceDescriptorSchemaVersion
  scope: { ... }
  entryId: ResourceDescriptorSchemaVersion
  source: string
  currentVersion: unknown | null
  activation: { ... } | { ... } | { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.get({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed/predecessors

Read the durable instruction predecessor census

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: SpaceInstructionPredecessorCensus = {
  schemaVersion: "space-instruction-predecessor-census.v1"
  spaceSlug: ResourceDescriptorSchemaVersion
  sources: { ... }[]
  unresolvedCount: unknown
  principalUnresolvedCount: unknown
  flipEligible: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.predecessors({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed/predecessors/apply

Apply one exact predecessor fingerprint

Parameters

spaceSlug · path · required

Request

{
  sourceId: ResourceDescriptorSchemaVersion = string
  fingerprint: ResourceDescriptorSchemaVersion = string
  reviewedFileContent?: ResourceDescriptorSchemaVersion = string | null
  previewHash: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: SpaceInstructionPredecessorApplyResult = {
  migration: { ... }
  application: { ... }
  dispositionReceiptRef: WorkEvidenceRef
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.predecessorsApply({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed/predecessors/discard

Discard one exact predecessor fingerprint with Evidence

Parameters

spaceSlug · path · required

Request

{
  sourceId: ResourceDescriptorSchemaVersion = string
  fingerprint: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: SpaceInstructionPredecessorDiscardResult = {
  source: { ... }
  dispositionReceiptRef: WorkEvidenceRef
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.predecessorsDiscard({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed/predecessors/preview

Preview one exact predecessor migration

Parameters

spaceSlug · path · required

Request

{
  sourceId: ResourceDescriptorSchemaVersion = string
  fingerprint: ResourceDescriptorSchemaVersion = string
  reviewedFileContent?: ResourceDescriptorSchemaVersion = string | null
}

Response

{
  ok: boolean
  data: SpaceInstructionPredecessorPreview = {
  source: { ... }
  combinedSource: string
  preview: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.predecessorsPreview({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/instruction-seed/preview

Preview exact Space instruction placement

Parameters

spaceSlug · path · required

Request

{
  source: string
  expectedParentVersion: unknown | null
}

Response

{
  ok: boolean
  data: SpaceInstructionSeedPreview = {
  schemaVersion: "space-instruction-seed.v1"
  spaceSlug: ResourceDescriptorSchemaVersion
  scope: { ... }
  entryId: ResourceDescriptorSchemaVersion
  source: string
  currentVersion: unknown | null
  activation: { ... } | { ... } | { ... }
  sourceHash: ResourceDescriptorSchemaVersion
  previewHash: ResourceDescriptorSchemaVersion
  entries: { ... }[]
  placementDiff: { ... }[]
  lints: { ... }[]
  promotionOffers: { ... } | { ... } | { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.instructionSeed.preview({
  ...
})

GET /gateway/v1/internal/spaces

List spaces

List spaces available to the runtime user

Parameters

chatJid · query

Response

{
  ok: boolean
  data: {
  spaces: GatewayUserSpace[]
  consequence: SpaceConsequenceRollup[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.spaces.list({
  ...
})

GET /gateway/v1/internal/spaces/model

Space model catalog

List model choices and strict variant options for a space

Parameters

spaceSlug · query

Response

{
  ok: boolean
  data: SpaceModelCatalogResult = {
  spaceSlug: ResourceDescriptorSchemaVersion
  roleId: ResourceDescriptorSchemaVersion | null
  roleRef: string | null
  defaultModel: { ... } | null
  effectiveModel: { ... } | null
  overrideModel: { ... } | null
  models: { ... }[]
  roleModelCatalogs: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.spaces.model({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/retention/delete-space

Delete Space through retention

Parameters

spaceSlug · path · required

Request

{
  previewToken: ResourceDescriptorSchemaVersion = string
  confirmation: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "space-retention-job.v1"
  jobId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "work"
  spaceId: ResourceDescriptorSchemaVersion
  taskId: ResourceDescriptorSchemaVersion
  workId: ResourceDescriptorSchemaVersion
} | {
  kind: "task"
  spaceId: ResourceDescriptorSchemaVersion
  taskId: ResourceDescriptorSchemaVersion
} | {
  kind: "task_set"
  spaceId: ResourceDescriptorSchemaVersion
  taskIds: ResourceDescriptorSchemaVersion[]
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
} | {
  kind: "user"
  userId: ResourceDescriptorSchemaVersion
}
  trigger: "scheduled" | "run_now" | "task_delete" | "space_delete" | "user_delete"
  status: "queued" | "rechecking" | "deleting" | "retrying" | "completed" | "failed_terminal"
  policyHash?: ResourceDescriptorSchemaVersion = string | null
  attempt: unknown
  createdAt: ResourceDescriptorSchemaVersion = string
  updatedAt: ResourceDescriptorSchemaVersion = string
  retryAt?: ResourceDescriptorSchemaVersion = string | null
  completedAt?: ResourceDescriptorSchemaVersion = string | null
  blockers: {
  code: ResourceDescriptorSchemaVersion
  message: ResourceDescriptorSchemaVersion
  participantId?: ResourceDescriptorSchemaVersion | null
  taskId?: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  details?: { [key: string]: unknown } | null
}[]
  participantReceipts: {
  participantId: ResourceDescriptorSchemaVersion
  idempotencyKey: ResourceDescriptorSchemaVersion
  completedAt: ResourceDescriptorSchemaVersion
  deletedCounts: { ... }
  deletedStorage: { ... }
  details?: { [key: string]: unknown } | null
}[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.retention.deleteSpace({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/retention/deletion-preview

Preview Space deletion

Parameters

spaceSlug · path · required

Request

{
  expectedDeclarationHash: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "space-retention-preview.v1"
  previewToken: ResourceDescriptorSchemaVersion = string
  expiresAt: ResourceDescriptorSchemaVersion = string
  declarationHash: ResourceDescriptorSchemaVersion = string
  policyHash: ResourceDescriptorSchemaVersion = string
  inventoryWatermark: ResourceDescriptorSchemaVersion = string
  inventory: {
  spaceId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  generatedAt: ResourceDescriptorSchemaVersion = string
  policy: {
  requested: { ... }
  effective: { ... }
  limits: { ... }
}
  counts: {
  tasks: unknown
  workItems: unknown
  evidenceRecords: unknown
  receipts: unknown
  projections: unknown
  artifacts: unknown
  artifactObjects: unknown
  telemetryRows: unknown
}
  storage: {
  bytes: unknown
  accuracy: "exact" | "estimated"
}
  oldestTerminalAt?: ResourceDescriptorSchemaVersion | null
  newestTerminalAt?: ResourceDescriptorSchemaVersion | null
  nextEligibleAt?: ResourceDescriptorSchemaVersion | null
  candidates: { ... }[]
  blockers: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.retention.deletionPreview({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/retention/preview

Preview Space retention

Parameters

spaceSlug · path · required

Request

{
  policy: {
  schemaVersion: "space-retention-policy.v1"
  terminalWork: { ... } | { ... }
  telemetry: {
  kind: "delete_after"
  days: unknown & unknown
}
}
  expectedDeclarationHash: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "space-retention-preview.v1"
  previewToken: ResourceDescriptorSchemaVersion = string
  expiresAt: ResourceDescriptorSchemaVersion = string
  declarationHash: ResourceDescriptorSchemaVersion = string
  policyHash: ResourceDescriptorSchemaVersion = string
  inventoryWatermark: ResourceDescriptorSchemaVersion = string
  inventory: {
  spaceId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  generatedAt: ResourceDescriptorSchemaVersion = string
  policy: {
  requested: { ... }
  effective: { ... }
  limits: { ... }
}
  counts: {
  tasks: unknown
  workItems: unknown
  evidenceRecords: unknown
  receipts: unknown
  projections: unknown
  artifacts: unknown
  artifactObjects: unknown
  telemetryRows: unknown
}
  storage: {
  bytes: unknown
  accuracy: "exact" | "estimated"
}
  oldestTerminalAt?: ResourceDescriptorSchemaVersion | null
  newestTerminalAt?: ResourceDescriptorSchemaVersion | null
  nextEligibleAt?: ResourceDescriptorSchemaVersion | null
  candidates: { ... }[]
  blockers: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.retention.preview({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/retention/run

Run Space retention

Parameters

spaceSlug · path · required

Request

{
  previewToken: ResourceDescriptorSchemaVersion = string
}

Response

{
  jobs: {
  schemaVersion: "space-retention-job.v1"
  jobId: ResourceDescriptorSchemaVersion
  scope: { ... } | { ... } | { ... } | { ... } | { ... }
  trigger: "scheduled" | "run_now" | "task_delete" | "space_delete" | "user_delete"
  status: "queued" | "rechecking" | "deleting" | "retrying" | "completed" | "failed_terminal"
  policyHash?: ResourceDescriptorSchemaVersion | null
  attempt: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  retryAt?: ResourceDescriptorSchemaVersion | null
  completedAt?: ResourceDescriptorSchemaVersion | null
  blockers: { ... }[]
  participantReceipts: { ... }[]
}[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.retention.run({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/retention

Get Space retention status

Parameters

spaceSlug · path · required

Response

{
  spaceId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  declarationHash: ResourceDescriptorSchemaVersion = string
  policy: {
  requested: {
  schemaVersion: "space-retention-policy.v1"
  terminalWork: { ... } | { ... }
  telemetry: { ... }
}
  effective: {
  schemaVersion: "space-retention-policy.v1"
  terminalWork: { ... } | { ... }
  telemetry: { ... }
}
  limits: {
  maximumTerminalWorkDays?: unknown & unknown | null
  maximumTelemetryDays?: unknown & unknown | null
  backupMaximumAgeDays?: unknown & unknown | null
}
}
  inventory: {
  spaceId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  generatedAt: ResourceDescriptorSchemaVersion = string
  policy: {
  requested: { ... }
  effective: { ... }
  limits: { ... }
}
  counts: {
  tasks: unknown
  workItems: unknown
  evidenceRecords: unknown
  receipts: unknown
  projections: unknown
  artifacts: unknown
  artifactObjects: unknown
  telemetryRows: unknown
}
  storage: {
  bytes: unknown
  accuracy: "exact" | "estimated"
}
  oldestTerminalAt?: ResourceDescriptorSchemaVersion | null
  newestTerminalAt?: ResourceDescriptorSchemaVersion | null
  nextEligibleAt?: ResourceDescriptorSchemaVersion | null
  candidates: { ... }[]
  blockers: { ... }[]
}
  nextScheduledAt?: ResourceDescriptorSchemaVersion = string | null
  lastCompletedAt?: ResourceDescriptorSchemaVersion = string | null
  jobs: {
  schemaVersion: "space-retention-job.v1"
  jobId: ResourceDescriptorSchemaVersion
  scope: { ... } | { ... } | { ... } | { ... } | { ... }
  trigger: "scheduled" | "run_now" | "task_delete" | "space_delete" | "user_delete"
  status: "queued" | "rechecking" | "deleting" | "retrying" | "completed" | "failed_terminal"
  policyHash?: ResourceDescriptorSchemaVersion | null
  attempt: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  retryAt?: ResourceDescriptorSchemaVersion | null
  completedAt?: ResourceDescriptorSchemaVersion | null
  blockers: { ... }[]
  participantReceipts: { ... }[]
}[]
  receipts: {
  schemaVersion: "space-retention-receipt.v1"
  receiptId: ResourceDescriptorSchemaVersion
  jobId: ResourceDescriptorSchemaVersion
  scopeHash: ResourceDescriptorSchemaVersion
  policyHash?: ResourceDescriptorSchemaVersion | null
  completedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  deletedCounts: { ... }
  deletedStorage: { ... }
  participantReceipts: { ... }[]
  backupTombstoneId: ResourceDescriptorSchemaVersion
}[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.retention.status({
  ...
})

PUT /gateway/v1/internal/users/me/spaces/{spaceSlug}/retention

Update Space retention

Parameters

spaceSlug · path · required

Request

{
  policy: {
  schemaVersion: "space-retention-policy.v1"
  terminalWork: { ... } | { ... }
  telemetry: {
  kind: "delete_after"
  days: unknown & unknown
}
}
  expectedDeclarationHash: ResourceDescriptorSchemaVersion = string
  previewToken: ResourceDescriptorSchemaVersion = string
}

Response

{
  spaceId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  declarationHash: ResourceDescriptorSchemaVersion = string
  policy: {
  requested: {
  schemaVersion: "space-retention-policy.v1"
  terminalWork: { ... } | { ... }
  telemetry: { ... }
}
  effective: {
  schemaVersion: "space-retention-policy.v1"
  terminalWork: { ... } | { ... }
  telemetry: { ... }
}
  limits: {
  maximumTerminalWorkDays?: unknown & unknown | null
  maximumTelemetryDays?: unknown & unknown | null
  backupMaximumAgeDays?: unknown & unknown | null
}
}
  inventory: {
  spaceId: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  generatedAt: ResourceDescriptorSchemaVersion = string
  policy: {
  requested: { ... }
  effective: { ... }
  limits: { ... }
}
  counts: {
  tasks: unknown
  workItems: unknown
  evidenceRecords: unknown
  receipts: unknown
  projections: unknown
  artifacts: unknown
  artifactObjects: unknown
  telemetryRows: unknown
}
  storage: {
  bytes: unknown
  accuracy: "exact" | "estimated"
}
  oldestTerminalAt?: ResourceDescriptorSchemaVersion | null
  newestTerminalAt?: ResourceDescriptorSchemaVersion | null
  nextEligibleAt?: ResourceDescriptorSchemaVersion | null
  candidates: { ... }[]
  blockers: { ... }[]
}
  nextScheduledAt?: ResourceDescriptorSchemaVersion = string | null
  lastCompletedAt?: ResourceDescriptorSchemaVersion = string | null
  jobs: {
  schemaVersion: "space-retention-job.v1"
  jobId: ResourceDescriptorSchemaVersion
  scope: { ... } | { ... } | { ... } | { ... } | { ... }
  trigger: "scheduled" | "run_now" | "task_delete" | "space_delete" | "user_delete"
  status: "queued" | "rechecking" | "deleting" | "retrying" | "completed" | "failed_terminal"
  policyHash?: ResourceDescriptorSchemaVersion | null
  attempt: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  retryAt?: ResourceDescriptorSchemaVersion | null
  completedAt?: ResourceDescriptorSchemaVersion | null
  blockers: { ... }[]
  participantReceipts: { ... }[]
}[]
  receipts: {
  schemaVersion: "space-retention-receipt.v1"
  receiptId: ResourceDescriptorSchemaVersion
  jobId: ResourceDescriptorSchemaVersion
  scopeHash: ResourceDescriptorSchemaVersion
  policyHash?: ResourceDescriptorSchemaVersion | null
  completedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  deletedCounts: { ... }
  deletedStorage: { ... }
  participantReceipts: { ... }[]
  backupTombstoneId: ResourceDescriptorSchemaVersion
}[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaces.retention.update({
  ...
})

95 operations

Users

#users

GET /gateway/v1/internal/users/{userId}/auth/password

Get user password status

Parameters

userId · path · required

Response

{
  ok: true
  data: {
  userId: string
  password: GatewayUserPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.auth.password.get({
  ...
})

POST /gateway/v1/internal/users/{userId}/auth/password

Set user password

Parameters

userId · path · required

Request

{
  password: string
}

Response

{
  ok: true
  data: {
  userId: string
  password: GatewayUserPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.auth.password.set({
  ...
})

POST /gateway/v1/internal/users/{userId}/auth/tokens

Create user access token

Parameters

userId · path · required

Request

{
  name?: string | null
}

Response

{
  ok: true
  data: {
  userId: string
  token: string
  tokenInfo: GatewayUserAccessToken = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.auth.tokens.create({
  ...
})

GET /gateway/v1/internal/users/{userId}/auth/tokens

List user access tokens

Parameters

userId · path · required

Response

{
  ok: true
  data: {
  userId: string
  tokens: GatewayUserAccessToken[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.auth.tokens.list({
  ...
})

POST /gateway/v1/internal/users/me/auth/tokens/refresh

Refresh current user access token

Response

{
  ok: true
  data: {
  token: string
  tokenInfo: GatewayUserAccessToken = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.auth.tokens.refresh()

DELETE /gateway/v1/internal/users/{userId}/auth/tokens/{tokenId}

Revoke user access token

Parameters

userId · path · required
tokenId · path · required

Response

{
  ok: true
  data: {
  userId: string
  tokenId: string
  revoked: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.auth.tokens.revoke({
  ...
})

POST /gateway/v1/internal/users

Create user

Create or upsert a runtime user

Request

{
  userId: string
  password: string
  serverPassword?: string | null
}

Response

{
  ok: true
  data: {
  user: GatewayUser = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.create({
  ...
})

DELETE /gateway/v1/internal/users/{userId}

Delete user

Parameters

userId · path · required

Response

{
  ok: true
  data: {
  removed: boolean
  userId: string
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.delete({
  ...
})

POST /gateway/v1/internal/users/installables/update-outdated

Update outdated installables for every active user

Response

{
  ok: true
  data: {
  checked: unknown
  updated: unknown
  skipped: unknown
  failed: unknown
  items: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.installables.updateOutdated({
  ...
})

GET /gateway/v1/internal/users

List users

List known control-plane users

Parameters

includeInactive · query

Response

{
  ok: true
  data: {
  users: GatewayUser[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.list({
  ...
})

GET /gateway/v1/internal/users/me/apps

List current user app connections

Response

{
  ok: true
  data: {
  userId: string
  connections: GatewayUserAppConnection[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.apps.list({
  ...
})

POST /gateway/v1/internal/users/me/apps/pair-requests/{pairRequestId}/approve

Approve pending app pair request

Parameters

pairRequestId · path · required

Request

{
  scopes?: string[] | null
  spaceSlugs?: string[] | null
}

Response

{
  ok: true
  data: {
  request: GatewayAppPairRequest = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.apps.pairRequests.approve({
  ...
})

POST /gateway/v1/internal/users/me/apps/pair-requests/{pairRequestId}/deny

Deny pending app pair request

Parameters

pairRequestId · path · required

Response

{
  ok: true
  data: {
  request: GatewayAppPairRequest = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.apps.pairRequests.deny({
  ...
})

GET /gateway/v1/internal/users/me/apps/pair-requests

List pending app pair requests

Response

{
  ok: true
  data: {
  requests: GatewayAppPairRequest[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.apps.pairRequests.list({
  ...
})

POST /gateway/v1/internal/users/me/apps/{connectionId}/revoke

Revoke current user app connection

Parameters

connectionId · path · required

Response

{
  ok: true
  data: {
  userId: string
  connectionId: string
  revoked: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.apps.revoke({
  ...
})

DELETE /gateway/v1/internal/users/me/apps/revoked

Delete revoked current user app connections

Response

{
  ok: true
  data: {
  userId: string
  deleted: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.apps.revoked.delete({
  ...
})

GET /gateway/v1/internal/users/me/auth/password

Get current user password status

Response

{
  ok: true
  data: {
  userId: string
  password: GatewayUserPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.password.get({
  ...
})

POST /gateway/v1/internal/users/me/auth/password

Set current user password

Request

{
  password: string
  currentPassword?: string | null
}

Response

{
  ok: true
  data: {
  userId: string
  password: GatewayUserPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.password.set({
  ...
})

PUT /gateway/v1/internal/users/me/auth/providers/{providerId}/api-key

Set current user provider API key

Parameters

providerId · path · required

Request

{
  apiKey: string
}

Response

{
  ok: true
  data: {
  providerId: string
  cleared?: boolean | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.providers.apiKey.set({
  ...
})

DELETE /gateway/v1/internal/users/me/auth/providers/{providerId}

Clear current user provider auth

Parameters

providerId · path · required

Response

{
  ok: true
  data: {
  providerId: string
  cleared?: boolean | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.providers.clear({
  ...
})

GET /gateway/v1/internal/users/me/auth/providers

List current user auth providers

Response

{
  ok: true
  data: {
  providers: GatewayProviderAuthProvider[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.providers.list({
  ...
})

POST /gateway/v1/internal/users/me/auth/providers/{providerId}/oauth/authorize

Start current user provider OAuth

Parameters

providerId · path · required

Response

{
  ok: true
  data: {
  step: GatewayProviderAuthStep = { ... } | { ... } | { ... } | { ... } | { ... } | { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.providers.oauth.authorize({
  ...
})

POST /gateway/v1/internal/users/me/auth/providers/{providerId}/oauth/callback

Continue current user provider OAuth

Parameters

providerId · path · required

Request

{
  loginId: string
  value?: string | null
}

Response

{
  ok: true
  data: {
  step: GatewayProviderAuthStep = { ... } | { ... } | { ... } | { ... } | { ... } | { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.auth.providers.oauth.callback({
  ...
})

DELETE /gateway/v1/internal/users/me/contributions/{contributionId}

Delete current user installed contribution

Parameters

contributionId · path · required

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.contributions.delete({
  ...
})

POST /gateway/v1/internal/users/me/contributions/import-local

Import current user contribution from local folder

Request

{ [key: string]: unknown }

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.contributions.importLocal({
  ...
})

GET /gateway/v1/internal/users/me/contributions

List current user installed contributions

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.contributions.list({
  ...
})

POST /gateway/v1/internal/users/me/contributions/{contributionId}/reload

Reload current user installed contribution

Parameters

contributionId · path · required

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.contributions.reload({
  ...
})

PATCH /gateway/v1/internal/users/me/contributions/{contributionId}/status

Set current user installed contribution status

Parameters

contributionId · path · required

Request

{ [key: string]: unknown }

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.contributions.status.patch({
  ...
})

POST /gateway/v1/internal/users/me/default-space

Set current user default space

Request

{
  spaceId?: string | null
  spaceSlug?: string | null
}

Response

{
  ok: true
  data: {
  user: GatewayUser = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.defaultSpace.set({
  ...
})

POST /gateway/v1/internal/users/me/dictation/cancel

Cancel current user dictation

Response

{
  ok: true
  data: {
  state: "idle" | "recording"
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.dictation.cancel({
  ...
})

GET /gateway/v1/internal/users/me/dictation

Get current user dictation services

Response

{
  ok: true
  data: GatewayDictationSelection = {
  selectedDictationServiceId: string | null
  selectionMode: "auto" | "none" | "selected"
  services: GatewayDictationService[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.dictation.get({
  ...
})

POST /gateway/v1/internal/users/me/dictation/service

Set current user dictation service

Request

{
  dictationServiceId: string | null
}

Response

{
  ok: true
  data: GatewayDictationSelection = {
  selectedDictationServiceId: string | null
  selectionMode: "auto" | "none" | "selected"
  services: GatewayDictationService[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.dictation.service.set({
  ...
})

POST /gateway/v1/internal/users/me/dictation/start

Start current user dictation

Response

{
  ok: true
  data: {
  state: "idle" | "recording"
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.dictation.start({
  ...
})

POST /gateway/v1/internal/users/me/dictation/stop

Stop current user dictation

Response

{
  ok: true
  data: {
  text: string
  model: string
  backend: string
  language?: string | null
  durationSeconds: number | "NaN" | "Infinity" | "-Infinity" | "Infinity" | "-Infinity" | "NaN"
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.dictation.stop({
  ...
})

GET /gateway/v1/internal/users/me

Get current user

Response

{
  ok: true
  data: {
  user: GatewayUser = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.get({
  ...
})

POST /gateway/v1/internal/users/me/installable-images/resolve

Resolve current user installable image

Request

{
  kind: "marketplace_bundle"
  repoId: string
  bundleId: string
} | {
  kind: string
} | {
  kind: "installed_skill"
  skillId: string
} | {
  kind: "installed_tool"
  toolPackageId: string
} | {
  kind: "service_plugin"
  pluginId: string
}

Response

{
  ok: true
  data: {
  dataUrl: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.installableImages.resolve({
  ...
})

GET /gateway/v1/internal/users/me/installables/available/bundle/{repoId}/{bundleId}

Get current user available marketplace bundle detail

Parameters

repoId · path · required
bundleId · path · required

Response

{
  ok: true
  data: {
  userId: string
  detail: GatewayInstallableDetail = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.installables.available.detail({
  ...
})

GET /gateway/v1/internal/users/me/installables/installed/{kind}/{installedId}

Get current user installed installable detail

Parameters

kind · path · required
installedId · path · required

Response

{
  ok: true
  data: {
  userId: string
  detail: GatewayInstallableDetail = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.installables.installed.detail({
  ...
})

GET /gateway/v1/internal/users/me/keybindings

Get current user keybindings

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.keybindings.get({
  ...
})

DELETE /gateway/v1/internal/users/me/marketplace/auth/github

Clear current user GitHub marketplace token

Response

{
  ok: true
  data: {
  connected: boolean
  updatedAt: string | null
  cleared?: boolean | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplace.auth.github.clear({
  ...
})

GET /gateway/v1/internal/users/me/marketplace/auth/github

Get current user GitHub marketplace auth status

Response

{
  ok: true
  data: {
  connected: boolean
  updatedAt: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplace.auth.github.get({
  ...
})

PUT /gateway/v1/internal/users/me/marketplace/auth/github

Store current user GitHub marketplace token

Request

{
  token: string
}

Response

{
  ok: true
  data: {
  connected: boolean
  updatedAt: string | null
  cleared?: boolean | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplace.auth.github.set({
  ...
})

POST /gateway/v1/internal/users/me/marketplace/install

Install one marketplace primitive for current user

Request

{
  bundleId: string
  repoId?: string
  enabled?: boolean
}

Response

{
  ok: true
  data: {
  userId: string
  item: GatewayMarketplacePrimitive = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplace.install({
  ...
})

POST /gateway/v1/internal/users/me/marketplace/items/install

Install one marketplace primitive for current user

Request

{
  bundleId: string
  repoId?: string
  enabled?: boolean
}

Response

{
  ok: true
  data: {
  userId: string
  item: GatewayMarketplacePrimitive = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplace.items.install({
  ...
})

GET /gateway/v1/internal/users/me/marketplace/items

List available marketplace primitives for current user

Parameters

query · query
payloadKind · query
repoId · query

Response

{
  ok: true
  data: {
  userId: string
  items: GatewayMarketplacePrimitive[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplace.items.list({
  ...
})

DELETE /gateway/v1/internal/users/me/marketplace-repos/{repoId}

Delete current user marketplace repo

Parameters

repoId · path · required

Response

{
  ok: true
  data: {
  userId: string
  repoId: string
  deleted: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplaceRepos.delete({
  ...
})

GET /gateway/v1/internal/users/me/marketplace-repos

List current user marketplace repos

Response

{
  ok: true
  data: {
  userId: string
  repos: GatewayMarketplaceRepo[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplaceRepos.list({
  ...
})

POST /gateway/v1/internal/users/me/marketplace-repos

Add or update current user marketplace repo

Request

{
  sourceKind: "local"
  repoId: string
  displayName?: string | null
  localPath: string
} | {
  sourceKind: "github"
  repoId: string
  displayName?: string | null
  githubOwner: string
  githubRepo: string
  githubRef: string
}

Response

{
  ok: true
  data: {
  userId: string
  repo: GatewayMarketplaceRepo = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.marketplaceRepos.upsert({
  ...
})

POST /gateway/v1/internal/users/me/plugins/{pluginId}/actions/{actionId}

Invoke current user plugin action

Parameters

pluginId · path · required
actionId · path · required

Request

{
  input?: { [key: string]: unknown } | null | null
}

Response

{
  ok: true
  data: {
  userId: string
  pluginId: string
  actionId: string
  status: { [key: string]: unknown } | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.plugins.actions.invoke({
  ...
})

GET /gateway/v1/internal/users/me/plugins

List current user configurable plugins

Response

{
  ok: true
  data: {
  userId: string
  plugins: GatewayUserPlugin[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.plugins.list({
  ...
})

PUT /gateway/v1/internal/users/me/plugins/{pluginId}/settings

Update current user plugin settings

Parameters

pluginId · path · required

Request

{
  settings: { [key: string]: unknown } | null
}

Response

{
  ok: true
  data: {
  userId: string
  plugin: GatewayUserPlugin = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.plugins.settings.put({
  ...
})

GET /gateway/v1/internal/users/me/plugins/{pluginId}/status

Get current user plugin status

Parameters

pluginId · path · required

Response

{
  ok: true
  data: {
  userId: string
  pluginId: string
  status: { [key: string]: unknown }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.plugins.status.get({
  ...
})

PATCH /gateway/v1/internal/users/me/plugins/{pluginId}/status

Set current user plugin runtime status

Parameters

pluginId · path · required

Request

{
  enabled: boolean
}

Response

{
  ok: true
  data: {
  userId: string
  plugin: GatewayUserPlugin = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.plugins.status.patch({
  ...
})

POST /gateway/v1/internal/users/me/realtime/conversations/connect

Connect current user realtime conversation

Request

{
  realtimeConversationId: string
  threadId: string
}

Response

{
  ok: boolean
  data: GatewayRealtimeConversationConnectResult = {
  realtimeConversationId: string
  threadId: string
  transport: string
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.realtime.conversations.connect({
  ...
})

POST /gateway/v1/internal/users/me/realtime/conversations/event

Send current user realtime conversation event

Request

{
  realtimeConversationId: string
  threadId: string
  event: GatewayRealtimeConversationModelEvent = {
  type: string
  event: unknown
}
}

Response

{
  ok: boolean
  data: GatewayRealtimeConversationClientEventResult = {
  realtimeConversationId: string
  threadId: string
  accepted: boolean
  mirrored?: boolean
  providerEvents?: unknown[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.realtime.conversations.event({
  ...
})

POST /gateway/v1/internal/users/me/realtime/conversations/start

Start current user realtime conversation

Request

{
  spaceSlug: string
  threadId: string
}

Response

{
  ok: boolean
  data: GatewayRealtimeConversationStartResult = {
  realtimeConversationId: string
  threadId: string
  spaceSlug: string
  transport: string
  realtime: GatewayRealtimeConfig
  transcriptPolicy: "none" | "persist_final" | "full"
  createdAt: string
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.realtime.conversations.start({
  ...
})

POST /gateway/v1/internal/users/me/realtime/conversations/stop

Stop current user realtime conversation

Request

{
  realtimeConversationId: string
  threadId: string
}

Response

{
  ok: boolean
  data: GatewayRealtimeConversationStopResult = {
  realtimeConversationId: string
  threadId: string
  stopped: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.realtime.conversations.stop({
  ...
})

POST /gateway/v1/internal/users/me/realtime/conversations/subscribe

Subscribe to current user realtime conversation events

Request

{
  realtimeConversationId: string
  threadId: string
}

Response

string

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.realtime.conversations.subscribe({
  ...
})

POST /gateway/v1/internal/users/me/runtime/lease

Create current user runtime lease

Request

{
  clientKind: string
  transportMode?: "direct" | "network" | null
  shellMode?: "desktop" | "web-attached" | "web-detached" | null
  profileKind?: "local" | "remote" | null
  origin?: string | null
  threadId?: string | null
  spaceSlug?: string | null
  scopes?: string[] | null
}

Response

{
  ok: true
  data: {
  leaseId: string
  runtimeInstanceId: string
  transportMode: "direct" | "network"
  socketUrl: string
  token: string
  expiresAt: string
  capabilities: {
  commandSocket: true
  uploads: true
}
  maxFrameBytes: unknown
  nodeAuth?: {
  kind: "node_principal"
  principal: "node_token"
  bearerHeader: "authorization"
  webSocketSubprotocolPrefix: "aster.bearer.v1."
}
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.runtime.lease({
  ...
})

GET /gateway/v1/internal/users/me/runtime/ready

Get current user runtime readiness

Parameters

activeSpaceSlug · query
activeThreadId · query

Response

{
  ok: true
  data: {
  runtime: GatewayUserRuntimeState = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.runtime.ready({
  ...
})

DELETE /gateway/v1/internal/users/me/skills/{skillId}

Delete current user installed skill

Parameters

skillId · path · required

Response

{
  ok: true
  data: {
  userId: string
  skillId: string
  deleted: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.skills.delete({
  ...
})

POST /gateway/v1/internal/users/me/skills/import-local

Import current user skill from a local folder

Request

{
  folderPath: string
}

Response

{
  ok: true
  data: {
  userId: string
  skill: GatewayInstalledSkill = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.skills.importLocal({
  ...
})

GET /gateway/v1/internal/users/me/skills

List current user installed skills

Response

{
  ok: true
  data: {
  userId: string
  skills: GatewayInstalledSkill[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.skills.list({
  ...
})

POST /gateway/v1/internal/users/me/skills/{skillId}/reload

Reload current user installed skill

Parameters

skillId · path · required

Response

{
  ok: true
  data: {
  userId: string
  skill: GatewayInstalledSkill = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.skills.reload({
  ...
})

PATCH /gateway/v1/internal/users/me/skills/{skillId}/status

Set current user installed skill status

Parameters

skillId · path · required

Request

{
  status: "active" | "disabled"
}

Response

{
  ok: true
  data: {
  userId: string
  skill: GatewayInstalledSkill = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.skills.status.set({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/apply

Apply current user space config

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: {
  userId: string
  space: GatewayUserSpace = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.apply({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/capabilities

Get current user space capabilities

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: SpaceCapabilitiesResult = {
  spaceSlug: ResourceDescriptorSchemaVersion
  consequence: { ... }
  effectiveRoles: { ... }[]
  effectiveAccessRoots: { ... }[]
  effectiveTools: { ... }[]
  harnessToolInventories: { ... }[]
  effectiveWorkflows: { ... }[]
  availablePermissions: { ... }[]
  availablePermissionAuthorizers: { ... }[]
  permissionAuthorizer: { ... }
  permissionProvider: { ... }
  evidenceSearchProvider: { ... }
  transcriptionService: { ... }
  sandbox: { ... }
  executionSurface: { ... }
  mode: { ... }
  availableModes: { ... }[]
  effort?: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.capabilities.get({
  ...
})

DELETE /gateway/v1/internal/users/me/spaces/{spaceSlug}/capabilities/tools/{toolId}

Clear current user space tool binding

Parameters

spaceSlug · path · required
toolId · path · required

Response

{
  ok: true
  data: {
  spaceSlug: string
  toolId: string
  cleared: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.capabilities.tools.clear({
  ...
})

PUT /gateway/v1/internal/users/me/spaces/{spaceSlug}/capabilities/tools/{toolId}

Set current user space tool binding

Parameters

spaceSlug · path · required
toolId · path · required

Request

{
  enabled: boolean
}

Response

{
  ok: true
  data: {
  userId: string
  spaceSlug: string
  toolId: string
  enabled: boolean
  updatedAt: string
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.capabilities.tools.set({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/contributions

List current user space contributions

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.contributions.list({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/{spaceSlug}/contributions/{contributionId}

Update current user space contribution binding

Parameters

spaceSlug · path · required
contributionId · path · required

Request

{ [key: string]: unknown }

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.contributions.update({
  ...
})

POST /gateway/v1/internal/users/me/spaces

Create current user space

Request

{
  slug?: ResourceDescriptorSchemaVersion = string | null
  baseSpaceId?: ResourceDescriptorSchemaVersion = string | null
  displayName?: ResourceDescriptorSchemaVersion = string | null
  description?: string | null | null
  spaceAvatar?: string | null | null
  spaceColor?: string | null | null
  parentSpaceSlug?: string | null | null
  workspaceMode?: string | null
  workingDirectory?: string | null | null
  permissionProviderId?: string | null | null
  permissionAuthorizerId?: string | null | null
  modeId?: string | null | null
  settings?: { [key: string]: unknown } | null | null
}

Response

{
  ok: boolean
  data: {
  userId: string
  space: GatewayUserSpace = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.create({
  ...
})

GET /gateway/v1/internal/users/me/spaces/installables

List current user installed spaces

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.installables.list({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/installables/{spaceId}/status

Set current user installed space status

Parameters

spaceId · path · required

Request

{ [key: string]: unknown }

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.installables.status({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/mcp-servers/capabilities

Get current user space MCP server capabilities

Parameters

spaceSlug · path · required

Response

{
  ok: true
  data: {
  spaceSlug: string
  capabilities: {
  tools: { ... }[]
  resources: { ... }[]
  prompts: { ... }[]
}
  statuses: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.mcpServers.capabilities({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/mcp-servers

List current user space MCP servers

Parameters

spaceSlug · path · required

Response

{
  ok: true
  data: {
  spaceSlug: string
  servers: GatewayUserSpaceMcpServer[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.mcpServers.list({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/{spaceSlug}/mcp-servers/{serverId}

Update current user space MCP server

Parameters

spaceSlug · path · required
serverId · path · required

Request

{
  enabled: boolean
  settings?: { [key: string]: unknown } | null | null
  skipRuntimeRefresh?: boolean | null
}

Response

{
  ok: true
  data: {
  spaceSlug: string
  server: GatewayUserSpaceMcpServer = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.mcpServers.update({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/{spaceSlug}/module-mutations

Apply current user space module mutations

Parameters

spaceSlug · path · required

Request

{
  mutations: { [key: string]: unknown }[]
  submittedByRunId?: string | null
  autonomyRung?: 0 | 1
}

Response

{
  ok: true
  data: GatewayUserSpaceModuleMutationResult = {
  spaceSlug: string
  moduleHash: string | null
  applied: boolean
  queued: boolean
  changed: boolean
  diagnostics: GatewayUserSpaceModuleCompileDiagnostic[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.moduleMutations.apply({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/plans/{planId}/approve

Approve current user space plan

Parameters

spaceSlug · path · required
planId · path · required

Request

{
  approvedBy?: string
  grantAuthority?: boolean
}

Response

{
  ok: boolean
  data: GatewaySpacePlanReviewEntry = {
  plan: GatewaySpacePlanRecord
  review: GatewaySpacePlanReview
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.plans.approve({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/plans

List current user space plans

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: GatewayUserSpacePlansData = {
  userId: string
  spaceSlug: string
  plans: GatewaySpacePlanReviewEntry[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.plans.list({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/plans/{planId}/reject

Reject current user space plan

Parameters

spaceSlug · path · required
planId · path · required

Request

{
  rejectedBy?: string
}

Response

{
  ok: boolean
  data: GatewaySpacePlanReviewEntry = {
  plan: GatewaySpacePlanRecord
  review: GatewaySpacePlanReview
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.plans.reject({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/providers/runtime-status

List current user space provider runtime statuses

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.spaces.providers.runtimeStatus({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/skills

List current user space skills

Parameters

spaceSlug · path · required

Response

{
  ok: true
  data: {
  spaceSlug: string
  skills: GatewayUserSpaceSkill[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.skills.list({
  ...
})

PUT /gateway/v1/internal/users/me/spaces/{spaceSlug}/skills/{skillId}

Update current user space skill

Parameters

spaceSlug · path · required
skillId · path · required

Request

{
  enabled: boolean
}

Response

{
  ok: true
  data: {
  spaceSlug: string
  skill: GatewayUserSpaceSkill = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.skills.update({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/tools

List current user space tools

Parameters

spaceSlug · path · required

Response

{
  ok: true
  data: {
  spaceSlug: string
  tools: GatewayUserSpaceToolPackage[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.tools.list({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/{spaceSlug}/tools/{toolPackageId}

Update current user space tool

Parameters

spaceSlug · path · required
toolPackageId · path · required

Request

{
  enabled: boolean
}

Response

{
  ok: true
  data: {
  spaceSlug: string
  tool: GatewayUserSpaceToolPackage = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.tools.update({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/{spaceSlug}

Update current user space

Parameters

spaceSlug · path · required

Request

{
  displayName?: ResourceDescriptorSchemaVersion = string | null
  description?: string | null | null
  spaceAvatar?: string | null | null
  spaceColor?: string | null | null
  parentSpaceSlug?: string | null | null
  workspaceMode?: string | null
  workingDirectory?: string | null | null
  model?: { ... } | null | null
  realtime?: { ... } | null | null
  permissionProviderId?: string | null | null
  permissionAuthorizerId?: string | null | null
  modeId?: string | null | null
  settings?: { [key: string]: unknown } | null | null
}

Response

{
  ok: boolean
  data: {
  userId: string
  space: GatewayUserSpace = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.me.spaces.update({
  ...
})

POST /gateway/v1/internal/users/me/transcription

Transcribe current user audio

Request

string

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.users.me.transcription.post({
  ...
})

POST /gateway/v1/internal/users/{userId}/pause

Pause user

Parameters

userId · path · required

Response

{
  ok: true
  data: {
  user: GatewayUser = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.pause({
  ...
})

POST /gateway/v1/internal/users/{userId}/plugins/{pluginId}/actions/{actionId}

Invoke user plugin action

Parameters

userId · path · required
pluginId · path · required
actionId · path · required

Request

{
  input?: { [key: string]: unknown } | null | null
}

Response

{
  ok: true
  data: {
  userId: string
  pluginId: string
  actionId: string
  status: { [key: string]: unknown } | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.plugins.actions.invoke({
  ...
})

GET /gateway/v1/internal/users/{userId}/plugins

List user configurable plugins

Parameters

userId · path · required

Response

{
  ok: true
  data: {
  userId: string
  plugins: GatewayUserPlugin[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.plugins.list({
  ...
})

PUT /gateway/v1/internal/users/{userId}/plugins/{pluginId}/settings

Update user plugin settings

Parameters

userId · path · required
pluginId · path · required

Request

{
  settings: { [key: string]: unknown } | null
}

Response

{
  ok: true
  data: {
  userId: string
  plugin: GatewayUserPlugin = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.plugins.settings.put({
  ...
})

GET /gateway/v1/internal/users/{userId}/plugins/{pluginId}/status

Get user plugin status

Parameters

userId · path · required
pluginId · path · required

Response

{
  ok: true
  data: {
  userId: string
  pluginId: string
  status: { [key: string]: unknown }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.plugins.status.get({
  ...
})

PATCH /gateway/v1/internal/users/{userId}/plugins/{pluginId}/status

Set user plugin runtime status

Parameters

userId · path · required
pluginId · path · required

Request

{
  enabled: boolean
}

Response

{
  ok: true
  data: {
  userId: string
  plugin: GatewayUserPlugin = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.plugins.status.patch({
  ...
})

POST /gateway/v1/internal/users/{userId}/resume

Resume user

Parameters

userId · path · required

Response

{
  ok: true
  data: {
  user: GatewayUser = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.users.resume({
  ...
})

44 operations

Apps

#apps

GET /gateway/v1/apps/tasks/{taskId}/work/{workId}/evidence/{evidenceId}/content

Read authorized paired-app Evidence artifact content

Parameters

taskId · path · required
workId · path · required
evidenceId · path · required

Response

string

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appEvidence.content({
  ...
})

GET /gateway/v1/apps/tasks/{taskId}/work/{workId}/evidence/{evidenceId}

Inspect Task/Work-scoped paired-app Evidence

Parameters

taskId · path · required
workId · path · required
evidenceId · path · required

Response

{
  ok: boolean
  data: AppEvidenceInspectionResult = {
  schemaVersion: "app-evidence-inspection.v1"
  address: { ... }
  availability: "available" | "invalidated" | "pruned" | "unavailable"
  evidence?: { ... } | null
  invalidation: { ... }[]
  artifact?: { ... } | null
  receipt?: { ... } | null
  links: { ... }[]
  projections: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appEvidence.inspect({
  ...
})

GET /gateway/v1/apps/work/{workId}/evidence

Page paired-app Work Evidence

Parameters

workId · path · required
limit · query
cursor · query

Response

{
  ok: boolean
  data: AppEvidencePageResult = {
  workId: string
  evidence: { ... }[]
  nextCursor: string | null
  total: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appEvidence.list({
  ...
})

POST /gateway/v1/apps/execution-placement/activate-image

Activate a fully reviewed execution image

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  imageFingerprint: unknown
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appExecutionPlacement.activateImage({
  ...
})

POST /gateway/v1/apps/execution-placement/approve

Approve one exact artifact and complete image authority

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  subject: {
  kind: "artifact"
  pluginKey: ResourceDescriptorSchemaVersion
  artifactFingerprint: unknown
  publisherId: ResourceDescriptorSchemaVersion
  publisherKeyFingerprint: unknown
} | {
  kind: "publisher"
  publisherId: ResourceDescriptorSchemaVersion
  publisherKeyFingerprint: unknown
}
  ceilings: {
  entitlementProfileAddress: unknown
  isolationClasses: unknown
  runtimeProtocolRange: ResourceDescriptorSchemaVersion = string
  executionHostMinimum?: { ... } | null
}
  reviewedImageFingerprints: unknown
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appExecutionPlacement.approve({
  ...
})

POST /gateway/v1/apps/execution-placement/deny

Deny shared placement for one exact artifact

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  subject: {
  kind: "artifact"
  pluginKey: ResourceDescriptorSchemaVersion = string
  artifactFingerprint: unknown
  publisherId: ResourceDescriptorSchemaVersion = string
  publisherKeyFingerprint: unknown
}
  imageFingerprint?: unknown | null
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appExecutionPlacement.deny({
  ...
})

POST /gateway/v1/apps/execution-placement/force-isolation

Force one installed plugin into verified one-member isolation

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  pluginKey: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appExecutionPlacement.forceIsolation({
  ...
})

POST /gateway/v1/apps/execution-placement/review

Review exact installed execution placement

Request

{
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  imageFingerprint?: unknown | null
}

Response

{
  ok: boolean
  data: ExecutionPlacementReviewSnapshot = {
  schemaVersion: "aster.execution-placement-review.v1"
  scope: { ... } | { ... }
  artifacts: { ... }[]
  grants: { ... }[]
  images: { ... }[]
  receipts: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appExecutionPlacement.review({
  ...
})

POST /gateway/v1/apps/execution-placement/revoke

Revoke one exact execution-placement grant

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  grantId: unknown
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appExecutionPlacement.revoke({
  ...
})

POST /gateway/v1/apps/intent-ingress

Submit paired-app intent through Task-owned Intent Ingress

Request

{
  schemaVersion: "intent-ingress.v3"
  ingressId: string
  idempotencyKey: string
  submission: {
  kind: "objective"
  intent: WorkIntent
  routing: { ... } | { ... }
  title?: string | null
  dependsOn?: { ... }[] | null
  metadata?: { [key: string]: unknown } | null
} | {
  kind: "interaction_response"
  interactionId: string
  response: { [key: string]: unknown }
}
  requestedAt: string
  citations: {
  kind: "task_local" | "external_provenance"
  evidenceRef: WorkEvidenceRef
}[]
  uploadReferences?: unknown | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  ok: boolean
  data: AppIntentIngressResult = {
  decision: IntentIngressDecision
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appIntentIngress.submit({
  ...
})

POST /gateway/v1/apps/product-plugins/{pluginId}/disable

Disable one installed non-required product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appProductPlugins.disable({
  ...
})

POST /gateway/v1/apps/product-plugins/{pluginId}/enable

Enable one installed product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appProductPlugins.enable({
  ...
})

POST /gateway/v1/apps/product-plugins/{pluginId}/install

Install one optional or suppressed default product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appProductPlugins.install({
  ...
})

GET /gateway/v1/apps/product-plugins

List product plugin lifecycle policy and current state

Response

{
  ok: boolean
  data: ProductPluginLifecycleSnapshot = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  productId: ResourceDescriptorSchemaVersion
  productName: ResourceDescriptorSchemaVersion
  plugins: { ... }[]
  receipts: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appProductPlugins.list({
  ...
})

POST /gateway/v1/apps/product-plugins/{pluginId}/uninstall

Uninstall one default or optional product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appProductPlugins.uninstall({
  ...
})

POST /gateway/v1/apps/tasks/{taskId}/archive

Archive a paired-app Task

Parameters

taskId · path · required

Request

{
  archivedAt?: string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  ok: boolean
  data: AppTaskProjection = {
  taskId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentWorkId: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  task: TaskRecord
  work?: WorkView | null
  settlement?: { ... } | null
  snooze?: { ... } | null
  placement?: "snoozed" | "settled" | "active" | null
  timeline: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.archive({
  ...
})

POST /gateway/v1/apps/tasks/{taskId}/cancel

Cancel a paired-app Task

Parameters

taskId · path · required

Request

{
  reason?: string | null
}

Response

{
  ok: boolean
  data: AppTaskProjection = {
  taskId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentWorkId: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  task: TaskRecord
  work?: WorkView | null
  settlement?: { ... } | null
  snooze?: { ... } | null
  placement?: "snoozed" | "settled" | "active" | null
  timeline: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.cancel({
  ...
})

GET /gateway/v1/apps/tasks/{taskId}/work

Inspect a paired-app Task's current Work

Parameters

taskId · path · required

Response

{
  ok: boolean
  data: AppWorkResult = {
  work: WorkView
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.currentWork({
  ...
})

GET /gateway/v1/apps/tasks/{taskId}

Get a paired-app Task

Parameters

taskId · path · required

Response

{
  ok: boolean
  data: AppTaskProjection = {
  taskId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentWorkId: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  task: TaskRecord
  work?: WorkView | null
  settlement?: { ... } | null
  snooze?: { ... } | null
  placement?: "snoozed" | "settled" | "active" | null
  timeline: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.get({
  ...
})

GET /gateway/v1/apps/tasks

List paired-app Tasks

Parameters

spaceSlug · query
status · query
q · query
includeArchived · query
limit · query
cursor · query

Response

{
  ok: boolean
  data: AppTaskPageResult = {
  tasks: TaskRecord[]
  work: WorkView[]
  nextCursor: ResourceDescriptorSchemaVersion | null
  total: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.list({
  ...
})

POST /gateway/v1/apps/tasks/{taskId}/rename

Rename a paired-app Task

Parameters

taskId · path · required

Request

{
  title: ResourceDescriptorSchemaVersion = string
  recordedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  ok: boolean
  data: AppTaskProjection = {
  taskId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentWorkId: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  task: TaskRecord
  work?: WorkView | null
  settlement?: { ... } | null
  snooze?: { ... } | null
  placement?: "snoozed" | "settled" | "active" | null
  timeline: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.rename({
  ...
})

POST /gateway/v1/apps/tasks/{taskId}/unarchive

Unarchive a paired-app Task

Parameters

taskId · path · required

Request

{
  archivedAt: ResourceDescriptorSchemaVersion = string
  unarchivedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  ok: boolean
  data: AppTaskProjection = {
  taskId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentWorkId: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  task: TaskRecord
  work?: WorkView | null
  settlement?: { ... } | null
  snooze?: { ... } | null
  placement?: "snoozed" | "settled" | "active" | null
  timeline: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.unarchive({
  ...
})

POST /gateway/v1/apps/tasks/{taskId}/viewed

Mark a paired-app Task viewed

Parameters

taskId · path · required

Request

{
  viewedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  ok: boolean
  data: AppTaskProjection = {
  taskId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentWorkId: ResourceDescriptorSchemaVersion | null
  workId?: ResourceDescriptorSchemaVersion | null
  task: TaskRecord
  work?: WorkView | null
  settlement?: { ... } | null
  snooze?: { ... } | null
  placement?: "snoozed" | "settled" | "active" | null
  timeline: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appTasks.viewed({
  ...
})

POST /gateway/v1/apps/uploads/{uploadId}/chunks

Append or replay one bounded upload chunk

Parameters

uploadId · path · required

Request

{
  schemaVersion: "app-upload.v1"
  chunkIndex: unknown
  offset: unknown
  dataBase64: unknown & unknown
  chunkSha256?: unknown | null
}

Response

{
  ok: boolean
  data: AppUploadStatus = {
  schemaVersion: "app-upload.v1"
  uploadId: unknown
  state: "active" | "completed"
  spaceSlug: ResourceDescriptorSchemaVersion
  fileName: ResourceDescriptorSchemaVersion
  mediaType: "text/plain" | "text/markdown" | "application/json" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp"
  sizeBytes: unknown
  receivedBytes: unknown
  nextChunkIndex: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  reference?: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appUploads.append({
  ...
})

POST /gateway/v1/apps/uploads/{uploadId}/cancel

Cancel one paired-app upload without existence disclosure

Parameters

uploadId · path · required

Request

{
  schemaVersion: "app-upload.v1"
}

Response

{
  ok: boolean
  data: AppUploadCancelResult = {
  schemaVersion: "app-upload.v1"
  cancelled: true
  uploadId: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appUploads.cancel({
  ...
})

POST /gateway/v1/apps/uploads/{uploadId}/complete

Complete one paired-app upload and obtain a stable reference

Parameters

uploadId · path · required

Request

{
  schemaVersion: "app-upload.v1"
  expectedContentSha256?: unknown | null
}

Response

{
  ok: boolean
  data: AppUploadStatus = {
  schemaVersion: "app-upload.v1"
  uploadId: unknown
  state: "active" | "completed"
  spaceSlug: ResourceDescriptorSchemaVersion
  fileName: ResourceDescriptorSchemaVersion
  mediaType: "text/plain" | "text/markdown" | "application/json" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp"
  sizeBytes: unknown
  receivedBytes: unknown
  nextChunkIndex: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  reference?: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appUploads.complete({
  ...
})

POST /gateway/v1/apps/uploads

Start or resume one bounded paired-app upload

Request

{
  schemaVersion: "app-upload.v1"
  uploadId: unknown
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  spaceSlug: ResourceDescriptorSchemaVersion = string
  fileName: ResourceDescriptorSchemaVersion = string
  mediaType: "text/plain" | "text/markdown" | "application/json" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp"
  sizeBytes: unknown & unknown
  expectedContentSha256?: unknown | null
}

Response

{
  ok: boolean
  data: AppUploadStatus = {
  schemaVersion: "app-upload.v1"
  uploadId: unknown
  state: "active" | "completed"
  spaceSlug: ResourceDescriptorSchemaVersion
  fileName: ResourceDescriptorSchemaVersion
  mediaType: "text/plain" | "text/markdown" | "application/json" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp"
  sizeBytes: unknown
  receivedBytes: unknown
  nextChunkIndex: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  reference?: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appUploads.start({
  ...
})

GET /gateway/v1/apps/uploads/{uploadId}

Inspect one authorized paired-app upload

Parameters

uploadId · path · required

Response

{
  ok: boolean
  data: AppUploadStatus = {
  schemaVersion: "app-upload.v1"
  uploadId: unknown
  state: "active" | "completed"
  spaceSlug: ResourceDescriptorSchemaVersion
  fileName: ResourceDescriptorSchemaVersion
  mediaType: "text/plain" | "text/markdown" | "application/json" | "application/pdf" | "image/png" | "image/jpeg" | "image/gif" | "image/webp"
  sizeBytes: unknown
  receivedBytes: unknown
  nextChunkIndex: unknown
  createdAt: ResourceDescriptorSchemaVersion
  updatedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  reference?: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appUploads.status({
  ...
})

GET /gateway/v1/apps/work/{workId}

Inspect paired-app Work

Parameters

workId · path · required

Response

{
  ok: boolean
  data: AppWorkResult = {
  work: WorkView
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.appWork.get({
  ...
})

GET /gateway/v1/apps/connection/current

Get current paired app connection

Response

{
  ok: true
  data: {
  connection: {
  id: string
  userId: string
  appId: string
  name: string
  appVersion: string | null
  deviceName: string | null
  scopes: string[]
  spaceSlugs: string[]
}
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.connection.current({
  ...
})

POST /gateway/v1/apps/connection/revoke

Revoke current paired app connection

Response

{
  ok: true
  data: {
  revoked: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.connection.revoke({
  ...
})

POST /gateway/v1/apps/events

Submit app event

Queue an external app ingress event for watcher dispatch

Request

{
  type?: string | null
  content: string
  externalEventId?: string | null
  metadata?: { [key: string]: unknown } | null
  spaceSlug?: string | null
  space?: string | null
}

Response

{
  ok: true
  data: {
  accepted: true
  eventId: string
  ingressEventId: string
  deduplicated?: boolean | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.events.create({
  ...
})

GET /gateway/v1/apps/events

Deprecated app event stream

Removed legacy app event SSE stream. Use the Apps runtime WebSocket lease instead.

Response

{
  ok: true
  data: {
  accepted: true
  eventId: string
  ingressEventId: string
  deduplicated?: boolean | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.events.stream.deprecated({
  ...
})

POST /gateway/v1/apps/events/types

Register app event types

Request

{
  types: unknown & unknown
}

Response

{
  ok: true
  data: {
  types: AppEventType[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.events.types.register({
  ...
})

POST /gateway/v1/apps/pair

Create app pairing request

Create a local pairing request for a user to approve in Aster.

Request

{
  app: {
  id: string
  name?: string | null
  version?: string | null | null
}
  deviceName?: string | null | null
  scopes?: string[] | null | null
  spaceSlugs?: string[] | null
  ttlMs?: unknown & unknown | null
}

Response

{
  ok: true
  data: {
  request: GatewayAppPairRequest = { ... }
  secret: string
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.pair.create({
  ...
})

GET /gateway/v1/apps/pair/{pairRequestId}

Get app pairing request status

Poll a local pairing request. Approved responses include the app credential token once.

Parameters

pairRequestId · path · required

Response

{
  ok: true
  data: {
  request: GatewayAppPairRequest = { ... }
  token?: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.pair.get({
  ...
})

POST /gateway/v1/apps/composer/query

Query the paired-app Composer registry

Request

{
  spaceSlug: string
  taskId?: string | null
  query: string
  limit?: unknown & unknown | null
}

Response

{
  ok: boolean
  data: AppComposerQueryResult = {
  spaceSlug: string
  query: string
  sections: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.apps.pairedComposer.query({
  ...
})

POST /gateway/v1/apps/runtime/lease

Create app runtime lease

Request

{
  clientKind?: string | null
  transportMode?: "direct" | "network" | null
  shellMode?: "desktop" | "web-attached" | "web-detached" | null
  profileKind?: "local" | "remote" | null
  origin?: string | null
}

Response

{
  ok: true
  data: {
  leaseId: string
  runtimeInstanceId: string
  transportMode: "direct" | "network"
  socketUrl: string
  token: string
  expiresAt: string
  capabilities: {
  commandSocket: true
  uploads: true
}
  maxFrameBytes: unknown
  nodeAuth?: {
  kind: "node_principal"
  principal: "node_token"
  bearerHeader: "authorization"
  webSocketSubprotocolPrefix: "aster.bearer.v1."
}
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.runtime.lease({
  ...
})

GET /gateway/v1/apps/runtime/ready

Get app runtime readiness

Response

{
  ok: true
  data: {
  runtime: {
  userId: string
  runtimeInstanceId: string | null
  ready: boolean
  lifecycleState: string
}
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.runtime.ready({
  ...
})

POST /gateway/v1/apps/connect

Create app socket ticket

Create a short-lived one-time ticket for the durable paired app WebSocket.

Response

{
  ok: true
  data: GatewayAppSocketTicket = {
  ticket: string
  url: string
  expiresAt: string
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.socket.connect({
  ...
})

POST /gateway/v1/apps/socket-ticket

Create app socket ticket

Create a short-lived one-time ticket for the durable paired app WebSocket.

Response

{
  ok: true
  data: GatewayAppSocketTicket = {
  ticket: string
  url: string
  expiresAt: string
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.socket.ticket({
  ...
})

POST /gateway/v1/apps/spaces/make

Create an app-owned space module

Create a space backed by a managed TypeScript space module.

Request

{
  slug: string
  displayName: string
  description?: string | null | null
  parentSpaceSlug?: string | null | null
  workspaceMode?: "shared" | "isolated" | "hybrid" | null
  workingDirectory?: string | null
  moduleSource: string
  moduleManifest: AppSpaceModuleManifest = { [key: string]: unknown }
  spaceAvatar?: string | null
  spaceColor?: string | null
}

Response

{
  ok: true
  data: {
  space: GatewayUserSpace = { ... }
  module: GatewayAppManagedSpaceModule = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.spaces.make({
  ...
})

PATCH /gateway/v1/apps/spaces/{spaceSlug}/module

Update an app-owned space module

Replace the managed TypeScript module for a space owned by or granted to the app.

Parameters

spaceSlug · path · required

Request

{
  moduleSource: string
  moduleManifest: AppSpaceModuleManifest = { [key: string]: unknown }
}

Response

{
  ok: true
  data: {
  module: GatewayAppManagedSpaceModule = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.spaces.module.update({
  ...
})

GET /gateway/v1/apps/user

Get current app user

Response

{
  ok: true
  data: {
  user: {
  id: string
}
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.apps.user.current({
  ...
})

1 operations

Composer

#composer

POST /gateway/v1/internal/composer/query

Query the composer registry

Query every registered composer source for the authenticated Space.

Request

{
  spaceSlug: string
  threadId?: string | null
  query: string
  limit?: number | null
}

Response

{
  ok: true
  data: ComposerQueryResult = {
  spaceSlug: string
  query: string
  sections: ComposerSection[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.composer.query({ spaceSlug: "main", query: "notes" })

1 operations

Evidence

#evidence

GET /gateway/v1/internal/evidence

List Work evidence

Parameters

workId · query
spaceSlug · query
kind · query
q · query

Response

{
  evidence: EvidenceRecord = { ... }[]
  artifacts: ArtifactRecord = { ... }[]
  receipts: ReceiptEnvelope = { ... }[]
  links: EvidenceLink = { ... }[]
  projections: EvidenceProjection = { ... }[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.evidence.list({
  ...
})

6 operations

ExecutionPlacement

#executionPlacement

POST /gateway/v1/internal/users/me/execution-placement/activate-image

Activate a fully reviewed execution image

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  imageFingerprint: unknown
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.executionPlacement.activateImage({
  ...
})

POST /gateway/v1/internal/users/me/execution-placement/approve

Approve one exact artifact and complete image authority

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  subject: {
  kind: "artifact"
  pluginKey: ResourceDescriptorSchemaVersion
  artifactFingerprint: unknown
  publisherId: ResourceDescriptorSchemaVersion
  publisherKeyFingerprint: unknown
} | {
  kind: "publisher"
  publisherId: ResourceDescriptorSchemaVersion
  publisherKeyFingerprint: unknown
}
  ceilings: {
  entitlementProfileAddress: unknown
  isolationClasses: unknown
  runtimeProtocolRange: ResourceDescriptorSchemaVersion = string
  executionHostMinimum?: { ... } | null
}
  reviewedImageFingerprints: unknown
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.executionPlacement.approve({
  ...
})

POST /gateway/v1/internal/users/me/execution-placement/deny

Deny shared placement for one exact artifact

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  subject: {
  kind: "artifact"
  pluginKey: ResourceDescriptorSchemaVersion = string
  artifactFingerprint: unknown
  publisherId: ResourceDescriptorSchemaVersion = string
  publisherKeyFingerprint: unknown
}
  imageFingerprint?: unknown | null
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.executionPlacement.deny({
  ...
})

POST /gateway/v1/internal/users/me/execution-placement/force-isolation

Force one installed plugin into verified one-member isolation

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  pluginKey: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.executionPlacement.forceIsolation({
  ...
})

POST /gateway/v1/internal/users/me/execution-placement/review

Review exact installed execution placement

Request

{
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  imageFingerprint?: unknown | null
}

Response

{
  ok: boolean
  data: ExecutionPlacementReviewSnapshot = {
  schemaVersion: "aster.execution-placement-review.v1"
  scope: { ... } | { ... }
  artifacts: { ... }[]
  grants: { ... }[]
  images: { ... }[]
  receipts: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.executionPlacement.review({
  ...
})

POST /gateway/v1/internal/users/me/execution-placement/revoke

Revoke one exact execution-placement grant

Request

{
  schemaVersion: "aster.execution-placement-review.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  scope: {
  kind: "owner"
} | {
  kind: "space"
  spaceId: ResourceDescriptorSchemaVersion
}
  reason: ResourceDescriptorSchemaVersion = string
  grantId: unknown
}

Response

{
  ok: boolean
  data: ExecutionPlacementMutationResult = {
  schemaVersion: "aster.execution-placement-review.v1"
  action: "approve" | "deny" | "activate_image" | "force_isolation" | "revoke"
  snapshot: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.executionPlacement.revoke({
  ...
})

11 operations

GatewayAuth

#gatewayAuth

POST /gateway/v1/auth/login

Login with user credentials

Create a user access token by user ID and password

Request

{
  userId: string
  password: string
  name?: string | null
}

Response

{
  ok: true
  data: {
  user: GatewayAuthUser = { ... }
  token: string
  tokenInfo: GatewayAuthToken = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.login({
  ...
})

POST /gateway/v1/auth/logout

Logout current user access token

Revoke the active bearer user access token

Response

{
  ok: true
  data: {
  userId: string
  tokenId: string
  revoked: true
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.logout({
  ...
})

GET /gateway/v1/auth/self-signup

Get self-sign-up policy

Return whether unauthenticated visitors can create member accounts on this server

Response

{
  ok: true
  data: {
  selfSignup: GatewaySelfSignupStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.selfSignup.get({
  ...
})

POST /gateway/v1/auth/self-signup

Set self-sign-up policy

Enable or disable unauthenticated member self-sign-up for this server

Request

{
  enabled: boolean
}

Response

{
  ok: true
  data: {
  selfSignup: GatewaySelfSignupStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.selfSignup.set({
  ...
})

POST /gateway/v1/auth/server-name

Set server name

Set or clear the public server name shown to users throughout the UI

Request

{
  name?: string | null | null
}

Response

{
  ok: true
  data: {
  serverName: GatewayServerNameStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.serverName.set({
  ...
})

DELETE /gateway/v1/auth/server-password

Clear server password

Disable the shared server password requirement for creating users

Request

{
  currentPassword?: string
}

Response

{
  ok: true
  data: {
  password: GatewayServerPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.serverPassword.clear({
  ...
})

GET /gateway/v1/auth/server-password

Get server password status

Return whether the shared server password is configured for user creation

Response

{
  ok: true
  data: {
  password: GatewayServerPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.serverPassword.get({
  ...
})

POST /gateway/v1/auth/server-password

Set server password

Set or change the shared server password used to authorize user creation

Request

{
  password: string
  currentPassword?: string | null
}

Response

{
  ok: true
  data: {
  password: GatewayServerPasswordStatus = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.serverPassword.set({
  ...
})

POST /gateway/v1/auth/setup/admin

Create the first admin user

Bootstrap a fresh server by creating its first admin account and auth token

Request

{
  userId: string
  password: string
  serverPassword?: string | null
  serverName?: string | null | null
  name?: string | null
}

Response

{
  ok: true
  data: {
  user: GatewayAuthUser = { ... }
  token: string
  tokenInfo: GatewayAuthToken = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.setup.admin.create({
  ...
})

GET /gateway/v1/auth/setup

Get server setup status

Return whether the server still needs its first admin user

Response

{
  ok: true
  data: GatewaySetupStatus = {
  setupRequired: boolean
  serverPasswordConfigured: boolean
  selfSignupEnabled: boolean
  serverName: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.setup.get({
  ...
})

POST /gateway/v1/auth/signup

Sign up for a new member account

Create a new member account when server self-sign-up is enabled, then return a user access token

Request

{
  userId: string
  password: string
  serverPassword?: string | null
  name?: string | null
}

Response

{
  ok: true
  data: {
  user: GatewayAuthUser = { ... }
  token: string
  tokenInfo: GatewayAuthToken = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.gatewayAuth.signup({
  ...
})

2 operations

IntentIngress

#intentIngress

POST /gateway/v1/internal/operator-routing-corrections

Record and execute a user-authorized routing correction

Request

{
  schemaVersion: "operator-routing-correction-command.v1"
  correctionId: ResourceDescriptorSchemaVersion = string
  identity: {
  userId: ResourceDescriptorSchemaVersion = string
  contextIdentity: {
  kind: "context_identity"
  contextIdentityId: unknown
}
}
  sourceIngressId: ResourceDescriptorSchemaVersion = string
  sourceTaskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  sourceWorkRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  classification: "confirmed_misroute" | "changed_intent"
  reason: "clarification_rehome" | "explicit_user_redirect" | "wrong_task_reported"
  selectedTarget: {
  candidateId: ResourceDescriptorSchemaVersion = string
  directive: IntentRouteDirective = { ... } | { ... } | { ... } | { ... } | { ... }
}
  requestedAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  decision: IntentIngressDecision = { ... } | { ... } | { ... } | { ... } | { ... }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.intentIngress.correctRouting({
  ...
})

POST /gateway/v1/internal/intent-ingress

Submit objective or pending-interaction intent

Request

{
  schemaVersion: "intent-ingress.v3"
  ingressId: ResourceDescriptorSchemaVersion = string
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  identity: {
  userId: ResourceDescriptorSchemaVersion = string
  contextIdentity: {
  kind: "context_identity"
  contextIdentityId: unknown
}
}
  creationOrigin: IntentCreationOrigin = { ... } | { ... } | { ... } | { ... } | { ... }
  submission: {
  kind: "objective"
  execution: "schedule" | "record_only"
  intent: WorkIntent
  routing: { ... } | { ... }
  resourceTargetIds?: ResourceDescriptorSchemaVersion[] | null
  title?: ResourceDescriptorSchemaVersion | null
  dependsOn?: { ... }[] | null
  waitId?: ResourceDescriptorSchemaVersion | null
  correlationRef?: ResourceDescriptorSchemaVersion | null
  control?: IntentIngressControl | null
  workspaceOverride?: IntentIngressWorkspaceOverride | null
  queueAfter?: IntentIngressQueueAfter | null
  metadata?: { [key: string]: unknown } | null
} | {
  kind: "interaction_response"
  interactionId: ResourceDescriptorSchemaVersion
  response: { [key: string]: unknown }
}
  requestedAt: ResourceDescriptorSchemaVersion = string
  citations: {
  kind: "task_local" | "external_provenance"
  evidenceRef: WorkEvidenceRef
}[]
  metadata?: { [key: string]: unknown } | null
}

Response

{
  decision: IntentIngressDecision = { ... } | { ... } | { ... } | { ... } | { ... }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.intentIngress.submit({
  ...
})

7 operations

Plugins

#plugins

DELETE /gateway/v1/internal/plugins/{pluginId}

Uninstall one configured service plugin

Parameters

pluginId · path · required

Response

{
  ok: true
  data: {
  deleted: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.delete({
  ...
})

POST /gateway/v1/internal/plugins/import-local

Import service plugin from local folder

Request

{
  folderPath: string
}

Response

{
  ok: true
  data: {
  plugin: GatewayServicePlugin = { ... }
  configuredRevision: unknown
  activeRevision: unknown | null
  restartRequired: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.importLocal({
  ...
})

GET /gateway/v1/internal/plugins

List configured service plugins

Response

{
  ok: true
  data: {
  plugins: GatewayServicePlugin[]
  diagnostics: GatewayServicePluginDiagnostic[]
  configuredRevision: unknown
  activeRevision: unknown | null
  restartRequired: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.list({
  ...
})

POST /gateway/v1/internal/plugins/{pluginId}/reload

Reload one configured service plugin from its source

Parameters

pluginId · path · required

Response

{
  ok: true
  data: {
  plugin: GatewayServicePlugin = { ... }
  configuredRevision: unknown
  activeRevision: unknown | null
  restartRequired: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.reload({
  ...
})

PUT /gateway/v1/internal/plugins/{pluginId}/settings

Update configured service plugin settings

Parameters

pluginId · path · required

Request

{
  settings: { [key: string]: unknown } | null
}

Response

{
  ok: true
  data: {
  plugin: GatewayServicePlugin = { ... }
  configuredRevision: unknown
  activeRevision: unknown | null
  restartRequired: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.settings.put({
  ...
})

POST /gateway/v1/internal/plugins/{pluginId}/sidecars/{sidecarId}/install

Install or repair one configured plugin sidecar

Parameters

pluginId · path · required
sidecarId · path · required

Response

{
  ok: true
  data: {
  plugin: GatewayServicePlugin = { ... }
  configuredRevision: unknown
  activeRevision: unknown | null
  restartRequired: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.sidecars.install({
  ...
})

PATCH /gateway/v1/internal/plugins/{pluginId}/status

Update configured service plugin status

Parameters

pluginId · path · required

Request

{
  status: "active" | "disabled"
}

Response

{
  ok: true
  data: {
  plugin: GatewayServicePlugin = { ... }
  configuredRevision: unknown
  activeRevision: unknown | null
  restartRequired: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.plugins.status.patch({
  ...
})

5 operations

ProductPlugins

#productPlugins

POST /gateway/v1/internal/users/me/product-plugins/{pluginId}/disable

Disable one installed non-required product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.productPlugins.disable({
  ...
})

POST /gateway/v1/internal/users/me/product-plugins/{pluginId}/enable

Enable one installed product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.productPlugins.enable({
  ...
})

POST /gateway/v1/internal/users/me/product-plugins/{pluginId}/install

Install one optional or suppressed default product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.productPlugins.install({
  ...
})

GET /gateway/v1/internal/users/me/product-plugins

List product plugin lifecycle policy and current state

Response

{
  ok: boolean
  data: ProductPluginLifecycleSnapshot = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  productId: ResourceDescriptorSchemaVersion
  productName: ResourceDescriptorSchemaVersion
  plugins: { ... }[]
  receipts: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.productPlugins.list({
  ...
})

POST /gateway/v1/internal/users/me/product-plugins/{pluginId}/uninstall

Uninstall one default or optional product plugin

Parameters

pluginId · path · required

Request

{
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  commandId: ResourceDescriptorSchemaVersion = string
  reason: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ProductPluginLifecycleMutationResult = {
  schemaVersion: "aster.product-plugin-lifecycle.v1"
  action: "install" | "uninstall" | "enable" | "disable"
  plugin: { ... }
  receipt: { ... } | null
  runtime: { ... } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.productPlugins.uninstall({
  ...
})

3 operations

Services

#services

GET /gateway/v1/internal/services/{serviceId}

Inspect service catalog entry

Parameters

serviceId · path · required

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.services.inspect({
  ...
})

GET /gateway/v1/internal/services/providers

List protocol provider catalog

Parameters

protocolId · query · required
range · query
activeOnly · query

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.services.providers({
  ...
})

GET /gateway/v1/internal/services/search

Search service catalog

Parameters

q · query
query · query
spaceSlug · query

Response

{
  ok: boolean
  data: { [key: string]: unknown }
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.services.search({
  ...
})

16 operations

Sites

#sites

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/archive

Archive a revision-fenced Site

Parameters

spaceSlug · path · required
siteId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
  reason: string
}

Response

{
  ok: boolean
  data: SiteMutationResult = {
  schemaVersion: "site-management.v1"
  site: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.archive({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments/{siteDeploymentId}/activate

Activate a staged Site deployment

Parameters

spaceSlug · path · required
siteId · path · required
siteDeploymentId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
}

Response

{
  ok: boolean
  data: SiteDeploymentMutationResult = {
  schemaVersion: "site-management.v1"
  deployment: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.activate({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments

Deploy an immutable SiteVersion

Parameters

spaceSlug · path · required
siteId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
  siteVersionId: unknown
  target: {
  kind: "self_host"
  spaceHomeGeneration: unknown
} | {
  kind: "provider"
  providerInstanceId: string
  targetRef: string
}
}

Response

{
  ok: boolean
  data: SiteDeploymentMutationResult = {
  schemaVersion: "site-management.v1"
  deployment: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.deploy({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments/{siteDeploymentId}/destroy

Destroy a Site deployment

Parameters

spaceSlug · path · required
siteId · path · required
siteDeploymentId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
}

Response

{
  ok: boolean
  data: SiteDeploymentMutationResult = {
  schemaVersion: "site-management.v1"
  deployment: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.destroy({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments/{siteDeploymentId}/inspect

Inspect provider deployment health

Parameters

spaceSlug · path · required
siteId · path · required
siteDeploymentId · path · required

Response

{
  ok: boolean
  data: SiteDeploymentMutationResult = {
  schemaVersion: "site-management.v1"
  deployment: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.inspect({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments

List sanitized Site deployment projections

Parameters

spaceSlug · path · required
siteId · path · required
cursor · query
limit · query

Response

{
  ok: boolean
  data: SiteDeploymentListProjection = {
  schemaVersion: "site-management.v1"
  items: { ... }[]
  nextCursor: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.list({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments/rollback

Roll back to a retained Site deployment

Parameters

spaceSlug · path · required
siteId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
  toSiteDeploymentId: unknown
}

Response

{
  ok: boolean
  data: SiteDeploymentMutationResult = {
  schemaVersion: "site-management.v1"
  deployment: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.rollback({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/deployments/{siteDeploymentId}/suspend

Suspend Site ingress

Parameters

spaceSlug · path · required
siteId · path · required
siteDeploymentId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
}

Response

{
  ok: boolean
  data: SiteDeploymentMutationResult = {
  schemaVersion: "site-management.v1"
  deployment: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.deployments.suspend({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}

Read an exact Site projection

Parameters

spaceSlug · path · required
siteId · path · required

Response

{
  ok: boolean
  data: SiteDetailProjection = {
  schemaVersion: "site-management.v1"
  site: { ... }
  currentVersion: { ... } | null
  deployments: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.get({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/hosting-targets

List sanitized Site hosting targets

Parameters

spaceSlug · path · required

Response

{
  ok: boolean
  data: SiteHostingTargetsProjection = {
  schemaVersion: "site-management.v1"
  selfHost: { ... }
  providers: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.hostingTargets.list({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/hosting-targets/validate

Validate an exact Site hosting target

Parameters

spaceSlug · path · required
siteId · path · required

Request

{
  schemaVersion: "site-management.v1"
  target: {
  kind: "self_host"
  spaceHomeGeneration: unknown
} | {
  kind: "provider"
  providerInstanceId: string
  targetRef: string
}
}

Response

{
  ok: boolean
  data: SiteHostingTargetValidationResult = {
  schemaVersion: "site-management.v1"
  accepted: true
  target: { ... } | { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.hostingTargets.validate({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/intents

Accept a Site creation intent into Task and Work

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  slug: unknown
  displayName: string
  description: string | null
  brief: string
}

Response

{
  ok: boolean
  data: SiteCreateIntentResult = {
  schemaVersion: "site-management.v1"
  taskRef: { ... }
  workRef: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.intents.create({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/intents

Accept a Site update intent into Task and Work

Parameters

spaceSlug · path · required
siteId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
  brief: string
}

Response

{
  ok: boolean
  data: SiteCreateIntentResult = {
  schemaVersion: "site-management.v1"
  taskRef: { ... }
  workRef: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.intents.update({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites

List Sites in an owned Space

Parameters

spaceSlug · path · required
cursor · query
limit · query

Response

{
  ok: boolean
  data: SiteListProjection = {
  schemaVersion: "site-management.v1"
  items: { ... }[]
  nextCursor: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.list({
  ...
})

PATCH /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}

Update revision-fenced Site metadata

Parameters

spaceSlug · path · required
siteId · path · required

Request

{
  schemaVersion: "site-management.v1"
  idempotencyKey: string
  expectedRevision: unknown
  displayName?: string | null
  description?: string | null | null
}

Response

{
  ok: boolean
  data: SiteMutationResult = {
  schemaVersion: "site-management.v1"
  site: { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.updateMetadata({
  ...
})

GET /gateway/v1/internal/users/me/spaces/{spaceSlug}/sites/{siteId}/versions

List immutable SiteVersion build projections

Parameters

spaceSlug · path · required
siteId · path · required
cursor · query
limit · query

Response

{
  ok: boolean
  data: SiteVersionListProjection = {
  schemaVersion: "site-management.v1"
  items: { ... }[]
  nextCursor: string | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.sites.versions.list({
  ...
})

27 operations

SpaceResources

#spaceResources

POST /gateway/v1/internal/space-resources/work-bindings

Resolve and bind Resources to Work

Request

{
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  taskScopeRevisionId: ResourceDescriptorSchemaVersion = string
  selections: unknown
  primaryResourceId: ResourceDescriptorSchemaVersion = string | null
  initiator: WorkResourceBindingInitiator = "user" | "worker" | "workflow"
  reason: ResourceDescriptorSchemaVersion = string
  idempotencyKey: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: WorkResourceBindingSet = {
  revision: unknown
  bindings: unknown
  primaryResourceId: ResourceDescriptorSchemaVersion | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.bindWork({
  ...
})

POST /gateway/v1/internal/space-resources/clones/configure

Configure a Resource remote inside a node-local clone

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  node: {
  nodeId: unknown
}
  pathHandle: ResourceDescriptorSchemaVersion = string
  remoteName: ResourceDescriptorSchemaVersion = string
  autoFetch: boolean
}

Response

{
  ok: boolean
  data: ResourceCloneConfiguration = { ... } | null
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.configureClone({
  ...
})

POST /gateway/v1/internal/space-resources/task-scope/decide

Decide a Task Resource-scope expansion

Request

{
  requestId: ResourceDescriptorSchemaVersion = string
  expectedRevisionId: ResourceDescriptorSchemaVersion = string
  decision: "approved" | "refused"
}

Response

{
  ok: boolean
  data: TaskResourceScopeExpansionRequest = {
  schemaVersion: "task-resource-scope-expansion.v1"
  requestId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentRevisionId: ResourceDescriptorSchemaVersion
  requestedResourceIds: unknown
  reason: ResourceDescriptorSchemaVersion
  status: "pending" | "approved" | "refused" | "superseded"
  requestedAt: ResourceDescriptorSchemaVersion
  decidedAt: ResourceDescriptorSchemaVersion | null
  decisionReceiptId: ResourceDescriptorSchemaVersion | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.decideTaskScopeExpansion({
  ...
})

POST /gateway/v1/internal/space-resources/actions/discover

Discover registry actions and click-time availability

Request

{
  target: ResourceActionTarget = { ... } | { ... } | { ... }
}

Response

{
  ok: boolean
  data: ResourceActionDiscoveryResult = {
  schemaVersion: "resource-action.v1"
  kindId: ResourceDescriptorSchemaVersion
  target: ResourceActionTarget
  actions: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.discoverActions({
  ...
})

POST /gateway/v1/internal/space-resources/publications/dispatch

Dispatch an authorized Resource publication intent

Request

{
  publicationId: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ResourcePublicationView = {
  schemaVersion: "resource-publication.v1"
  publicationId: ResourceDescriptorSchemaVersion
  identity: ResourcePublicationIdentity
  target: ResourcePublicationTarget
  policy: PublishPolicy
  state: ResourcePublicationState
  blockedReason: ResourcePublicationBlockedReason | null
  attemptCount: unknown
  receipt: ResourcePublicationReceipt | null
  updatedAt: ResourceDescriptorSchemaVersion
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.dispatchPublication({
  ...
})

POST /gateway/v1/internal/space-resources/actions/execute

Execute one registry action after click-time revalidation

Request

{
  schemaVersion: "resource-action.v1"
  actionId: ResourceDescriptorSchemaVersion = string
  target: ResourceActionTarget = { ... } | { ... } | { ... }
  parameterSchemaVersion: ResourceDescriptorSchemaVersion = string
  parameters: GatewayJsonValue = null | boolean | number | "NaN" | "Infinity" | "-Infinity" | string | GatewayJsonValue[] | { [key: string]: unknown }
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  consequenceConsent: {
  kind: "explicit_user_consent"
  actionId: ResourceDescriptorSchemaVersion
  consentedAt: ResourceDescriptorSchemaVersion
} | null
}

Response

{
  ok: boolean
  data: ResourceActionInvocationResult = ResourceActionRun | ClientResourceActionTicket
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.executeAction({
  ...
})

POST /gateway/v1/internal/space-resources/actions/client/execute

Route a consented client-local action to its selected node

Request

{
  ticket: ClientResourceActionTicket = {
  schemaVersion: "client-resource-action.v1"
  ticketId: ResourceDescriptorSchemaVersion
  principalId: ResourceDescriptorSchemaVersion
  spaceId: ResourceDescriptorSchemaVersion
  nodeId: ResourceDescriptorSchemaVersion
  recipe: ClientResourceActionRecipe
  nonce: ResourceDescriptorSchemaVersion
  issuedAt: ResourceDescriptorSchemaVersion
  expiresAt: ResourceDescriptorSchemaVersion
  verificationKey: ClientResourceActionVerificationKey
  signature: ResourceDescriptorSchemaVersion
}
  decision: ClientResourceActionDecision = {
  schemaVersion: "client-resource-action.v1"
  ticketId: ResourceDescriptorSchemaVersion
  consent: "approved" | "declined"
  operation: ResourceDescriptorSchemaVersion | null
  previewDigest: ResourceDescriptorSchemaVersion | null
  decidedAt: ResourceDescriptorSchemaVersion
}
}

Response

{
  ok: boolean
  data: ClientResourceActionExecutionResult = ClientResourceActionPreview | ClientResourceActionOutcome
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.executeClientAction({
  ...
})

POST /gateway/v1/internal/space-resources/clones/fetch

Fetch finalized Resource refs into a node-local clone

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  node: {
  nodeId: unknown
}
}

Response

{
  ok: boolean
  data: ResourceCloneFetchResult = {
  resourceId: ResourceDescriptorSchemaVersion
  node: { ... }
  fetchedAt: ResourceDescriptorSchemaVersion | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.fetchClone({
  ...
})

GET /gateway/v1/internal/space-resources/get

Get one Space Resource

Parameters

resourceId · query · required

Response

{
  ok: boolean
  data: SpaceResource = {
  schemaVersion: "space-resource.v2"
  resourceId: ResourceDescriptorSchemaVersion
  spaceId: ResourceDescriptorSchemaVersion
  displayName: ResourceDescriptorSchemaVersion
  mentionHandle: ResourceDescriptorSchemaVersion
  boundaryRequirement: { ... } | null
  status: "active" | "revoked"
  generation: unknown
  registeredBy: { ... } | { ... }
  registeredAt: ResourceDescriptorSchemaVersion
  registrationReceiptId: ResourceDescriptorSchemaVersion
  revokedAt: ResourceDescriptorSchemaVersion | null
  revocationReceiptId: ResourceDescriptorSchemaVersion | null
  family: ResourceFamily
  kindId: ResourceDescriptorSchemaVersion
  descriptorSchemaVersion: ResourceDescriptorSchemaVersion
  descriptor: ResourceDescriptorValue
  credentialBinding: ResourceCredentialBindingRef | null
  providerProtocolVersion: ResourceDescriptorSchemaVersion
  providerArtifactFingerprint: ResourceDescriptorSchemaVersion
  providerRefFormatVersion: ResourceDescriptorSchemaVersion
  writerPolicy: "serial" | "optimistic_cas" | "none"
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.get({
  ...
})

GET /gateway/v1/internal/space-resources/clones

Get node-local clone configuration

Parameters

resourceId · query · required
nodeId · query · required

Response

{
  ok: boolean
  data: ResourceCloneConfiguration = { ... } | null
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.getClone({
  ...
})

GET /gateway/v1/internal/space-resources/version

Get one Resource version

Parameters

versionId · query · required

Response

{
  ok: boolean
  data: SpaceResourceVersion = {
  schemaVersion: "space-resource-version.v2"
  ref: SpaceResourceVersionRef
  parentVersionRef: SpaceResourceVersionRef | null
  producerWorkRef: { ... } | null
  settlementReceiptId: ResourceDescriptorSchemaVersion
  restoredFromVersionRef: SpaceResourceVersionRef | null
  state: SpaceResourceVersionState
  createdAt: ResourceDescriptorSchemaVersion
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.getVersion({
  ...
})

GET /gateway/v1/internal/space-resources/head

Get the available Resource head

Parameters

resourceId · query · required

Response

{
  ok: boolean
  data: SpaceResourceVersion = {
  schemaVersion: "space-resource-version.v2"
  ref: SpaceResourceVersionRef
  parentVersionRef: SpaceResourceVersionRef | null
  producerWorkRef: { ... } | null
  settlementReceiptId: ResourceDescriptorSchemaVersion
  restoredFromVersionRef: SpaceResourceVersionRef | null
  state: SpaceResourceVersionState
  createdAt: ResourceDescriptorSchemaVersion
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.head({
  ...
})

POST /gateway/v1/internal/space-resources/fetch-grants

Issue a short-lived node-scoped fetch grant

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  node: {
  nodeId: unknown
}
}

Response

{
  ok: boolean
  data: IssueResourceFetchGrantResult = {
  grant: ResourceFetchGrant
  token: ResourceDescriptorSchemaVersion
  endpoint: ResourceDescriptorSchemaVersion
  fetchRefspec: ResourceDescriptorSchemaVersion
  availableOrdinal: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.issueFetchGrant({
  ...
})

GET /gateway/v1/internal/space-resources

List Space Resources

Parameters

spaceId · query · required
includeRevoked · query

Response

{
  ok: boolean
  data: SpaceResourceListResult = {
  resources: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.list({
  ...
})

GET /gateway/v1/internal/space-resources/kinds

List trusted Resource kinds

Response

{
  ok: boolean
  data: SpaceResourceKindListResult = {
  kinds: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.listKinds({
  ...
})

POST /gateway/v1/internal/space-resources/publications/list

List independent publication state for one Resource

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ResourcePublicationListResult = {
  publications: unknown
  unpublishedCount: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.listPublications({
  ...
})

GET /gateway/v1/internal/space-resources/receipts

List durable Resource receipts

Parameters

spaceId · query · required
resourceId · query
workId · query

Response

{
  ok: boolean
  data: SpaceResourceReceiptListResult = {
  receipts: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.listReceipts({
  ...
})

GET /gateway/v1/internal/space-resources/task-scope/requests

List Task Resource-scope expansion requests

Parameters

taskId · query · required
status · query

Response

{
  ok: boolean
  data: TaskResourceScopeExpansionListResult = {
  requests: unknown
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.listTaskScopeExpansions({
  ...
})

GET /gateway/v1/internal/space-resources/mentions

Resolve Resource mention handles

Parameters

handle · query · required
spaceId · query

Response

{
  ok: boolean
  data: SpaceResourceMentionLookupResult = {
  matches: { ... }[]
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.lookupMentions({
  ...
})

POST /gateway/v1/internal/space-resources/work-binding-proposals

Propose worker- or workflow-authored Work Resource bindings

Request

{
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  taskScopeRevisionId: ResourceDescriptorSchemaVersion = string
  selections: unknown
  primaryMentionHandle: ResourceDescriptorSchemaVersion = string | null
  initiator: "worker" | "workflow"
  reason: ResourceDescriptorSchemaVersion = string
  idempotencyKey: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: WorkResourceBindingSet = {
  revision: unknown
  bindings: unknown
  primaryResourceId: ResourceDescriptorSchemaVersion | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.proposeWorkBindings({
  ...
})

POST /gateway/v1/internal/space-resources/register

Register a provider-backed Resource

Request

{
  spaceId: ResourceDescriptorSchemaVersion = string
  displayName: ResourceDescriptorSchemaVersion = string
  mentionHandle: ResourceDescriptorSchemaVersion = string
  boundaryRequirement: {
  minimumClass: "unconfined" | "kernel_confined" | "container_confined" | "vm_confined"
  filesystem: "ambient" | "profile_enforced"
  network: { ... }
  process: "ambient" | "profile_enforced" | "namespace_isolated" | "vm_isolated"
  resources: "observed" | "kernel_enforced"
  acceptedCustodies: unknown
} | null
  family: ResourceFamily = "materializable_file_tree" | "connected_service"
  kindId: ResourceDescriptorSchemaVersion = string
  descriptorSchemaVersion: ResourceDescriptorSchemaVersion = string
  descriptor: ResourceDescriptorValue = null | boolean | number | "NaN" | "Infinity" | "-Infinity" | string | GatewayJsonValue[] | { [key: string]: unknown }
  credentialBinding: ResourceCredentialBindingRef = { ... } | { ... } | { ... } | null
}

Response

{
  ok: boolean
  data: SpaceResource = {
  schemaVersion: "space-resource.v2"
  resourceId: ResourceDescriptorSchemaVersion
  spaceId: ResourceDescriptorSchemaVersion
  displayName: ResourceDescriptorSchemaVersion
  mentionHandle: ResourceDescriptorSchemaVersion
  boundaryRequirement: { ... } | null
  status: "active" | "revoked"
  generation: unknown
  registeredBy: { ... } | { ... }
  registeredAt: ResourceDescriptorSchemaVersion
  registrationReceiptId: ResourceDescriptorSchemaVersion
  revokedAt: ResourceDescriptorSchemaVersion | null
  revocationReceiptId: ResourceDescriptorSchemaVersion | null
  family: ResourceFamily
  kindId: ResourceDescriptorSchemaVersion
  descriptorSchemaVersion: ResourceDescriptorSchemaVersion
  descriptor: ResourceDescriptorValue
  credentialBinding: ResourceCredentialBindingRef | null
  providerProtocolVersion: ResourceDescriptorSchemaVersion
  providerArtifactFingerprint: ResourceDescriptorSchemaVersion
  providerRefFormatVersion: ResourceDescriptorSchemaVersion
  writerPolicy: "serial" | "optimistic_cas" | "none"
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.register({
  ...
})

POST /gateway/v1/internal/space-resources/clones/remove

Remove an exact consented Resource remote from a node-local clone

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  node: {
  nodeId: unknown
}
}

Response

{
  ok: boolean
  data: {
  removed: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.removeClone({
  ...
})

POST /gateway/v1/internal/space-resources/rename

Rename a Resource mention handle

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  mentionHandle: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: SpaceResource = {
  schemaVersion: "space-resource.v2"
  resourceId: ResourceDescriptorSchemaVersion
  spaceId: ResourceDescriptorSchemaVersion
  displayName: ResourceDescriptorSchemaVersion
  mentionHandle: ResourceDescriptorSchemaVersion
  boundaryRequirement: { ... } | null
  status: "active" | "revoked"
  generation: unknown
  registeredBy: { ... } | { ... }
  registeredAt: ResourceDescriptorSchemaVersion
  registrationReceiptId: ResourceDescriptorSchemaVersion
  revokedAt: ResourceDescriptorSchemaVersion | null
  revocationReceiptId: ResourceDescriptorSchemaVersion | null
  family: ResourceFamily
  kindId: ResourceDescriptorSchemaVersion
  descriptorSchemaVersion: ResourceDescriptorSchemaVersion
  descriptor: ResourceDescriptorValue
  credentialBinding: ResourceCredentialBindingRef | null
  providerProtocolVersion: ResourceDescriptorSchemaVersion
  providerArtifactFingerprint: ResourceDescriptorSchemaVersion
  providerRefFormatVersion: ResourceDescriptorSchemaVersion
  writerPolicy: "serial" | "optimistic_cas" | "none"
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.renameMention({
  ...
})

POST /gateway/v1/internal/space-resources/publications/request

Create or recover an idempotent Resource publication intent

Request

{
  schemaVersion: "resource-publication.v1"
  resourceId: ResourceDescriptorSchemaVersion = string
  settledVersionId: ResourceDescriptorSchemaVersion = string
  settlementReceiptId: ResourceDescriptorSchemaVersion = string
  target: ResourcePublicationTarget = {
  remoteIdentity: ResourceDescriptorSchemaVersion
  targetRef: ResourceDescriptorSchemaVersion
  kind: "work_ref" | "named_branch"
}
  expectedRemoteState: ResourceProviderOpaqueValue = null | boolean | number | "NaN" | "Infinity" | "-Infinity" | string | GatewayJsonValue[] | { [key: string]: unknown } | null
  authorizationPolicyId: ResourceDescriptorSchemaVersion = string
  authorizationPolicyRevision: ResourceDescriptorSchemaVersion = string
  approval: {
  kind: "explicit_user_approval"
  approvedBy: ResourceDescriptorSchemaVersion
  approvedAt: ResourceDescriptorSchemaVersion
} | null
  idempotencyKey: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: ResourcePublicationView = {
  schemaVersion: "resource-publication.v1"
  publicationId: ResourceDescriptorSchemaVersion
  identity: ResourcePublicationIdentity
  target: ResourcePublicationTarget
  policy: PublishPolicy
  state: ResourcePublicationState
  blockedReason: ResourcePublicationBlockedReason | null
  attemptCount: unknown
  receipt: ResourcePublicationReceipt | null
  updatedAt: ResourceDescriptorSchemaVersion
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.requestPublication({
  ...
})

POST /gateway/v1/internal/space-resources/task-scope/request

Request a Task Resource-scope expansion

Request

{
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  currentRevisionId: ResourceDescriptorSchemaVersion = string
  requestedResourceIds: unknown
  reason: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: TaskResourceScopeExpansionRequest = {
  schemaVersion: "task-resource-scope-expansion.v1"
  requestId: ResourceDescriptorSchemaVersion
  taskRef: { ... }
  currentRevisionId: ResourceDescriptorSchemaVersion
  requestedResourceIds: unknown
  reason: ResourceDescriptorSchemaVersion
  status: "pending" | "approved" | "refused" | "superseded"
  requestedAt: ResourceDescriptorSchemaVersion
  decidedAt: ResourceDescriptorSchemaVersion | null
  decisionReceiptId: ResourceDescriptorSchemaVersion | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.requestTaskScopeExpansion({
  ...
})

POST /gateway/v1/internal/space-resources/restrict

Restrict Resource access

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  subject: SpaceResourceRestrictionSubject = { ... } | { ... } | { ... }
}

Response

{
  ok: boolean
  data: SpaceResourceRestriction = {
  schemaVersion: "space-resource.v2"
  restrictionId: ResourceDescriptorSchemaVersion
  spaceId: ResourceDescriptorSchemaVersion
  resourceId: ResourceDescriptorSchemaVersion
  effect: "deny"
  subject: SpaceResourceRestrictionSubject
  status: "active" | "revoked"
  receiptId: ResourceDescriptorSchemaVersion
  createdAt: ResourceDescriptorSchemaVersion
  revokedAt: ResourceDescriptorSchemaVersion | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.restrict({
  ...
})

POST /gateway/v1/internal/space-resources/revoke

Revoke a Space Resource

Request

{
  resourceId: ResourceDescriptorSchemaVersion = string
  expectedGeneration: unknown
  reason: ResourceDescriptorSchemaVersion = string
}

Response

{
  ok: boolean
  data: SpaceResource = {
  schemaVersion: "space-resource.v2"
  resourceId: ResourceDescriptorSchemaVersion
  spaceId: ResourceDescriptorSchemaVersion
  displayName: ResourceDescriptorSchemaVersion
  mentionHandle: ResourceDescriptorSchemaVersion
  boundaryRequirement: { ... } | null
  status: "active" | "revoked"
  generation: unknown
  registeredBy: { ... } | { ... }
  registeredAt: ResourceDescriptorSchemaVersion
  registrationReceiptId: ResourceDescriptorSchemaVersion
  revokedAt: ResourceDescriptorSchemaVersion | null
  revocationReceiptId: ResourceDescriptorSchemaVersion | null
  family: ResourceFamily
  kindId: ResourceDescriptorSchemaVersion
  descriptorSchemaVersion: ResourceDescriptorSchemaVersion
  descriptor: ResourceDescriptorValue
  credentialBinding: ResourceCredentialBindingRef | null
  providerProtocolVersion: ResourceDescriptorSchemaVersion
  providerArtifactFingerprint: ResourceDescriptorSchemaVersion
  providerRefFormatVersion: ResourceDescriptorSchemaVersion
  writerPolicy: "serial" | "optimistic_cas" | "none"
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.spaceResources.revoke({
  ...
})

11 operations

Tasks

#tasks

POST /gateway/v1/internal/tasks/{taskId}/archive

Archive Task

Parameters

taskId · path · required

Request

{
  archivedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.archive({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/cancel

Cancel Task

Parameters

taskId · path · required

Request

{
  reason?: ResourceDescriptorSchemaVersion = string | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.cancel({
  ...
})

GET /gateway/v1/internal/tasks/{taskId}

Get Task

Parameters

taskId · path · required

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.get({
  ...
})

GET /gateway/v1/internal/tasks

List Tasks

Parameters

spaceSlug · query
allSpaces · query
includeArchived · query

Response

{
  tasks: TaskRecord = { ... }[]
  work: WorkView = { ... }[]
  projections: TaskListProjection = { ... }[]
  snoozed?: {
  count: number
  taskIds: string[]
  nextWake: TaskWakeSchedule | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.list({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/rename

Rename Task

Parameters

taskId · path · required

Request

{
  title: ResourceDescriptorSchemaVersion = string
  recordedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.rename({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/settle

Settle Task

Parameters

taskId · path · required

Request

{
  settledAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.settle({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/snooze

Snooze Task

Parameters

taskId · path · required

Request

{
  snoozedUntil: ResourceDescriptorSchemaVersion = string
  snoozedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.snooze({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/unarchive

Unarchive Task

Parameters

taskId · path · required

Request

{
  archivedAt: ResourceDescriptorSchemaVersion = string
  unarchivedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.unarchive({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/unsettle

Unsettle Task

Parameters

taskId · path · required

Request

{
  unsettledAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.unsettle({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/unsnooze

Unsnooze Task

Parameters

taskId · path · required

Request

{
  unsnoozedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.unsnooze({
  ...
})

POST /gateway/v1/internal/tasks/{taskId}/viewed

Mark Task viewed

Parameters

taskId · path · required

Request

{
  viewedAt?: ResourceDescriptorSchemaVersion = string | null
  metadata?: { [key: string]: unknown } | null
}

Response

{
  task: TaskRecord = {
  schemaVersion: "task.v5"
  taskId: string
  title?: string | null
  status: "open" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: { ... }
  objective: { ... }
  currentObjectiveRevisionId: string
  resourceScope: TaskResourceScope
  currentResourceScopeRevisionId: string
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  dependencies: { ... }[]
  dependencyResolutions: { ... }[]
  workRefs: { ... }[]
  workBranchEdges: { ... }[]
  currentWorkRef: { ... } | null
  cancellation: { ... } | null
  result: { ... } | null
  activity?: { ... } | null
  archiveState?: { ... } | { ... } | null
  settledState?: { ... } | null
  settlementBlockers?: "pending_question" | "pending_approval" | "live_invocation"[] | null
  snoozeState?: { ... } | { ... } | null
  evidenceRefs: WorkEvidenceRef[]
  metadata?: { [key: string]: unknown } | null
}
  currentWorkId?: string
  workId?: string
  work?: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
  settlement?: TaskSettlement = {
  settled: boolean
  reason: "pending_question" | "pending_approval" | "live_invocation" | "explicitly_settled" | "pinned_active" | "idle_window_elapsed" | "within_idle_window"
  idleWindowMs: unknown
  autoSettlesAt: ResourceDescriptorSchemaVersion | null
  blockers: "pending_question" | "pending_approval" | "live_invocation"[]
}
  snooze?: TaskSnooze = {
  snoozed: boolean
  snoozedUntil: ResourceDescriptorSchemaVersion | null
  wake: { ... } | null
}
  placement?: "snoozed" | "settled" | "active"
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.tasks.viewed({
  ...
})

7 operations

UserMcpServers

#userMcpServers

POST /gateway/v1/internal/users/me/mcp-servers

userMcpServers.currentMcpServersCreate

Request

{
  serverId?: string | null
  name: string
  transport?: "stdio" | "streamable_http" | null
  url?: string | null
  command?: string | null
  args?: string[] | null
  env?: { ... }[] | null
  status?: "active" | "disabled" | null
  skipRuntimeRefresh?: boolean | null
}

Response

{
  ok: true
  data: {
  userId: string
  server: GatewayUserMcpServer = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersCreate({
  ...
})

DELETE /gateway/v1/internal/users/me/mcp-servers/{serverId}

userMcpServers.currentMcpServersDelete

Parameters

serverId · path · required

Response

{
  ok: true
  data: {
  userId: string
  serverId: string
  deleted: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersDelete({
  ...
})

POST /gateway/v1/internal/users/me/mcp-servers/{serverId}/disconnect

userMcpServers.currentMcpServersDisconnect

Parameters

serverId · path · required

Response

{
  ok: true
  data: {
  disconnected: boolean
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersDisconnect({
  ...
})

GET /gateway/v1/internal/users/me/mcp-servers/{serverId}

userMcpServers.currentMcpServersGet

Parameters

serverId · path · required

Response

{
  ok: true
  data: {
  userId: string
  server: GatewayUserMcpServer = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersGet({
  ...
})

GET /gateway/v1/internal/users/me/mcp-servers

userMcpServers.currentMcpServersList

Response

{
  ok: true
  data: {
  userId: string
  servers: GatewayUserMcpServer[]
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersList({
  ...
})

POST /gateway/v1/internal/users/me/mcp-servers/{serverId}/test

userMcpServers.currentMcpServersTest

Parameters

serverId · path · required

Response

{
  ok: true
  data: {
  userId: string
  state: "ready" | "error"
  error?: string | null
  capabilities: {
  tools: { ... }[]
  resources: { ... }[]
  prompts: { ... }[]
}
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersTest({
  ...
})

PATCH /gateway/v1/internal/users/me/mcp-servers/{serverId}

userMcpServers.currentMcpServersUpdate

Parameters

serverId · path · required

Request

{
  name?: string | null
  transport?: "stdio" | "streamable_http" | null
  url?: string | null
  command?: string | null
  args?: string[] | null
  env?: { ... }[] | null
  status?: "active" | "disabled" | null
  skipRuntimeRefresh?: boolean | null
}

Response

{
  ok: true
  data: {
  userId: string
  server: GatewayUserMcpServer = { ... }
}
}

SDK sample

import { createAsterGatewayClient } from "@aster/sdk"

const client = createAsterGatewayClient()
await client.userMcpServers.currentMcpServersUpdate({
  ...
})

5 operations

Work

#work

GET /gateway/v1/internal/work/{workId}/export

Read Work export

Parameters

workId · path · required
spaceSlug · query

Response

{
  bundle: WorkExportBundle = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workRef: WorkAddressRef
  title?: ResourceDescriptorSchemaVersion | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  objective: WorkObjective
  exportedAt: ResourceDescriptorSchemaVersion
  exportedBy?: ResourceDescriptorSchemaVersion | null
  selection: { ... }
  origin: WorkOrigin
  originEvidenceRefs: WorkEvidenceRef[]
  intent?: WorkIntent | null
  turns: { ... }[]
  turnClassifications: { ... }[]
  turnReplies: { ... }[]
  outputs: { ... }[]
  currentOutputId: string | null
  effectPolicy?: WorkEffectPolicyRevision | null
  parentLinks: WorkLineageRef[]
  childLinks: { ... }[]
  obligations: WorkObligation[]
  invocations: { ... }[]
  evidenceRefs: WorkEvidenceRef[]
  artifactRefs: WorkAddressRef[]
  receiptRefs: WorkAddressRef[]
  transcriptProjectionRefs: WorkAddressRef[]
  observerSnapshotRefs: WorkAddressRef[]
  authoritySummary?: WorkAuthorityState | null
  resourceSummary?: WorkResourceState | null
  verificationSummary: { ... }[]
  metadata?: { [key: string]: unknown } | null
  secretMaterial?: unknown | null
  providerCredentials?: unknown | null
  telemetry?: unknown | null
  runtimeState?: unknown | null
  processState?: unknown | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.work.export({
  ...
})

GET /gateway/v1/internal/work/{workId}

Get Work

Parameters

workId · path · required
spaceSlug · query

Response

{
  workId: string
  workRef: WorkAddressRef = { ... } | { ... } | { ... } | { ... } | { ... } | { ... } | { ... } | { ... } | { ... } | { ... } | { ... } | { ... }
  address: string
  work: WorkView = {
  schemaVersion: "work.v5"
  taskRef: { ... }
  workId: string
  title?: string | null
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  identity: { ... }
  origin: WorkOrigin
  objective: WorkObjective
  intent: WorkIntent
  createdAt: string
  updatedAt: string
  turnRefs: WorkAddressRef[]
  classificationRefs: WorkAddressRef[]
  replyEvidenceRefs: WorkEvidenceRef[]
  outputRefs: WorkAddressRef[]
  initiatingEvidenceRefs: WorkEvidenceRef[]
  currentResultEvidenceRefs: WorkEvidenceRef[]
  currentOutputId: string | null
  cognitiveBindingManifest?: { ... } | null
  effectPolicy?: WorkEffectPolicyRevision | null
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  evidenceRefs: WorkEvidenceRef[]
  lineage?: WorkLineageRef[] | null
  settlement: WorkSettlement | null
  authority: WorkAuthorityState
  resources: WorkResourceState
  resourceBindings: WorkResourceBindingSet
  routeDecisionId?: string | null | null
  metadata?: { [key: string]: unknown } | null
  turns?: unknown | null
  turnClassifications?: unknown | null
  turnReplies?: unknown | null
  outputs?: unknown | null
  content: WorkContentProjection
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.work.get({
  ...
})

GET /gateway/v1/internal/work/{workId}/inspect

Inspect Work

Parameters

workId · path · required
snapshotId · query
spaceSlug · query

Response

{
  snapshot: WorkObserverSnapshot = {
  schemaVersion: "observer.v6"
  ownerPrincipal: { ... } | { ... }
  snapshotId: string
  scope: { ... }
  capturedAt: ResourceDescriptorSchemaVersion
  objective: WorkObjective
  effectPolicy?: { ... } | null
  lineage: WorkLineageRef[]
  obligations: WorkObligation[]
  invocations: WorkInvocationRef[]
  grants: { ... } | { ... }[]
  settlement: WorkSettlement | null
  evidenceRefs: WorkEvidenceRef[]
  status: "accepted" | "routing" | "running" | "waiting" | "blocked" | "completed" | "failed" | "canceled"
  activeObligations: WorkObligation[]
  runningInvocations: WorkInvocationRef[]
  waitingInvocations: WorkInvocationRef[]
  authority: WorkAuthorityState
  authorityWaits: { ... }[]
  inputWaits: { ... }[]
  workflowWakes: { ... }[]
  orderingWaits?: { ... }[] | null
  capacityWaits?: { ... }[] | null
  recentEvidenceRefs: WorkEvidenceRef[]
  resourceState: WorkResourceState
  routeRationale: { ... }[]
  verificationStates?: { ... }[] | null
  compensationStates?: { ... }[] | null
  effectStates?: { ... }[] | null
  effectPolicyHolds?: { ... }[] | null
  durableSnapshotRef?: { ... } | null
  relatedRefs: WorkAddressRef[]
  summary?: ResourceDescriptorSchemaVersion | null
  metadata?: { [key: string]: unknown } | null
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.work.inspect({
  ...
})

GET /gateway/v1/internal/work

List Work

Parameters

spaceSlug · query

Response

{
  work: WorkView = { ... }[]
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.work.list({
  ...
})

4 operations

Workflows

#workflows

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/workflows/cancel

Cancel Workflow activation

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "workflow-product-command.v2"
  kind: "cancel"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  workflowId: ResourceDescriptorSchemaVersion = string
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  invocationRef: {
  kind: "invocation"
  workId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
}
  attemptRef: {
  kind: "attempt"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
  attemptId: ResourceDescriptorSchemaVersion = string
  attempt: unknown
}
  workflowRunRef: {
  kind: "workflow_run"
  workflowId: ResourceDescriptorSchemaVersion = string
  engineId: ResourceDescriptorSchemaVersion = string
  runId: ResourceDescriptorSchemaVersion = string
}
  reason: ResourceDescriptorSchemaVersion = string
  requestedAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "workflow-product-command.v2"
  kind: "canceled"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  canceledAt: ResourceDescriptorSchemaVersion = string
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  invocationRef: {
  kind: "invocation"
  workId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
}
  attemptRef: {
  kind: "attempt"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
  attemptId: ResourceDescriptorSchemaVersion = string
  attempt: unknown
}
  workflowRunRef: {
  kind: "workflow_run"
  workflowId: ResourceDescriptorSchemaVersion = string
  engineId: ResourceDescriptorSchemaVersion = string
  runId: ResourceDescriptorSchemaVersion = string
}
  cancellationEvidenceId?: ResourceDescriptorSchemaVersion = string | null
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.workflows.product.cancel({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/workflows/deliver

Deliver Workflow event

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "workflow-product-command.v2"
  kind: "deliver_event"
  workflowId: ResourceDescriptorSchemaVersion = string
  placement?: { ... } | { ... } | null
  sourceEvidenceRefs?: WorkEvidenceRef[] | null
  binding: {
  schemaVersion: "workflow-trigger-binding.v1"
  triggerId: ResourceDescriptorSchemaVersion = string
  connectorId: ResourceDescriptorSchemaVersion = string
  semantics: "start_activation" | "wake_served"
}
  event: {
  externalEventId: ResourceDescriptorSchemaVersion = string
  triggerId: ResourceDescriptorSchemaVersion = string
  type: ResourceDescriptorSchemaVersion = string
  occurredAt: ResourceDescriptorSchemaVersion = string
  payload?: unknown | null
  provenance?: { [key: string]: unknown } | null
  metadata?: { [key: string]: unknown } | null
}
  correlationId?: ResourceDescriptorSchemaVersion = string | null
  correlationKey?: { ... } | { ... } | { ... } | null
  requestedAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "workflow-product-command.v2"
  kind: "run_scheduled" | "delivery_scheduled"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  acceptedAt: ResourceDescriptorSchemaVersion = string
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  obligationRef: {
  kind: "obligation"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
}
  invocationRef: {
  kind: "invocation"
  workId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
}
  attemptRef: {
  kind: "attempt"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
  attemptId: ResourceDescriptorSchemaVersion = string
  attempt: unknown
}
  workflowRunRef: {
  kind: "workflow_run"
  workflowId: ResourceDescriptorSchemaVersion = string
  engineId: ResourceDescriptorSchemaVersion = string
  runId: ResourceDescriptorSchemaVersion = string
}
  originEvidenceRef: WorkEvidenceRef = {
  kind: "fact" | "artifact" | "receipt" | "diagnostic" | "projection"
  workId: string
  evidenceId: string
  contentAddress?: string | null
}
  externalEventId?: ResourceDescriptorSchemaVersion = string | null
  triggerId?: ResourceDescriptorSchemaVersion = string | null
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.workflows.product.deliver({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/workflows/resume

Resume a manually retryable Workflow activation

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "workflow-product-command.v2"
  kind: "resume"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  workflowId: ResourceDescriptorSchemaVersion = string
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  invocationRef: {
  kind: "invocation"
  workId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
}
  attemptRef: {
  kind: "attempt"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
  attemptId: ResourceDescriptorSchemaVersion = string
  attempt: unknown
}
  workflowRunRef: {
  kind: "workflow_run"
  workflowId: ResourceDescriptorSchemaVersion = string
  engineId: ResourceDescriptorSchemaVersion = string
  runId: ResourceDescriptorSchemaVersion = string
}
  requestedAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "workflow-product-command.v2"
  kind: "resumed"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  resumedAt: ResourceDescriptorSchemaVersion = string
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  invocationRef: {
  kind: "invocation"
  workId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
}
  attemptRef: {
  kind: "attempt"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
  attemptId: ResourceDescriptorSchemaVersion = string
  attempt: unknown
}
  workflowRunRef: {
  kind: "workflow_run"
  workflowId: ResourceDescriptorSchemaVersion = string
  engineId: ResourceDescriptorSchemaVersion = string
  runId: ResourceDescriptorSchemaVersion = string
}
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.workflows.product.resume({
  ...
})

POST /gateway/v1/internal/users/me/spaces/{spaceSlug}/workflows/run

Schedule Workflow activation

Parameters

spaceSlug · path · required

Request

{
  schemaVersion: "workflow-product-command.v2"
  kind: "run"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  workflowId: ResourceDescriptorSchemaVersion = string
  placement?: { ... } | { ... } | null
  input?: {
  prompt?: string | null
  data?: { [key: string]: unknown } | null
  metadata?: { [key: string]: unknown } | null
} | null
  requestedAt: ResourceDescriptorSchemaVersion = string
}

Response

{
  schemaVersion: "workflow-product-command.v2"
  kind: "run_scheduled" | "delivery_scheduled"
  idempotencyKey: ResourceDescriptorSchemaVersion = string
  acceptedAt: ResourceDescriptorSchemaVersion = string
  taskRef: {
  kind: "task"
  taskId: ResourceDescriptorSchemaVersion = string
}
  workRef: {
  kind: "work"
  workId: ResourceDescriptorSchemaVersion = string
}
  obligationRef: {
  kind: "obligation"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
}
  invocationRef: {
  kind: "invocation"
  workId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
}
  attemptRef: {
  kind: "attempt"
  workId: ResourceDescriptorSchemaVersion = string
  obligationId: ResourceDescriptorSchemaVersion = string
  invocationId: ResourceDescriptorSchemaVersion = string
  attemptId: ResourceDescriptorSchemaVersion = string
  attempt: unknown
}
  workflowRunRef: {
  kind: "workflow_run"
  workflowId: ResourceDescriptorSchemaVersion = string
  engineId: ResourceDescriptorSchemaVersion = string
  runId: ResourceDescriptorSchemaVersion = string
}
  originEvidenceRef: WorkEvidenceRef = {
  kind: "fact" | "artifact" | "receipt" | "diagnostic" | "projection"
  workId: string
  evidenceId: string
  contentAddress?: string | null
}
  externalEventId?: ResourceDescriptorSchemaVersion = string | null
  triggerId?: ResourceDescriptorSchemaVersion = string | null
}

SDK sample

import { createAsterGatewayClient } from "./client"

const client = createAsterGatewayClient()
await client.workflows.product.run({
  ...
})