@proteos/sdk 0.18.1

package/src/agent/session-types.ts

@@ -0,0 +1,397 @@
+/**
+ * Types for the agent-service Sessions API — a conversation with a configured
+ * Agent.
+ *
+ * Hand-written mirror of the Go models in `go.proteos.ai/model/agent`
+ * (`session.go`, `session-event.go`, `session-event-type.go`, `session-payload.go`,
+ * `session-content.go` + `api/session-requests.go`). Field names match the
+ * snake_case wire format exactly, including enum values.
+ *
+ * A Session is a thin mutable parent over an append-only `SessionEvent` log: the
+ * events are the source of truth, the session carries only identity, the agent it
+ * runs, a title and the latest lifecycle status. A {@link Turn} is a derived
+ * projection of the log (never stored).
+ */
+
+import type { AuditFields, ListOptions, UserRef } from '../types/common.js'
+import type { ToolKind } from './types.js'
+
+export type { ToolKind } from './types.js'
+
+// ---------------------------------------------------------------------------
+// Session
+// ---------------------------------------------------------------------------
+
+/**
+ * The latest lifecycle state of a session, projected from the `session.status_*`
+ * events. `idle` = ready for the next user message; `running` = a turn is in
+ * flight; `terminated` = ended; `error` = the last turn failed.
+ */
+export type SessionStatus = 'idle' | 'running' | 'terminated' | 'error'
+
+/**
+ * The rolled-up token accounting for a session — the sum of every model request's
+ * usage plus the request count, projected from the `span.model_request_end` events
+ * and kept on the session row so listings/headers can show cost without replaying
+ * the log. `total_tokens` is the derived input+output sum.
+ *
+ * `model` is the model the usage is attributed to. Managed Agents reports no model
+ * id on its usage events, so it is seeded once at session create from the agent's
+ * configured model and preserved across recomputes (empty on sessions created
+ * before usage tracking existed).
+ */
+export interface SessionUsage {
+  model: string
+  input_tokens: number
+  output_tokens: number
+  cache_read_input_tokens: number
+  cache_creation_input_tokens: number
+  total_tokens: number
+  request_count: number
+}
+
+/**
+ * One conversation with a configured Agent. Surrogate-keyed by `id` (a session is
+ * a graph node referenced by every event). `status` is denormalized from the
+ * event log for cheap listing; `usage` is the denormalized token total.
+ */
+export interface Session extends AuditFields {
+  org_id: string
+  id: string
+  agent_key: string
+  title: string
+  status: SessionStatus
+  usage: SessionUsage
+}
+
+// ---------------------------------------------------------------------------
+// Event types (the discriminant)
+// ---------------------------------------------------------------------------
+
+/**
+ * The discriminant of a {@link SessionEvent} — it selects which payload shape the
+ * event carries. v1 carries WHOLE events only; the delta/chunk variants
+ * (`agent.message.delta`, …) are intentionally absent.
+ */
+export type EventType =
+  // User-originated (posted via the API or echoed back by the provider).
+  | 'user.message'
+  | 'user.interrupt'
+  | 'user.tool_confirmation'
+  | 'user.tool_result'
+  // Agent-originated.
+  | 'agent.message'
+  | 'agent.reasoning'
+  | 'agent.tool_use'
+  | 'agent.tool_result'
+  | 'agent.context_compacted'
+  | 'agent.artifacts'
+  // Session lifecycle.
+  | 'session.status_running'
+  | 'session.status_idle'
+  | 'session.status_terminated'
+  | 'session.error'
+  | 'session.updated'
+  // Span (observability).
+  | 'span.model_request_start'
+  | 'span.model_request_end'
+
+/** The client-postable subset (everything else is produced by the runtime). */
+export type ClientEventType =
+  | 'user.message'
+  | 'user.interrupt'
+  | 'user.tool_confirmation'
+  | 'user.tool_result'
+
+// ---------------------------------------------------------------------------
+// Content blocks (the self-tagged pieces of heterogeneous payloads)
+// ---------------------------------------------------------------------------
+
+/** A plain text block. Agent messages are text-only. */
+export interface TextBlock {
+  type: 'text'
+  text: string
+}
+
+/**
+ * A file value object: a reference to a stored File (storage-service) plus light
+ * metadata. Embedded inline in a user-message {@link ContentBlock} (`type=file`)
+ * and nested under `image` in a tool {@link ResultBlock}.
+ */
+export interface FileBlock {
+  file_id?: string
+  file_name?: string
+  mime_type?: string
+  size_in_bytes?: number
+}
+
+/**
+ * One block of a user/agent message body. For `type=text` only `text` is set; for
+ * `type=file` the {@link FileBlock} fields are promoted inline.
+ */
+export interface ContentBlock extends FileBlock {
+  type: 'text' | 'file'
+  text?: string
+}
+
+/**
+ * One block of a tool result. Unlike message file blocks, an image nests its file
+ * under `image`; `json` carries an arbitrary raw object.
+ */
+export interface ResultBlock {
+  type: 'text' | 'image' | 'json'
+  text?: string
+  image?: FileBlock
+  json?: unknown
+}
+
+// ---------------------------------------------------------------------------
+// Event payloads (discriminated by the sibling event `type`)
+// ---------------------------------------------------------------------------
+
+/** A user message body (text + file blocks). */
+export interface UserMessagePayload {
+  content: ContentBlock[]
+}
+
+/** An agent message body (text blocks only). */
+export interface AgentMessagePayload {
+  content: TextBlock[]
+}
+
+/**
+ * Files the agent produced in its sandbox this turn (reconciled from the session
+ * outputs), surfaced as downloadable attachments on the agent turn. A turn can
+ * produce several. Each {@link FileBlock} carries the storage-service `file_id`.
+ */
+export interface AgentArtifactsPayload {
+  files: FileBlock[]
+}
+
+/**
+ * An agent reasoning ("thinking") block. v1 whole-events carry no text/signature
+ * from the provider, so both are typically empty.
+ */
+export interface ReasoningPayload {
+  text: string
+  signature?: string
+}
+
+/**
+ * A tool invocation. `id` is the provider's tool_use event id — the correlation
+ * key a matching {@link ToolResultPayload}'s `tool_use_id` points back to.
+ * `tool_kind` is the execution location (action | mcp | client).
+ */
+export interface ToolUsePayload {
+  id: string
+  name: string
+  input: unknown
+  tool_kind: ToolKind
+}
+
+/** The result of a tool invocation, linked to its use by `tool_use_id`. */
+export interface ToolResultPayload {
+  tool_use_id: string
+  result: ResultBlock[]
+  /** "success" | "error" (open string for forward-compat). */
+  outcome: string
+}
+
+/** A user's decision on a tool that requested approval. */
+export interface ToolConfirmationPayload {
+  tool_use_id: string
+  /** "approved" | "denied" (open string for forward-compat). */
+  decision: string
+}
+
+/** Announces that earlier context was summarized. */
+export interface ContextCompactedPayload {
+  summary: string
+}
+
+/** A session-level error. */
+export interface ErrorPayload {
+  message: string
+  code?: string
+}
+
+/**
+ * Why a turn went idle. `type` is an open string ("turn_ended" |
+ * "user_action_required" | …) so new provider reasons don't break decoding.
+ */
+export interface StopReason {
+  type: string
+}
+
+/**
+ * Emitted when a turn ends. `event_ids` carries the tool_use event ids awaiting a
+ * client response when `stop_reason.type` is `user_action_required`.
+ */
+export interface SessionIdlePayload {
+  stop_reason: StopReason
+  event_ids?: string[]
+}
+
+/**
+ * A server-side session metadata change — v1 carries the (often auto-generated)
+ * title. Projected onto {@link Session.title}; emitted only when the title changed.
+ */
+export interface SessionUpdatedPayload {
+  title?: string
+}
+
+/** Opens a model-request span. */
+export interface ModelRequestStartPayload {
+  model_id: string
+}
+
+/** Per-request token accounting. */
+export interface ModelUsage {
+  input_tokens: number
+  output_tokens: number
+  cache_read_input_tokens?: number
+  cache_creation_input_tokens?: number
+}
+
+/** Closes a model-request span with usage. */
+export interface ModelRequestEndPayload {
+  model_usage: ModelUsage
+}
+
+/**
+ * The body of events that carry no fields (`user.interrupt`,
+ * `session.status_running`, `session.status_terminated`).
+ */
+export type EmptyPayload = Record<string, never>
+
+// ---------------------------------------------------------------------------
+// SessionEvent (the append-only log envelope)
+// ---------------------------------------------------------------------------
+
+/** Shared envelope fields carried by every {@link SessionEvent}. */
+export interface SessionEventEnvelope {
+  /** Dedupe key: our uuid for user events, the provider's id for agent events. */
+  id: string
+  session_id: string
+  org_id: string
+  /** Groups events into user/agent turns. */
+  turn_id: string
+  /** Per-session monotonic cursor (the SSE frame `id`). */
+  seq: number
+  created_by: UserRef
+  /** Meaningful only for user events: null = queued, timestamp = consumed. */
+  processed_at: string | null
+  created_at: string
+}
+
+/**
+ * One entry of the append-only session log — discriminated by `type`. The same
+ * envelope is delivered byte-for-byte over both the durable (REST) and live (SSE)
+ * channels, keyed by the same `seq`, so the two merge into one ordered log.
+ */
+export type SessionEvent = SessionEventEnvelope &
+  (
+    | { type: 'user.message'; payload: UserMessagePayload }
+    | { type: 'user.interrupt'; payload: EmptyPayload }
+    | { type: 'user.tool_confirmation'; payload: ToolConfirmationPayload }
+    | { type: 'user.tool_result'; payload: ToolResultPayload }
+    | { type: 'agent.message'; payload: AgentMessagePayload }
+    | { type: 'agent.reasoning'; payload: ReasoningPayload }
+    | { type: 'agent.tool_use'; payload: ToolUsePayload }
+    | { type: 'agent.tool_result'; payload: ToolResultPayload }
+    | { type: 'agent.context_compacted'; payload: ContextCompactedPayload }
+    | { type: 'agent.artifacts'; payload: AgentArtifactsPayload }
+    | { type: 'session.status_running'; payload: EmptyPayload }
+    | { type: 'session.status_idle'; payload: SessionIdlePayload }
+    | { type: 'session.status_terminated'; payload: EmptyPayload }
+    | { type: 'session.error'; payload: ErrorPayload }
+    | { type: 'session.updated'; payload: SessionUpdatedPayload }
+    | { type: 'span.model_request_start'; payload: ModelRequestStartPayload }
+    | { type: 'span.model_request_end'; payload: ModelRequestEndPayload }
+  )
+// A closed discriminated union (the v1 event set) so consumers narrow `payload`
+// by `type`. An unrecognized future event type still parses at runtime (it is cast
+// from JSON) — a switch over `type` simply won't match it, which is the intended
+// skip-and-ignore behavior.
+
+/**
+ * The `GroupByTurn` projection — NEVER stored, recomputed from the event log.
+ * `events` hold the envelopes verbatim, grouped by `turn_id` and ordered by `seq`.
+ * The web folds this client-side from the live event stream; this type mirrors the
+ * server's `GET /sessions/:id/turns` for completeness.
+ */
+export interface Turn {
+  id: string
+  role: 'user' | 'agent'
+  events: SessionEvent[]
+}
+
+// ---------------------------------------------------------------------------
+// Requests / query options
+// ---------------------------------------------------------------------------
+
+/**
+ * A client tool the launching surface advertises when it opens a session: a custom
+ * tool the agent calls but the browser renders/executes, returning the result. Only
+ * these three fields cross the wire — the render slot and React component are
+ * frontend-only. `input_schema` is a JSON Schema (draft-07) object.
+ */
+export interface ClientToolSchema {
+  name: string
+  description: string
+  input_schema: Record<string, unknown>
+}
+
+/**
+ * Opens a session against a configured agent. `title` is optional. `client_tools` is
+ * the launching surface's client-tool catalog, attached to this session only — a
+ * surface that can't render them simply omits the field, so the agent never gets a
+ * tool nobody can answer.
+ */
+export interface CreateSessionRequest {
+  agent_key: string
+  title?: string
+  client_tools?: ClientToolSchema[]
+}
+
+/**
+ * Posts a client event onto a session. Only client-postable `user.*` types are
+ * accepted; `payload` is the matching payload for the `type`.
+ */
+export interface AppendEventRequest {
+  type: ClientEventType
+  /**
+   * Optionally supply the turn's id (a UUID) so the client can render the message
+   * optimistically under a stable identity that matches the event echoed back
+   * over the stream. Omitted, the service mints one.
+   */
+  turn_id?: string
+  payload?: unknown
+}
+
+/** List filter for sessions (in addition to pagination/sorting). */
+export interface ListSessionsOptions extends ListOptions {
+  /** Filter by the agent the session runs. */
+  agent_key?: string
+}
+
+/**
+ * Forward cursor over the durable event log. `after_seq` is the exclusive lower
+ * bound (the last-seen seq); `order` defaults to asc (chronological). `types`
+ * restricts the result to specific event types (e.g. `['agent.message']`);
+ * omitted, every type is returned.
+ */
+export interface SessionEventsOptions {
+  after_seq?: number
+  limit?: number
+  order?: 'asc' | 'desc'
+  types?: EventType[]
+}
+
+/** Options for opening the live SSE stream. */
+export interface SessionStreamOptions {
+  /** Replay from this seq (exclusive) before following live. */
+  afterSeq?: number
+  /** Abort to tear the stream down. */
+  signal?: AbortSignal
+}

