@mutagent/sdk 0.3.37 → 0.3.39

package/src/models/{schemadefaul3.ts → schemadefaul8.ts}

@@ -4,12 +4,12 @@
 
 import * as z from "zod/v4-mini";
 
-export enum Schemadefaul3 {
+export enum Schemadefaul8 {
   Admin = "admin",
   Editor = "editor",
   Viewer = "viewer",
 }
 
 /** @internal */
-export const Schemadefaul3$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul3> =
-  z.enum(Schemadefaul3);
+export const Schemadefaul8$outboundSchema: z.ZodMiniEnum<typeof Schemadefaul8> =
+  z.enum(Schemadefaul8);

package/src/models/session-id-line.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type SessionIdLine = {
+  /**
+   * The Helix session to write to — from the `start` that created it.
+   */
+  sessionId: string;
+  /**
+   * Exactly one JSON object, serialised. No trailing newline — the box appends it, so one call cannot smuggle two commands. A value that is not a single JSON object is a 400.
+   */
+  line: string;
+};
+
+/** @internal */
+export type SessionIdLine$Outbound = {
+  sessionId: string;
+  line: string;
+};
+
+/** @internal */
+export const SessionIdLine$outboundSchema: z.ZodMiniType<
+  SessionIdLine$Outbound,
+  SessionIdLine
+> = z.object({
+  sessionId: z.string(),
+  line: z.string(),
+});
+
+export function sessionIdLineToJSON(sessionIdLine: SessionIdLine): string {
+  return JSON.stringify(SessionIdLine$outboundSchema.parse(sessionIdLine));
+}

package/src/models/session-id-signal.ts

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export enum Signal {
+  Sigint = "SIGINT",
+  Sigterm = "SIGTERM",
+}
+
+export type SessionIdSignal = {
+  /**
+   * The Helix session to signal — from the `start` that created it.
+   */
+  sessionId: string;
+  signal: Signal;
+};
+
+/** @internal */
+export const Signal$outboundSchema: z.ZodMiniEnum<typeof Signal> = z.enum(
+  Signal,
+);
+
+/** @internal */
+export type SessionIdSignal$Outbound = {
+  sessionId: string;
+  signal: string;
+};
+
+/** @internal */
+export const SessionIdSignal$outboundSchema: z.ZodMiniType<
+  SessionIdSignal$Outbound,
+  SessionIdSignal
+> = z.object({
+  sessionId: z.string(),
+  signal: Signal$outboundSchema,
+});
+
+export function sessionIdSignalToJSON(
+  sessionIdSignal: SessionIdSignal,
+): string {
+  return JSON.stringify(SessionIdSignal$outboundSchema.parse(sessionIdSignal));
+}

package/src/sdk/provider-configs.ts

@@ -87,7 +87,7 @@ export class ProviderConfigs extends ClientSDK {
    * Update provider config
    *
    * @remarks
-   * Update an existing provider configuration. If API key is provided, it will be re-encrypted.
+   * Update an existing provider configuration. When the patch replaces the SECRET — the apiKey field, or the catalog-named secret inside credentialFields — the new credential is connection-tested BEFORE it is written, the same guarantee POST /providers makes on create. A failed test writes nothing: the existing configuration, including fields elsewhere in the same request, is left exactly as it was. Non-secret changes (baseUrl, hostedFamily, apiVersion, other credentialFields entries) are applied without a live probe.
    */
   async updateProvider(
     request: operations.UpdateProviderRequest,
@@ -121,7 +121,7 @@ export class ProviderConfigs extends ClientSDK {
    * Get models catalog
    *
    * @remarks
-   * Returns the union of static known models and declared provider models for a workspace. Used by the optimizer dropdown.
+   * Returns the union of static known models and declared provider models for a workspace.
    */
   async getModelsCatalog(
     options?: RequestOptions,
@@ -136,7 +136,7 @@ export class ProviderConfigs extends ClientSDK {
    * List a provider configuration models
    *
    * @remarks
-   * The models this provider configuration offers, listed live from the provider and narrowed to the catalog's allow-list policy, with this workspace's per-model enablement applied. When the provider cannot be reached the stored allow-list is returned with `degraded: true` and the reason — an empty list is never presented as 'no models'.
+   * The models this provider configuration offers, listed live from the provider and narrowed to the catalog's allow-list policy, with this workspace's per-model enablement applied. When the provider cannot be reached the stored allow-list is returned with `degraded: true` and the reason — an empty list is never presented as 'no models'. Responses are cached for 60s per (workspace, configuration) and the route is additionally rate-limited, since a cache miss decrypts a credential and calls the live provider.
    */
   async listProviderModels(
     request: operations.ListProviderModelsRequest,

package/src/sdk/sandbox.ts

@@ -3,6 +3,7 @@
  */
 
 import { sandboxDeleteApiSandboxById } from "../funcs/sandbox-delete-api-sandbox-by-id.js";
+import { sandboxGetApiSandboxByIdSessions } from "../funcs/sandbox-get-api-sandbox-by-id-sessions.js";
 import { sandboxGetApiSandboxByIdStream } from "../funcs/sandbox-get-api-sandbox-by-id-stream.js";
 import { sandboxGetApiSandboxByIdTraces } from "../funcs/sandbox-get-api-sandbox-by-id-traces.js";
 import { sandboxGetApiSandboxById } from "../funcs/sandbox-get-api-sandbox-by-id.js";
@@ -11,27 +12,46 @@ import { sandboxGetApiSandboxProviders } from "../funcs/sandbox-get-api-sandbox-
 import { sandboxGetApiSandbox } from "../funcs/sandbox-get-api-sandbox.js";
 import { sandboxPostApiSandboxAgentRun } from "../funcs/sandbox-post-api-sandbox-agent-run.js";
 import { sandboxPostApiSandboxByIdExec } from "../funcs/sandbox-post-api-sandbox-by-id-exec.js";
+import { sandboxPostApiSandboxByIdInput } from "../funcs/sandbox-post-api-sandbox-by-id-input.js";
+import { sandboxPostApiSandboxByIdSession } from "../funcs/sandbox-post-api-sandbox-by-id-session.js";
+import { sandboxPostApiSandboxByIdSignal } from "../funcs/sandbox-post-api-sandbox-by-id-signal.js";
 import { sandboxPostApiSandboxPreflight } from "../funcs/sandbox-post-api-sandbox-preflight.js";
 import { sandboxPostApiSandboxRun } from "../funcs/sandbox-post-api-sandbox-run.js";
 import { sandboxPostApiSandboxTelemetryV1Traces } from "../funcs/sandbox-post-api-sandbox-telemetry-v1-traces.js";
 import { sandboxPostApiSandboxToken } from "../funcs/sandbox-post-api-sandbox-token.js";
 import { sandboxPostApiSandbox } from "../funcs/sandbox-post-api-sandbox.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
 export class Sandbox extends ClientSDK {
   /**
-   * Spawn a sandbox
+   * List sandbox providers
    *
    * @remarks
-   * Requires an operator token. A session or task token is rejected with 403.
+   * Providers this backend can reach and which is the default. A CLI that has no provider configured uses the default.
    */
-  async postApiSandbox(
-    request: operations.PostApiSandboxRequest,
+  async getApiSandboxProviders(
     options?: RequestOptions,
-  ): Promise<operations.PostApiSandboxResponse> {
-    return unwrapAsync(sandboxPostApiSandbox(
+  ): Promise<operations.GetApiSandboxProvidersResponse> {
+    return unwrapAsync(sandboxGetApiSandboxProviders(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Preflight a sandbox definition
+   *
+   * @remarks
+   * Validate a definition against a provider without creating anything. Returns every violation, not just the first.
+   */
+  async postApiSandboxPreflight(
+    request: models.DefinitionProvider,
+    options?: RequestOptions,
+  ): Promise<operations.PostApiSandboxPreflightResponse> {
+    return unwrapAsync(sandboxPostApiSandboxPreflight(
       this,
       request,
       options,
@@ -39,15 +59,15 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * List sandboxes
+   * List sandbox presets
    *
    * @remarks
-   * Always tenant-scoped. There is no unscoped listing path.
+   * Named definitions a one-shot run can name. A preset is what lets a caller run something without knowing our registry, region or image tag. Image references are deliberately not returned.
    */
-  async getApiSandbox(
+  async getApiSandboxPresets(
     options?: RequestOptions,
-  ): Promise<Array<operations.GetApiSandboxResponse>> {
-    return unwrapAsync(sandboxGetApiSandbox(
+  ): Promise<operations.GetApiSandboxPresetsResponse> {
+    return unwrapAsync(sandboxGetApiSandboxPresets(
       this,
       options,
     ));
@@ -60,7 +80,7 @@ export class Sandbox extends ClientSDK {
    * Spawns from a preset, runs the command, tears the sandbox down. Requires an operator token — a one-shot run creates a sandbox. 200, not 201: the durable outcome is a result, and the sandbox it names is already gone unless `keep` was set. Blocking, and therefore bounded by the provider invocation timeout — long or interactive runs belong on POST /api/sandbox + /:id/exec.
    */
   async postApiSandboxRun(
-    request: operations.PostApiSandboxRunRequest,
+    request: models.PresetTimeoutMsKeep,
     options?: RequestOptions,
   ): Promise<operations.PostApiSandboxRunResponse> {
     return unwrapAsync(sandboxPostApiSandboxRun(
@@ -88,46 +108,62 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * List sandbox presets
+   * Spawn a sandbox
    *
    * @remarks
-   * Named definitions a one-shot run can name. A preset is what lets a caller run something without knowing our registry, region or image tag. Image references are deliberately not returned.
+   * Requires an operator token. A session or task token is rejected with 403.
    */
-  async getApiSandboxPresets(
+  async postApiSandbox(
+    request: models.DefinitionRunId,
     options?: RequestOptions,
-  ): Promise<operations.GetApiSandboxPresetsResponse> {
-    return unwrapAsync(sandboxGetApiSandboxPresets(
+  ): Promise<operations.PostApiSandboxResponse> {
+    return unwrapAsync(sandboxPostApiSandbox(
       this,
+      request,
       options,
     ));
   }
 
   /**
-   * List sandbox providers
+   * List sandboxes
    *
    * @remarks
-   * Providers this backend can reach and which is the default. A CLI that has no provider configured uses the default.
+   * Always tenant-scoped. There is no unscoped listing path.
    */
-  async getApiSandboxProviders(
+  async getApiSandbox(
     options?: RequestOptions,
-  ): Promise<operations.GetApiSandboxProvidersResponse> {
-    return unwrapAsync(sandboxGetApiSandboxProviders(
+  ): Promise<Array<operations.GetApiSandboxResponse>> {
+    return unwrapAsync(sandboxGetApiSandbox(
       this,
       options,
     ));
   }
 
   /**
-   * Preflight a sandbox definition
+   * Get sandbox status
+   */
+  async getApiSandboxById(
+    request: operations.GetApiSandboxByIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetApiSandboxByIdResponse> {
+    return unwrapAsync(sandboxGetApiSandboxById(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Tear down a sandbox
    *
    * @remarks
-   * Validate a definition against a provider without creating anything. Returns every violation, not just the first.
+   * Idempotent. The record is forgotten even if the provider teardown fails.
    */
-  async postApiSandboxPreflight(
-    request: operations.PostApiSandboxPreflightRequest,
+  async deleteApiSandboxById(
+    request: operations.DeleteApiSandboxByIdRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostApiSandboxPreflightResponse> {
-    return unwrapAsync(sandboxPostApiSandboxPreflight(
+  ): Promise<operations.DeleteApiSandboxByIdResponse> {
+    return unwrapAsync(sandboxDeleteApiSandboxById(
       this,
       request,
       options,
@@ -135,16 +171,16 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * Exchange a platform API key for a sandbox operator token
+   * Watch a sandbox's output live
    *
    * @remarks
-   * Trades a platform API key (`x-api-key: mg_live_…`) for a short-lived operator token scoped to one workspace. The caller must be able to create resources in that workspace.
+   * Server-sent events: `stdout`, `stderr`, `rpc`, `unrecognised`, `status`, `ping` (every 15s), `error`. `rpc` carries one complete NDJSON frame from a Helix session running in RPC mode, verbatim — parse it client-side. `unrecognised` carries a line the backend could not classify; receiving one means this server and the sandbox image disagree about the protocol, and it is forwarded rather than dropped so that drift is visible instead of silent. All four output events share the `{seq, ts, text}` shape and one sequence counter, so their interleaving is the order the box produced them. `seq` is monotonic per sandbox and starts at 1; pass the last one seen as `?since=` to resume. If the buffer has already rolled past `since`, an `error` event names the lost range rather than skipping it silently. Disconnecting tears down the upstream.
    */
-  async postApiSandboxToken(
-    request: operations.PostApiSandboxTokenRequest,
+  async getApiSandboxByIdStream(
+    request: operations.GetApiSandboxByIdStreamRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostApiSandboxTokenResponse> {
-    return unwrapAsync(sandboxPostApiSandboxToken(
+  ): Promise<operations.GetApiSandboxByIdStreamResponse> {
+    return unwrapAsync(sandboxGetApiSandboxByIdStream(
       this,
       request,
       options,
@@ -152,28 +188,33 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * Ingest OTLP spans from inside a sandbox
+   * Run a command in a sandbox
    *
    * @remarks
-   * OTLP/HTTP JSON. Requires a task token; spans are attributed to the sandbox the token is bound to, never to the sandbox named in the payload.
+   * Returns the command's real exit code. A task token is rejected — in-sandbox code reports on itself, it does not drive the box. With `?stream=1` the same result comes back as the event stream of `GET /:id/stream`, scoped to this one invocation and terminated by a `status` event carrying the exit code.
    */
-  async postApiSandboxTelemetryV1Traces(
+  async postApiSandboxByIdExec(
+    request: operations.PostApiSandboxByIdExecRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostApiSandboxTelemetryV1TracesResponse> {
-    return unwrapAsync(sandboxPostApiSandboxTelemetryV1Traces(
+  ): Promise<operations.PostApiSandboxByIdExecResponse> {
+    return unwrapAsync(sandboxPostApiSandboxByIdExec(
       this,
+      request,
       options,
     ));
   }
 
   /**
-   * Get sandbox status
+   * Start a Helix session in a sandbox
+   *
+   * @remarks
+   * Returns as soon as the session is running — the run continues in the background and its output arrives on `GET /:id/stream`, not in this response. With `mode: "rpc"` the session is duplex: it emits `rpc` events on the stream and accepts `POST /:id/input`. `mode` defaults to `oneshot`, which is the pre-existing behaviour and has no stdin. A task token is rejected: starting an agent is driving the box.
    */
-  async getApiSandboxById(
-    request: operations.GetApiSandboxByIdRequest,
+  async postApiSandboxByIdSession(
+    request: operations.PostApiSandboxByIdSessionRequest,
     options?: RequestOptions,
-  ): Promise<operations.GetApiSandboxByIdResponse> {
-    return unwrapAsync(sandboxGetApiSandboxById(
+  ): Promise<operations.PostApiSandboxByIdSessionResponse> {
+    return unwrapAsync(sandboxPostApiSandboxByIdSession(
       this,
       request,
       options,
@@ -181,16 +222,16 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * Tear down a sandbox
+   * List the Helix sessions a sandbox is hosting
    *
    * @remarks
-   * Idempotent. The record is forgotten even if the provider teardown fails.
+   * Ids only — attach to one for detail. `sandbox:read`, unlike the other two session routes: asking which sessions exist is not driving the box.
    */
-  async deleteApiSandboxById(
-    request: operations.DeleteApiSandboxByIdRequest,
+  async getApiSandboxByIdSessions(
+    request: operations.GetApiSandboxByIdSessionsRequest,
     options?: RequestOptions,
-  ): Promise<operations.DeleteApiSandboxByIdResponse> {
-    return unwrapAsync(sandboxDeleteApiSandboxById(
+  ): Promise<operations.GetApiSandboxByIdSessionsResponse> {
+    return unwrapAsync(sandboxGetApiSandboxByIdSessions(
       this,
       request,
       options,
@@ -198,16 +239,16 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * Run a command in a sandbox
+   * Write one line to a Helix session's stdin
    *
    * @remarks
-   * Returns the command's real exit code. A task token is rejected — in-sandbox code reports on itself, it does not drive the box. With `?stream=1` the same result comes back as the event stream of `GET /:id/stream`, scoped to this one invocation and terminated by a `status` event carrying the exit code.
+   * The write half of the duplex session channel — the read half is the `rpc` events on `GET /:id/stream`. Use it to answer a HITL request or send a follow-up turn to a session started in RPC mode. `line` must be exactly one JSON object with no newline in it: the channel is newline-delimited, so one call carries one command. A 200 means the line reached the session, nothing more — whether the agent accepted it comes back on the stream, asynchronously. 400 if the line is not a single JSON object, 409 if the session is not running.
    */
-  async postApiSandboxByIdExec(
-    request: operations.PostApiSandboxByIdExecRequest,
+  async postApiSandboxByIdInput(
+    request: operations.PostApiSandboxByIdInputRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostApiSandboxByIdExecResponse> {
-    return unwrapAsync(sandboxPostApiSandboxByIdExec(
+  ): Promise<operations.PostApiSandboxByIdInputResponse> {
+    return unwrapAsync(sandboxPostApiSandboxByIdInput(
       this,
       request,
       options,
@@ -215,22 +256,37 @@ export class Sandbox extends ClientSDK {
   }
 
   /**
-   * Watch a sandbox's output live
+   * Stop a running Helix session without destroying its sandbox
    *
    * @remarks
-   * Server-sent events: `stdout`, `stderr`, `status`, `ping` (every 15s), `error`. `seq` is monotonic per sandbox and starts at 1; pass the last one seen as `?since=` to resume. If the buffer has already rolled past `since`, an `error` event names the lost range rather than skipping it silently. Disconnecting tears down the upstream.
+   * The remote equivalent of Ctrl-C on a local agent: the SESSION stops and the box — its filesystem, its other sessions, its event log — stays up. `DELETE /:id` remains the only thing that destroys a sandbox. Distinct from sending an `abort` command via `POST /:id/input`, which politely asks a cooperating agent to end its turn and only works while it is still reading stdin; a signal reaches a process that has stopped listening. 200 means the signal was delivered to a LIVE process, never merely that the request was well-formed. 409 if the session has already ended, 404 if the box has never heard of it.
    */
-  async getApiSandboxByIdStream(
-    request: operations.GetApiSandboxByIdStreamRequest,
+  async postApiSandboxByIdSignal(
+    request: operations.PostApiSandboxByIdSignalRequest,
     options?: RequestOptions,
-  ): Promise<void> {
-    return unwrapAsync(sandboxGetApiSandboxByIdStream(
+  ): Promise<operations.PostApiSandboxByIdSignalResponse> {
+    return unwrapAsync(sandboxPostApiSandboxByIdSignal(
       this,
       request,
       options,
     ));
   }
 
+  /**
+   * Ingest OTLP spans from inside a sandbox
+   *
+   * @remarks
+   * OTLP/HTTP JSON. Requires a task token; spans are attributed to the sandbox the token is bound to, never to the sandbox named in the payload.
+   */
+  async postApiSandboxTelemetryV1Traces(
+    options?: RequestOptions,
+  ): Promise<operations.PostApiSandboxTelemetryV1TracesResponse> {
+    return unwrapAsync(sandboxPostApiSandboxTelemetryV1Traces(
+      this,
+      options,
+    ));
+  }
+
   /**
    * Read a sandbox's captured spans
    */
@@ -244,4 +300,21 @@ export class Sandbox extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Exchange a platform API key for a sandbox operator token
+   *
+   * @remarks
+   * Trades a platform API key (`x-api-key: mg_live_…`) for a short-lived operator token scoped to one workspace. The caller must be able to create resources in that workspace.
+   */
+  async postApiSandboxToken(
+    request: operations.PostApiSandboxTokenRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostApiSandboxTokenResponse> {
+    return unwrapAsync(sandboxPostApiSandboxToken(
+      this,
+      request,
+      options,
+    ));
+  }
 }

package/src/sdk/sdk.ts

@@ -9,6 +9,7 @@ import { OrganizationMembers } from "./organization-members.js";
 import { Organizations } from "./organizations.js";
 import { ProviderConfigs } from "./provider-configs.js";
 import { Sandbox } from "./sandbox.js";
+import { Traces } from "./traces.js";
 import { UserProfile } from "./user-profile.js";
 import { WorkspaceMembers } from "./workspace-members.js";
 import { Workspaces } from "./workspaces.js";
@@ -19,6 +20,11 @@ export class Mutagent extends ClientSDK {
     return (this._userProfile ??= new UserProfile(this._options));
   }
 
+  private _sandbox?: Sandbox;
+  get sandbox(): Sandbox {
+    return (this._sandbox ??= new Sandbox(this._options));
+  }
+
   private _agents?: Agents;
   get agents(): Agents {
     return (this._agents ??= new Agents(this._options));
@@ -56,8 +62,8 @@ export class Mutagent extends ClientSDK {
     return (this._invitations ??= new Invitations(this._options));
   }
 
-  private _sandbox?: Sandbox;
-  get sandbox(): Sandbox {
-    return (this._sandbox ??= new Sandbox(this._options));
+  private _traces?: Traces;
+  get traces(): Traces {
+    return (this._traces ??= new Traces(this._options));
   }
 }

package/src/sdk/traces.ts

@@ -0,0 +1,93 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { tracesGetTrace } from "../funcs/traces-get-trace.js";
+import { tracesIngestTraceBatch } from "../funcs/traces-ingest-trace-batch.js";
+import { tracesListLogs } from "../funcs/traces-list-logs.js";
+import { tracesListTraceSpans } from "../funcs/traces-list-trace-spans.js";
+import { tracesListTraces } from "../funcs/traces-list-traces.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Traces extends ClientSDK {
+  /**
+   * Ingest a batch of traces (mutagent-cli hook format)
+   *
+   * @remarks
+   * The shape mutagent-cli hooks send. Translated to OTLP internally and stored through the same path as an SDK export.
+   */
+  async ingestTraceBatch(
+    request: operations.IngestTraceBatchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.IngestTraceBatchResponse> {
+    return unwrapAsync(tracesIngestTraceBatch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List recent traces
+   *
+   * @remarks
+   * Most recent first, keyset-paginated. Pass the previous page's nextCursor as ?cursor to continue; a null nextCursor means the last page.
+   */
+  async listTraces(
+    request?: operations.ListTracesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListTracesResponse> {
+    return unwrapAsync(tracesListTraces(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List recent log records
+   */
+  async listLogs(
+    request?: operations.ListLogsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.ListLogsResponse> {
+    return unwrapAsync(tracesListLogs(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get one trace envelope
+   */
+  async getTrace(
+    request: operations.GetTraceRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetTraceResponse> {
+    return unwrapAsync(tracesGetTrace(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get every span of one trace
+   *
+   * @remarks
+   * Not paginated: a trace is bounded by construction, and a partial span tree is not a useful thing to hand back.
+   */
+  async listTraceSpans(
+    request: operations.ListTraceSpansRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ListTraceSpansResponse> {
+    return unwrapAsync(tracesListTraceSpans(
+      this,
+      request,
+      options,
+    ));
+  }
+}