@instruments/materialgraph 0.25.0 → 0.27.0

package/response-schemas.js

@@ -0,0 +1,113 @@
+/**
+ * Runtime response contracts: the JSON Schema of each operation's success body.
+ *
+ * The schemas are the producer's own. They are projected from the served
+ * OpenAPI document, whose response bodies are generated from the Zod contracts
+ * the routes validate against, so a consumer never has to re-describe a large,
+ * partly open payload and watch it drift. Hand one to anything that takes a
+ * JSON Schema, such as a Mastra tool's `outputSchema`:
+ *
+ * ```ts
+ * import { responseSchema } from "@instruments/materialgraph/response-schemas";
+ *
+ * createTool({ outputSchema: responseSchema("search_materials_post"), … });
+ * ```
+ *
+ * Keyed by OpenAPI `operationId`, the same id `SDK_OPERATIONS` pairs with each
+ * client method. Schemas are JSON Schema 2020-12 and describe the parsed body
+ * the client method returns. `list_public_run_events` is absent: it streams
+ * Server-Sent Events rather than returning one JSON body.
+ *
+ * Objects accept properties the schema does not declare, so a field the API
+ * adds later never makes a pinned consumer reject a live response; enums and
+ * constants stay closed. That is why these are more lenient than the WebMCP
+ * `outputSchema`s, which describe what the API sends rather than what a
+ * consumer should tolerate.
+ *
+ * This is its own entry point because the catalogue is large; importing the
+ * client does not load it, and it is parsed on the first `responseSchema()`
+ * call rather than on import.
+ */
+import { MaterialGraphError } from "./errors.js";
+import { RESPONSE_SCHEMA_CATALOGUE_JSON } from "./response-schemas.generated.js";
+export { RESPONSE_SCHEMA_API_VERSION, RESPONSE_SCHEMA_OPERATION_IDS, } from "./response-schemas.generated.js";
+const JSON_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+const DEFINITION_PREFIX = "#/$defs/";
+const isJsonSchemaMap = (value) => typeof value === "object" &&
+    value !== null &&
+    Object.values(value).every((schema) => typeof schema === "object" && schema !== null && !Array.isArray(schema));
+const isCatalogue = (value) => typeof value === "object" &&
+    value !== null &&
+    "definitions" in value &&
+    isJsonSchemaMap(value.definitions) &&
+    "operations" in value &&
+    isJsonSchemaMap(value.operations);
+let parsedCatalogue;
+const loadCatalogue = () => {
+    if (parsedCatalogue === undefined) {
+        const parsed = JSON.parse(RESPONSE_SCHEMA_CATALOGUE_JSON);
+        if (!isCatalogue(parsed)) {
+            throw MaterialGraphError.unexpected("The response schema catalogue is malformed");
+        }
+        parsedCatalogue = parsed;
+    }
+    return parsedCatalogue;
+};
+/** Add every definition `value` reaches, transitively, to `into`. */
+const collectReferences = (catalogue, value, into) => {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            collectReferences(catalogue, item, into);
+        }
+        return;
+    }
+    if (typeof value !== "object" || value === null) {
+        return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        if (key === "$ref" &&
+            typeof child === "string" &&
+            child.startsWith(DEFINITION_PREFIX)) {
+            const name = child
+                .slice(DEFINITION_PREFIX.length)
+                .replaceAll("~1", "/")
+                .replaceAll("~0", "~");
+            if (!into.has(name)) {
+                into.add(name);
+                collectReferences(catalogue, catalogue.definitions[name], into);
+            }
+        }
+        else {
+            collectReferences(catalogue, child, into);
+        }
+    }
+};
+/**
+ * The success-response schema for one operation, self-contained and carrying
+ * only the definitions it reaches. Each call returns a fresh copy, so a caller
+ * that annotates or mutates it cannot change what the next caller gets.
+ */
+export const responseSchema = (operationId) => {
+    const catalogue = loadCatalogue();
+    const root = Object.hasOwn(catalogue.operations, operationId)
+        ? catalogue.operations[operationId]
+        : undefined;
+    if (root === undefined) {
+        throw MaterialGraphError.unexpected(`No response schema for operation: ${operationId}`);
+    }
+    const names = new Set();
+    collectReferences(catalogue, root, names);
+    const definitions = {};
+    for (const name of [...names].toSorted()) {
+        const definition = catalogue.definitions[name];
+        if (definition !== undefined) {
+            definitions[name] = definition;
+        }
+    }
+    const schema = {
+        $schema: JSON_SCHEMA_DIALECT,
+        ...root,
+        ...(names.size > 0 ? { $defs: definitions } : {}),
+    };
+    return structuredClone(schema);
+};