package/src/agent/sessions.ts

@@ -0,0 +1,197 @@
+import type { ProteosClient } from '../client.js'
+import { PageIterator } from '../iterator.js'
+import type { ListResult } from '../types/common.js'
+import type {
+  AppendEventRequest,
+  ContentBlock,
+  CreateSessionRequest,
+  FileBlock,
+  ListSessionsOptions,
+  ResultBlock,
+  Session,
+  SessionEvent,
+  SessionEventsOptions,
+  SessionStreamOptions,
+  Turn,
+} from './session-types.js'
+
+const SESSIONS_BASE_PATH = '/agents/v1/sessions'
+
+/**
+ * Service for managing agent Sessions — a conversation with a configured Agent,
+ * backed by an append-only event log. Covers the full agent-service session
+ * surface: CRUD, the durable event history, posting client events, the derived
+ * turns projection, and the live SSE stream.
+ */
+export interface SessionService {
+  /** Lists sessions, auto-paginating. */
+  list(options?: ListSessionsOptions): PageIterator<Session, ListSessionsOptions>
+  /** Fetches a single page of sessions with pagination metadata. */
+  listPage(options?: ListSessionsOptions): Promise<ListResult<Session>>
+  /** Gets a single session by id. @throws {ProteosError} 404 if not found. */
+  get(id: string): Promise<Session>
+  /** Opens a new session against a configured agent. @throws {ProteosError} 400. */
+  create(request: CreateSessionRequest): Promise<Session>
+
+  /**
+   * Reads a page of the durable event log (Postgres), a forward `after_seq`
+   * cursor ordered ascending by default. The live channel is {@link stream}.
+   */
+  events(id: string, options?: SessionEventsOptions): Promise<SessionEvent[]>
+  /** Posts a client (`user.*`) event onto a session. @throws {ProteosError} 400/409. */
+  appendEvent(id: string, request: AppendEventRequest): Promise<SessionEvent>
+  /** The server-side `GroupByTurn` projection of the full event log. */
+  turns(id: string): Promise<Turn[]>
+
+  /**
+   * Live-tails the session's event stream over SSE, yielding each
+   * {@link SessionEvent} as it arrives. Replays from `afterSeq` (exclusive) then
+   * follows live; reconnects resume gap-free. Runs until the `AbortSignal` fires.
+   */
+  stream(id: string, options?: SessionStreamOptions): AsyncGenerator<SessionEvent, void, unknown>
+
+  /**
+   * Convenience: appends a `user.message` with a single text block. Pass
+   * `turnId` (a UUID) to supply the turn's id so the caller can render the
+   * message optimistically under an id matching the echoed event.
+   */
+  sendMessage(id: string, text: string, turnId?: string): Promise<SessionEvent>
+  /**
+   * Convenience: appends a `user.message` built from optional text and file
+   * attachments. Each {@link FileBlock} carries the storage-service `file_id`; the
+   * backend uploads it to the model provider and mounts it into the agent's sandbox
+   * at send time. Pass `turnId` (a UUID) for optimistic rendering. At least one of
+   * `text` / `files` should be present.
+   */
+  sendUserMessage(
+    id: string,
+    input: { text?: string; files?: FileBlock[]; turnId?: string },
+  ): Promise<SessionEvent>
+  /** Convenience: appends a `user.interrupt` to halt the running turn. */
+  interrupt(id: string): Promise<SessionEvent>
+  /**
+   * Convenience: appends a `user.tool_result` answering a client tool the agent
+   * called (an `agent.tool_use` with `tool_kind: 'client'`). `toolUseId` is that
+   * tool-use event's id (carried in the idle event's `event_ids`); the backend
+   * relays the result to Anthropic as a `user.custom_tool_result` to resume the turn.
+   * `outcome` defaults to `'success'`.
+   */
+  submitToolResult(
+    id: string,
+    input: { toolUseId: string; result: ResultBlock[]; outcome?: 'success' | 'error' },
+  ): Promise<SessionEvent>
+}
+
+export class SessionServiceImpl implements SessionService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(options: ListSessionsOptions = {}): PageIterator<Session, ListSessionsOptions> {
+    return new PageIterator((opts) => this.listPage(opts), options)
+  }
+
+  async listPage(options: ListSessionsOptions = {}): Promise<ListResult<Session>> {
+    return this.client.requestWithQuery<ListResult<Session>>('GET', SESSIONS_BASE_PATH, options)
+  }
+
+  async get(id: string): Promise<Session> {
+    return this.client.request<Session>('GET', `${SESSIONS_BASE_PATH}/${id}`)
+  }
+
+  async create(request: CreateSessionRequest): Promise<Session> {
+    return this.client.request<Session>('POST', SESSIONS_BASE_PATH, request)
+  }
+
+  async events(id: string, options: SessionEventsOptions = {}): Promise<SessionEvent[]> {
+    // The backend reads `types` as a single comma-separated query param (a string
+    // it splits into a `type IN (...)` filter), so join the array rather than
+    // letting the serializer emit repeated `types=` params.
+    const { types, ...rest } = options
+    const query = {
+      ...rest,
+      ...(types && types.length > 0 ? { types: types.join(',') } : {}),
+    }
+    const response = await this.client.requestWithQuery<{ data: SessionEvent[] }>(
+      'GET',
+      `${SESSIONS_BASE_PATH}/${id}/events`,
+      query,
+    )
+    return response.data ?? []
+  }
+
+  async appendEvent(id: string, request: AppendEventRequest): Promise<SessionEvent> {
+    return this.client.request<SessionEvent>('POST', `${SESSIONS_BASE_PATH}/${id}/events`, request)
+  }
+
+  async turns(id: string): Promise<Turn[]> {
+    const response = await this.client.request<{ data: Turn[] }>(
+      'GET',
+      `${SESSIONS_BASE_PATH}/${id}/turns`,
+    )
+    return response.data ?? []
+  }
+
+  async *stream(
+    id: string,
+    options: SessionStreamOptions = {},
+  ): AsyncGenerator<SessionEvent, void, unknown> {
+    const query = options.afterSeq ? `?after_seq=${options.afterSeq}` : ''
+    const path = `${SESSIONS_BASE_PATH}/${id}/events/stream${query}`
+    const streamOptions = options.signal ? { signal: options.signal } : {}
+    for await (const frame of this.client.streamEvents(path, streamOptions)) {
+      const event = parseEvent(frame.data)
+      if (event) yield event
+    }
+  }
+
+  async sendMessage(id: string, text: string, turnId?: string): Promise<SessionEvent> {
+    return this.sendUserMessage(id, { text, ...(turnId ? { turnId } : {}) })
+  }
+
+  async sendUserMessage(
+    id: string,
+    input: { text?: string; files?: FileBlock[]; turnId?: string },
+  ): Promise<SessionEvent> {
+    const content: ContentBlock[] = []
+    const text = input.text?.trim()
+    if (text) content.push({ type: 'text', text })
+    for (const file of input.files ?? []) {
+      content.push({ type: 'file', ...file })
+    }
+    return this.appendEvent(id, {
+      type: 'user.message',
+      ...(input.turnId ? { turn_id: input.turnId } : {}),
+      payload: { content },
+    })
+  }
+
+  async interrupt(id: string): Promise<SessionEvent> {
+    return this.appendEvent(id, { type: 'user.interrupt' })
+  }
+
+  async submitToolResult(
+    id: string,
+    input: { toolUseId: string; result: ResultBlock[]; outcome?: 'success' | 'error' },
+  ): Promise<SessionEvent> {
+    return this.appendEvent(id, {
+      type: 'user.tool_result',
+      payload: {
+        tool_use_id: input.toolUseId,
+        result: input.result,
+        outcome: input.outcome ?? 'success',
+      },
+    })
+  }
+}
+
+/**
+ * Parses one SSE frame's `data` into a SessionEvent, returning null for an empty
+ * or unparseable frame — a single bad frame is skipped, not fatal to the stream.
+ */
+function parseEvent(data: string): SessionEvent | null {
+  if (!data) return null
+  try {
+    return JSON.parse(data) as SessionEvent
+  } catch {
+    return null
+  }
+}