package/run-types.d.ts

@@ -2,9 +2,8 @@
  * Hand-mirrored wire types for the MaterialGraph public Run + source-material
  * surface (spec 0.7.0). Like {@link ./types.ts}, these interfaces carry NO
  * runtime dependency on any `@materialgraph/*` package — they mirror the shapes
- * in `apps/web/public/openapi.yaml` (`list_public_capabilities`,
- * `create_public_run`, `get_public_run`, `list_public_run_events`,
- * `resume_public_run`, `cancel_public_run`, `upload_source_material`).
+ * in `apps/web/public/openapi.yaml` (`create_public_run`, `get_public_run`,
+ * `list_public_run_events`, `upload_source_material`).
  *
  * TOLERANT-PARSING CONTRACT: response enums are widened with {@link OpenEnum}
  * so a new server value still type-checks, and objects are read structurally —
@@ -32,27 +31,27 @@ export type FileInput = Blob | {
  * classifies each file and assigns its receipt {@link SourceMaterialReceiptFile.role};
  * the caller no longer pre-sorts a brief from its references.
  */
-export interface UploadSourceMaterialFilesInput {
+export type UploadSourceMaterialFilesInput = {
     files: FileInput[];
-}
+};
 /**
  * The legacy pre-classified shape — a single PDF `brief` plus optional image
  * `references` (multipart fields `brief` + `references`). Still accepted by the
  * server, folded into the pile. Prefer {@link UploadSourceMaterialFilesInput}.
  */
-export interface UploadSourceMaterialLegacyInput {
+export type UploadSourceMaterialLegacyInput = {
     /** The single PDF brief for the batch (multipart field `brief`). */
     brief: FileInput;
     /** Up to 12 reference images (multipart field `references`, repeatable). */
     references?: FileInput[];
-}
+};
 /**
  * Input for {@link MaterialGraphClient.uploadSourceMaterial} — either the
  * pile-of-files shape or the legacy brief+references shape.
  */
 export type UploadSourceMaterialInput = UploadSourceMaterialFilesInput | UploadSourceMaterialLegacyInput;
 /** One stored file in an upload receipt. */
-export interface SourceMaterialReceiptFile {
+export type SourceMaterialReceiptFile = {
     /** The stored file id (`smf_…`). Opaque — the prefix is a reading aid, not a contract. */
     sourceId: SourceFileId;
     /**
@@ -68,13 +67,13 @@ export interface SourceMaterialReceiptFile {
     bytes: number;
     /** PDF page count; null for images. */
     pages: number | null;
-}
+};
 /** The `201` receipt from `POST /api/v1/source-material`. */
-export interface SourceMaterialBatchReceipt {
+export type SourceMaterialBatchReceipt = {
     /** The stored batch id (`smb_…`). Opaque — hand it straight to a compose Run. */
     batchId: BatchId;
     sources: SourceMaterialReceiptFile[];
-}
+};
 /**
  * One analysis computed over an uploaded image's bytes.
  *
@@ -84,7 +83,7 @@ export interface SourceMaterialBatchReceipt {
  * sharing is by design and discloses nothing — you only ever see analyses of
  * images you hold yourself.
  */
-export interface SourceImageAnalysis {
+export type SourceImageAnalysis = {
     /** The kind of read. {@link OpenEnum} keeps a newer server value type-checking. */
     kind: OpenEnum<"scene_match">;
     /** The model version that produced {@link SourceImageAnalysis.result}. */
@@ -104,9 +103,9 @@ export interface SourceImageAnalysis {
     result: Record<string, JsonValue>;
     /** ISO-8601 timestamp of the most recent analysis. */
     analysedAt: string;
-}
+};
 /** Who a comment is from, as you SUBMIT it. Not the API principal posting it. */
-export interface SourceMaterialCommentAuthorInput {
+export type SourceMaterialCommentAuthorInput = {
     /** Trimmed, 1–160 characters. Longer or blank is refused by the server. */
     name: string;
     /**
@@ -114,7 +113,7 @@ export interface SourceMaterialCommentAuthorInput {
      * Trimmed, 1–160 characters when present. Nullable, not optional.
      */
     organisation: string | null;
-}
+};
 /**
  * Who a comment is from, as you READ IT BACK.
  *
@@ -122,28 +121,28 @@ export interface SourceMaterialCommentAuthorInput {
  * "recorded as from X", never as a statement X signed — the identity that IS
  * verified is {@link SourceMaterialCommentReply.recordedBy}.
  */
-export interface SourceMaterialCommentAuthor extends SourceMaterialCommentAuthorInput {
+export type SourceMaterialCommentAuthor = {
     /**
      * How the name got here. `reported` means a caller typed it. {@link OpenEnum}
      * keeps a newer server value type-checking; treat anything unfamiliar as
      * unverified.
      */
     attribution: OpenEnum<"reported">;
-}
+} & SourceMaterialCommentAuthorInput;
 /** The authenticated principal that recorded a comment. */
-export interface SourceMaterialCommentRecorder {
+export type SourceMaterialCommentRecorder = {
     /**
      * The principal that wrote the row. Comments can only be posted against a
      * batch the poster owns, so on every comment you can read this is your own.
      */
     principalId: string;
-}
+};
 /**
  * One reply on a source-material file. A reply carries no replies of its own:
  * threads are one level deep because the database makes a reply-to-reply
  * unstorable, and this type says so rather than implying a tree.
  */
-export interface SourceMaterialCommentReply {
+export type SourceMaterialCommentReply = {
     /** The stored comment id (`smc_…`). Opaque. */
     commentId: string;
     author: SourceMaterialCommentAuthor;
@@ -152,14 +151,14 @@ export interface SourceMaterialCommentReply {
     body: string;
     /** ISO-8601 timestamp of the posting. */
     createdAt: string;
-}
+};
 /** One root remark with the replies that answer it. */
-export interface SourceMaterialComment extends SourceMaterialCommentReply {
+export type SourceMaterialComment = {
     /** ALWAYS an array. `[]` means nobody answered — never a missing field. */
     replies: SourceMaterialCommentReply[];
-}
+} & SourceMaterialCommentReply;
 /** The `200` body of `GET …/sources/{sourceId}/comments`. */
-export interface SourceMaterialCommentThread {
+export type SourceMaterialCommentThread = {
     /** The file the thread hangs off (`smf_…`). Opaque. */
     sourceId: string;
     /**
@@ -172,9 +171,9 @@ export interface SourceMaterialCommentThread {
      * so `comments` is the oldest of them rather than all of them.
      */
     truncated: boolean;
-}
+};
 /** The body of `POST …/sources/{sourceId}/comments`. */
-export interface PostSourceMaterialCommentInput {
+export type PostSourceMaterialCommentInput = {
     author: SourceMaterialCommentAuthorInput;
     /** Trimmed, 1–4000 characters. */
     body: string;
@@ -189,17 +188,17 @@ export interface PostSourceMaterialCommentInput {
      * rather than a permanent duplicate. Scoped to the file.
      */
     idempotencyKey?: string | null;
-}
+};
 /** A comment the server just stored, as a root. */
-export interface StoredSourceMaterialRootComment extends SourceMaterialComment {
+export type StoredSourceMaterialRootComment = {
     kind: "root";
-}
+} & SourceMaterialComment;
 /** A comment the server just stored, as a reply to a root. */
-export interface StoredSourceMaterialReplyComment extends SourceMaterialCommentReply {
+export type StoredSourceMaterialReplyComment = {
     kind: "reply";
     /** The root this answers. Present because a reply always has one. */
     parentCommentId: string;
-}
+} & SourceMaterialCommentReply;
 /**
  * What a POST returns, discriminated on `kind`. Switch on it: a `root` carries
  * an empty `replies`, a `reply` carries `parentCommentId` and no `replies` at
@@ -207,13 +206,13 @@ export interface StoredSourceMaterialReplyComment extends SourceMaterialCommentR
  */
 export type StoredSourceMaterialComment = StoredSourceMaterialRootComment | StoredSourceMaterialReplyComment;
 /** The `201` body of `POST …/sources/{sourceId}/comments`. */
-export interface PostSourceMaterialCommentResult {
+export type PostSourceMaterialCommentResult = {
     /** The file the comment hangs off (`smf_…`). Opaque. */
     sourceId: string;
     comment: StoredSourceMaterialComment;
-}
+};
 /** One file as `GET /api/v1/source-material/{batchId}` returns it. */
-export interface SourceMaterialBatchFile extends SourceMaterialReceiptFile {
+export type SourceMaterialBatchFile = {
     /** Fetchable URL for the stored bytes. */
     url: string;
     /**
@@ -234,79 +233,43 @@ export interface SourceMaterialBatchFile extends SourceMaterialReceiptFile {
      * you have, including one nobody has commented on.
      */
     commentsTruncated: boolean;
-}
+} & SourceMaterialReceiptFile;
 /**
  * The `200` body of `GET /api/v1/source-material/{batchId}` — the batch, every
  * file it holds, and the analyses computed over each file's bytes.
  */
-export interface SourceMaterialBatchDetail {
+export type SourceMaterialBatchDetail = {
     /** The stored batch id (`smb_…`). Opaque. */
     batchId: BatchId;
     /** ISO-8601 timestamp of the upload. */
     createdAt: string;
     sources: SourceMaterialBatchFile[];
-}
+};
+/**
+ * Still carried on {@link PublicRun.capabilityKind}, so a Run created before
+ * MG-2252 reads back as `"agent"`. The rest of the public capability manifest
+ * shape retired with `GET /api/v1/capabilities`.
+ */
 export type CapabilityKind = OpenEnum<"agent" | "tool" | "workflow">;
-export type CapabilityExposure = OpenEnum<"public" | "partner" | "internal">;
-export type CapabilityScope = OpenEnum<"mg:read" | "mg:write" | "mg:ingest" | "mg:admin">;
-export type CapabilitySideEffectClass = OpenEnum<"read_only" | "browser_local" | "external_read" | "writes_proposed" | "writes_persisted" | "planned_only">;
-export interface CapabilityRetryPolicy {
-    maxAttempts: number;
-    backoff: OpenEnum<"none" | "fixed" | "exponential">;
-}
-export interface CapabilityInvokeLink {
-    href: string;
-    method: OpenEnum<"GET" | "POST">;
-}
-/** One human-input checkpoint exposed by a workflow capability. */
-export interface PublicCapabilitySuspension {
-    stepId: string;
-    suspend: Record<string, unknown>;
-    resume: Record<string, unknown>;
-}
-/** One invocable capability from the governed public manifest. */
-export interface PublicCapabilityMetadata {
-    publicId: string;
-    runtimeId: string;
-    kind: CapabilityKind;
-    exposure: CapabilityExposure;
-    name: string;
-    description: string;
-    schemas: {
-        input: Record<string, unknown>;
-        output: Record<string, unknown>;
-        suspensions?: PublicCapabilitySuspension[];
-    };
-    sideEffectClass: CapabilitySideEffectClass;
-    scopes: CapabilityScope[];
-    timeoutMs: number;
-    retryPolicy: CapabilityRetryPolicy;
-    tags: string[];
-    links: {
-        invoke: CapabilityInvokeLink;
-    };
-}
-/** The `GET /api/v1/capabilities` response envelope. */
-export interface CapabilityManifestResponse {
-    capabilities: PublicCapabilityMetadata[];
-}
+/** What `POST /api/v1/runs` admits: never an agent since MG-2252. */
+export type CreatableCapabilityKind = "tool" | "workflow";
 export type PublicRunStatus = OpenEnum<"queued" | "claimed" | "running" | "suspended" | "succeeded" | "failed" | "canceled">;
-export interface PublicRunFailure {
+export type PublicRunFailure = {
     code: string;
     message: string;
     retryable: boolean;
     detail?: Record<string, unknown>;
-}
-export interface PublicRunArtifactRef {
+};
+export type PublicRunArtifactRef = {
     kind: string;
     ref: string;
-}
+};
 /**
  * The caller-owned, redacted Run ledger record. Prompts, raw model messages,
  * reasoning, credentials, provider payloads, and source-document contents are
  * never returned — inputs and outputs are the `redacted*Json` projections.
  */
-export interface PublicRun {
+export type PublicRun = {
     /** Opaque — round-trip verbatim into every other Run call. */
     id: RunId;
     capabilityKind: CapabilityKind;
@@ -322,9 +285,7 @@ export interface PublicRun {
     /** The current typed question payload while this Run is suspended. */
     suspensionPayload: Record<string, unknown> | null;
     /**
-     * The step awaiting input while `status` is `suspended`. Pass it as
-     * {@link ResumeRunOptions.stepId} so a stale client cannot resume a step the
-     * Run has already moved past.
+     * The step awaiting input while `status` is `suspended`.
      *
      * Read `suspensionPayload` for the current typed question. The same payload is
      * also retained on the `suspended` ledger event; composition-specific events
@@ -338,10 +299,10 @@ export interface PublicRun {
     completedAt: string | null;
     createdAt: string;
     updatedAt: string;
-}
+};
 /** Body for `POST /api/v1/runs` ({@link MaterialGraphClient.createRun}). */
-export interface CreatePublicRunRequest {
-    capabilityKind: CapabilityKind;
+export type CreatePublicRunRequest = {
+    capabilityKind: CreatableCapabilityKind;
     capabilityId: string;
     /** The capability input, validated server-side against its live input schema. */
     inputJson: unknown;
@@ -353,83 +314,41 @@ export interface CreatePublicRunRequest {
     idempotencyKey?: string;
     /** Free-form caller correlation reference, echoed back on the Run. */
     clientReference?: string;
-}
+};
 /** The `POST /api/v1/runs` response (`200` replay or `202` accepted). */
-export interface CreatePublicRunResponse {
+export type CreatePublicRunResponse = {
     accepted: boolean;
     replayed: boolean;
     workflowRunId: string;
     run: PublicRun;
-}
-/** The `GET /api/v1/runs/{runId}` and resume/cancel response envelope. */
-export interface PublicRunResponse {
+};
+/** The `GET /api/v1/runs/{runId}` response envelope. */
+export type PublicRunResponse = {
     run: PublicRun;
-}
-/** Query for `GET /api/v1/runs` ({@link MaterialGraphClient.listRuns}). */
-export interface ListRunsOptions {
-    /**
-     * Return only Runs in this status. `"suspended"` is the recovery question:
-     * which of my Runs is still waiting on an answer?
-     */
-    status?: PublicRunStatus;
-    /** Page size, 1–100. Defaults to 20 server-side. */
-    limit?: number;
-    /**
-     * The previous page's {@link PublicRunListResponse.nextCursor}, round-tripped
-     * VERBATIM. It is opaque — never parse or construct one.
-     */
-    cursor?: string;
-    signal?: AbortSignal;
-}
-/** The `GET /api/v1/runs` response envelope — one page, newest first. */
-export interface PublicRunListResponse {
-    runs: PublicRun[];
-    /**
-     * Pass as {@link ListRunsOptions.cursor} for the next page. ABSENT — not
-     * empty-string, not null — once the last page has been served.
-     */
-    nextCursor?: string;
-}
-/** Body for `POST /api/v1/runs/{runId}/resume`. */
-export interface ResumePublicRunRequest {
-    /** The resume payload, validated against the suspended step's resume schema. */
-    resumeData: unknown;
-}
+};
 /**
  * One redacted Run event, decoded from an SSE `data:` frame. The stream yields
  * these in ascending {@link RunEvent.sequence} order. `payloadJson` is read
  * structurally; use {@link parseRunEvent} to narrow the composition family.
  */
-export interface RunEvent {
+export type RunEvent = {
     sequence: number;
     type: string;
     payloadJson: unknown;
-}
+};
 /** Run event types that close the stream — a terminal event ends a drain. */
 export declare const TERMINAL_RUN_EVENT_TYPES: ReadonlySet<string>;
 /** Options for {@link MaterialGraphClient.streamRunEvents}. */
-export interface StreamRunEventsOptions {
+export type StreamRunEventsOptions = {
     /** Resume the stream after this sequence (exclusive). Omitted starts at 0. */
     after?: number;
     /** Abort the stream; iteration stops cleanly. */
     signal?: AbortSignal;
-}
+};
 /** Options for {@link MaterialGraphClient.drainRunEvents}. */
-export interface DrainRunEventsOptions {
+export type DrainRunEventsOptions = {
     /** Resume after this sequence (exclusive). */
     after?: number;
     /** Stop collecting after this many milliseconds even without a terminal event. */
     deadlineMs: number;
-}
-/** Options for {@link MaterialGraphClient.resumeRun}. */
-export interface ResumeRunOptions {
-    /**
-     * The step the caller believes is suspended. When it mismatches the run
-     * doc's live `suspensionStepId` the API answers RFC-7807 409 (MG-608) —
-     * which is what stops a stale client resuming a step the run has already
-     * moved past. Omitted, the resume is unguarded, exactly as before.
-     */
-    stepId?: string;
-    /** Abort the request. */
-    signal?: AbortSignal;
-}
+};

package/runs.d.ts

@@ -1,13 +1,12 @@
-import { HttpTransport } from "./http-transport.js";
-import { type CapabilityManifestResponse, type CreatePublicRunRequest, type CreatePublicRunResponse, type DrainRunEventsOptions, type ListRunsOptions, type PostSourceMaterialCommentInput, type PostSourceMaterialCommentResult, type PublicRunListResponse, type PublicRunResponse, type ResumeRunOptions, type RunEvent, type SourceMaterialBatchDetail, type SourceMaterialBatchReceipt, type SourceMaterialCommentThread, type StreamRunEventsOptions, type UploadSourceMaterialInput } from "./run-types.js";
-import type { FinishScheduleResponse, GetRunScheduleOptions } from "./schedule-types.js";
+import type { HttpTransport } from "./http-transport.js";
+import type { CreatePublicRunRequest, CreatePublicRunResponse, DrainRunEventsOptions, PostSourceMaterialCommentInput, PostSourceMaterialCommentResult, PublicRunResponse, RunEvent, SourceMaterialBatchDetail, SourceMaterialBatchReceipt, SourceMaterialCommentThread, StreamRunEventsOptions, UploadSourceMaterialInput } from "./run-types.js";
 /**
  * Upload one atomic source-material batch (`POST /api/v1/source-material`).
  * Accepts the pile-of-files shape (`{ files }` → repeatable `files` field) or
  * the legacy `{ brief, references }` shape (→ `brief` + repeatable `references`
  * fields). Both wire to multipart the server accepts.
  */
-export declare function uploadSourceMaterial(transport: HttpTransport, input: UploadSourceMaterialInput, signal?: AbortSignal): Promise<SourceMaterialBatchReceipt>;
+export declare const uploadSourceMaterial: (transport: HttpTransport, input: UploadSourceMaterialInput, signal?: AbortSignal) => Promise<SourceMaterialBatchReceipt>;
 /**
  * Read back one uploaded batch (`GET /api/v1/source-material/{batchId}`): every
  * file with a fetchable `url`, and every analysis computed over its bytes
@@ -20,7 +19,7 @@ export declare function uploadSourceMaterial(transport: HttpTransport, input: Up
  * the server's Zod contract so a malformed response fails here with a path into
  * the payload rather than as an undefined three frames away in caller code.
  */
-export declare function getSourceMaterialBatch(transport: HttpTransport, batchId: string, signal?: AbortSignal): Promise<SourceMaterialBatchDetail>;
+export declare const getSourceMaterialBatch: (transport: HttpTransport, batchId: string, signal?: AbortSignal) => Promise<SourceMaterialBatchDetail>;
 /**
  * Read one file's comment thread
  * (`GET /api/v1/source-material/{batchId}/sources/{sourceId}/comments`).
@@ -38,7 +37,7 @@ export declare function getSourceMaterialBatch(transport: HttpTransport, batchId
  * A file that is not in that batch, or a batch you do not own, raises the same
  * 404 as a file that never existed.
  */
-export declare function listSourceMaterialComments(transport: HttpTransport, batchId: string, sourceId: string, signal?: AbortSignal): Promise<SourceMaterialCommentThread>;
+export declare const listSourceMaterialComments: (transport: HttpTransport, batchId: string, sourceId: string, signal?: AbortSignal) => Promise<SourceMaterialCommentThread>;
 /**
  * Add one remark to a file's thread
  * (`POST /api/v1/source-material/{batchId}/sources/{sourceId}/comments`).
@@ -54,59 +53,11 @@ export declare function listSourceMaterialComments(transport: HttpTransport, bat
  * The result is discriminated on `kind`: switch on it rather than reaching for
  * `replies`, which a `reply` does not have.
  */
-export declare function postSourceMaterialComment(transport: HttpTransport, batchId: string, sourceId: string, input: PostSourceMaterialCommentInput, signal?: AbortSignal): Promise<PostSourceMaterialCommentResult>;
-/** List invocable agents, workflows, and tools (`GET /api/v1/capabilities`). */
-export declare function capabilities(transport: HttpTransport, signal?: AbortSignal): Promise<CapabilityManifestResponse>;
+export declare const postSourceMaterialComment: (transport: HttpTransport, batchId: string, sourceId: string, input: PostSourceMaterialCommentInput, signal?: AbortSignal) => Promise<PostSourceMaterialCommentResult>;
 /** Start an asynchronous capability Run (`POST /api/v1/runs`). */
-export declare function createRun(transport: HttpTransport, body: CreatePublicRunRequest, signal?: AbortSignal): Promise<CreatePublicRunResponse>;
-/**
- * List your own Runs, newest first (`GET /api/v1/runs`).
- *
- * The recovery path for a client that still holds its API key but has lost a Run
- * id — a reinstalled app, or a crash before the id from {@link createRun} was
- * persisted. `{ status: "suspended" }` finds the Run still waiting on an answer.
- *
- * Only the calling principal's own Runs are ever returned; there is no
- * cross-principal listing.
- *
- * Page by following `nextCursor` until it is ABSENT — a full page is not the
- * signal to stop, and an absent cursor is the only one.
- */
-export declare function listRuns(transport: HttpTransport, options?: ListRunsOptions): Promise<PublicRunListResponse>;
+export declare const createRun: (transport: HttpTransport, body: CreatePublicRunRequest, signal?: AbortSignal) => Promise<CreatePublicRunResponse>;
 /** Get a Run's current state (`GET /api/v1/runs/{runId}`). */
-export declare function getRun(transport: HttpTransport, runId: string, signal?: AbortSignal): Promise<PublicRunResponse>;
-/**
- * Export a completed compose Run's scheme as a finish schedule — one row per
- * slot, every attribute value carrying its source and verification state
- * (`GET /api/v1/runs/{runId}/schedule`).
- *
- * The `.xlsx` form of the same export is deliberately NOT an SDK method: this
- * transport parses every response as text/JSON and has no binary read path, so
- * a bytes-returning method would mean a second transport surface for one file.
- * Fetch `GET /api/v1/runs/{runId}/schedule.xlsx` directly with the same bearer
- * key when you want the workbook.
- */
-export declare function getRunSchedule(transport: HttpTransport, runId: string, options?: GetRunScheduleOptions): Promise<FinishScheduleResponse>;
-/**
- * Resume a suspended Run (`POST /api/v1/runs/{runId}/resume`).
- *
- * The third argument takes either an `AbortSignal` (legacy) or
- * {@link ResumeRunOptions}.
- *
- * `stepId` is forwarded whenever it is PRESENT — `!== undefined`, not truthy.
- * An empty string is a present-but-malformed value and must reach the server
- * so its schema rejects it; treating it as absent would silently downgrade a
- * guarded resume into an unguarded one, which is the exact failure this guard
- * exists to prevent.
- *
- * Omitting it sends a body byte-identical to what this sent before. Note the
- * wire cannot distinguish `{ stepId: undefined }` from no key at all —
- * `JSON.stringify` drops both — so the distinction here is construction
- * intent, kept so the serialised body is provably unchanged for old callers.
- */
-export declare function resumeRun(transport: HttpTransport, runId: string, resumeData: unknown, signalOrOptions?: AbortSignal | ResumeRunOptions): Promise<PublicRunResponse>;
-/** Request durable Run cancellation (`POST /api/v1/runs/{runId}/cancel`). */
-export declare function cancelRun(transport: HttpTransport, runId: string, signal?: AbortSignal): Promise<PublicRunResponse>;
+export declare const getRun: (transport: HttpTransport, runId: string, signal?: AbortSignal) => Promise<PublicRunResponse>;
 /**
  * Stream ordered Run events as an async iterator (`GET
  * /api/v1/runs/{runId}/events`, SSE). Iterates until the stream ends or
@@ -129,4 +80,4 @@ export declare function streamRunEvents(transport: HttpTransport, runId: string,
  * failure (a real 4xx/5xx or transport error) still propagates, keeping the
  * fail-fast surface for genuine upstream problems.
  */
-export declare function drainRunEvents(transport: HttpTransport, runId: string, options: DrainRunEventsOptions): Promise<RunEvent[]>;
+export declare const drainRunEvents: (transport: HttpTransport, runId: string, options: DrainRunEventsOptions) => Promise<RunEvent[]>;