package/src/agent/skills.ts

@@ -0,0 +1,89 @@
+import type { ProteosClient } from '../client.js'
+import { PageIterator } from '../iterator.js'
+import type { ListResult } from '../types/common.js'
+import type { ListSkillsOptions, Skill, SkillVersion } from './types.js'
+
+const SKILLS_BASE_PATH = '/agents/v1/skills'
+
+/**
+ * Service for managing Skills — versioned bundles of instructions + files in the
+ * Anthropic Agent-Skills shape. Skills are created and updated only via
+ * {@link SkillService.deploy} (a multipart bundle upload); there is no JSON
+ * create/update.
+ */
+export interface SkillService {
+  /** Lists skills, auto-paginating. */
+  list(options?: ListSkillsOptions): PageIterator<Skill, ListSkillsOptions>
+  /** Fetches a single page of skills with pagination metadata. */
+  listPage(options?: ListSkillsOptions): Promise<ListResult<Skill>>
+  /** Gets a skill (with its current version + bundle pin) by key. @throws {ProteosError} 404. */
+  get(key: string): Promise<Skill>
+  /**
+   * Deploys a skill bundle (a `.tar.gz` containing `SKILL.md` at the root plus
+   * supporting files). The skill's key — its canonical identifier — is read
+   * from the bundle's `SKILL.md` frontmatter `name`, so no key is supplied here.
+   * Creates the skill on first deploy and a new immutable version each time.
+   *
+   * @param bundle - The `.tar.gz` bundle bytes.
+   * @param options.displayName - Optional human-readable display name.
+   * @param options.moduleSlug - Optional owning module slug (tags the skill so it
+   *   can be filtered + round-tripped by module). Empty for a standalone deploy.
+   */
+  deploy(bundle: Blob | File, options?: { displayName?: string; moduleSlug?: string }): Promise<Skill>
+  /** Deletes a skill and all its versions. @throws {ProteosError} 404. */
+  delete(key: string): Promise<void>
+  /** Lists all immutable versions of a skill, newest first. */
+  listVersions(key: string): Promise<SkillVersion[]>
+  /** Gets a specific immutable version by number. @throws {ProteosError} 404. */
+  getVersion(key: string, number: number): Promise<SkillVersion>
+}
+
+export class SkillServiceImpl implements SkillService {
+  constructor(private readonly client: ProteosClient) {}
+
+  list(options: ListSkillsOptions = {}): PageIterator<Skill, ListSkillsOptions> {
+    return new PageIterator((opts) => this.listPage(opts), options)
+  }
+
+  async listPage(options: ListSkillsOptions = {}): Promise<ListResult<Skill>> {
+    return this.client.requestWithQuery<ListResult<Skill>>('GET', SKILLS_BASE_PATH, options)
+  }
+
+  async get(key: string): Promise<Skill> {
+    return this.client.request<Skill>('GET', `${SKILLS_BASE_PATH}/${key}`)
+  }
+
+  async deploy(
+    bundle: Blob | File,
+    options?: { displayName?: string; moduleSlug?: string },
+  ): Promise<Skill> {
+    const formData = new FormData()
+    const filename = bundle instanceof File ? bundle.name : 'skill.tar.gz'
+    formData.append('bundle', bundle, filename)
+    if (options?.displayName) {
+      formData.append('display_name', options.displayName)
+    }
+    if (options?.moduleSlug) {
+      formData.append('module_slug', options.moduleSlug)
+    }
+    // Returns a bare Skill (no `{ data }` envelope). The key is derived from the
+    // bundle's SKILL.md frontmatter server-side.
+    return this.client.requestMultipart<Skill>('POST', `${SKILLS_BASE_PATH}/deploy`, formData)
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.client.request<void>('DELETE', `${SKILLS_BASE_PATH}/${key}`)
+  }
+
+  async listVersions(key: string): Promise<SkillVersion[]> {
+    const response = await this.client.request<{ data: SkillVersion[] }>(
+      'GET',
+      `${SKILLS_BASE_PATH}/${key}/versions`,
+    )
+    return response.data
+  }
+
+  async getVersion(key: string, number: number): Promise<SkillVersion> {
+    return this.client.request<SkillVersion>('GET', `${SKILLS_BASE_PATH}/${key}/versions/${number}`)
+  }
+}