@blazingagents/sdk 0.20.0 → 0.21.0

package/dist/http.js

@@ -4,6 +4,9 @@ const DIAGNOSTIC_BODY_LIMIT_BYTES = 64 * 1024;
 const INVALID_RESPONSE_MESSAGE = "The server returned an invalid response.";
 const NETWORK_ERROR_MESSAGE = "Network request failed (fetch threw before any HTTP exchange).";
 const REQUEST_ABORTED_MESSAGE = "The request was aborted before any HTTP response.";
+/**
+ * Appends query values while omitting null and undefined entries.
+ */
 function buildUrl(baseUrl, path, query) {
     const url = `${baseUrl}${path}`;
     if (!query) {
@@ -23,6 +26,10 @@ function buildUrl(baseUrl, path, query) {
  * Performs a request and returns the parsed JSON body for success (status
  * 2xx). API errors preserve the tolerant wire envelope; malformed responses
  * become `invalid_response`.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param path - Endpoint path relative to the base URL.
+ * @param options - Configuration for this operation.
+ * @param schema - Schema used to validate the value.
  */
 export async function requestJson(config, path, options = {}, schema) {
     const response = await rawRequest(config, path, options);
@@ -56,6 +63,9 @@ export async function requestJson(config, path, options = {}, schema) {
 /**
  * Performs a request and returns the raw `Response` for streaming paths.
  * Non-2xx bodies are decoded before a caller can observe a streaming body.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param path - Endpoint path relative to the base URL.
+ * @param options - Configuration for this operation.
  */
 export async function requestStream(config, path, options = {}) {
     const response = await rawRequest(config, path, options);
@@ -64,6 +74,9 @@ export async function requestStream(config, path, options = {}) {
     }
     throw await errorFromResponse(response, options.signal);
 }
+/**
+ * Sends an authenticated request and reports response metadata to the observer.
+ */
 async function rawRequest(config, path, options) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     const url = buildUrl(config.baseUrl, path, options.query);
@@ -122,6 +135,9 @@ async function rawRequest(config, path, options) {
         }, { cause });
     }
 }
+/**
+ * Reads bounded diagnostics and decodes a failed HTTP response.
+ */
 async function errorFromResponse(response, signal) {
     const read = await readResponseBody(response, true);
     if (read.readFailed && isRequestAborted(read.cause, signal)) {
@@ -133,6 +149,12 @@ async function errorFromResponse(response, signal) {
     }
     return parseErrorEnvelope(read.diagnosticBody, response.status, headers);
 }
+/**
+ * Checks whether the signal aborted or the cause names an AbortError.
+ * @param cause - Original failure to retain.
+ * @param signal - Signal that cancels the operation.
+ * @returns Whether the request signal or cause indicates cancellation.
+ */
 export function isRequestAborted(cause, signal) {
     return (signal?.aborted === true ||
         (cause !== null &&
@@ -140,6 +162,11 @@ export function isRequestAborted(cause, signal) {
             "name" in cause &&
             cause.name === "AbortError"));
 }
+/**
+ * Wraps an abort cause as a request_aborted SDK error.
+ * @param cause - Original failure to retain.
+ * @returns A request_aborted error retaining the cause.
+ */
 export function requestAbortedError(cause) {
     return new BlazingAgentsError({
         code: "request_aborted",
@@ -215,6 +242,9 @@ async function readResponseBody(response, stopAtDiagnosticLimit) {
         byteLength += chunk.byteLength;
     }
 }
+/**
+ * Cancels an oversized error body and retains its bounded diagnostic prefix.
+ */
 async function cancelTruncatedBody(reader, chunks, byteLength) {
     const diagnosticBody = decodeDiagnosticChunks(chunks, byteLength, true).body;
     try {
@@ -236,6 +266,9 @@ async function cancelTruncatedBody(reader, chunks, byteLength) {
         };
     }
 }
+/**
+ * Decodes diagnostics without exceeding the UTF-8 byte limit.
+ */
 function decodeDiagnosticChunks(chunks, byteLength, sourceTruncated) {
     const body = decodeChunks(chunks, byteLength, sourceTruncated);
     const encoded = new TextEncoder().encode(body);
@@ -247,6 +280,9 @@ function decodeDiagnosticChunks(chunks, byteLength, sourceTruncated) {
         truncated: true,
     };
 }
+/**
+ * Joins retained bytes and omits an incomplete trailing character when truncated.
+ */
 function decodeChunks(chunks, byteLength, truncated) {
     const bytes = new Uint8Array(byteLength);
     let offset = 0;
@@ -264,6 +300,10 @@ function decodeChunks(chunks, byteLength, truncated) {
  * Decodes a response body with the tolerant consumer schema. Unknown future
  * codes and fields remain valid; malformed responses never infer a domain
  * code from HTTP status.
+ * @param bodyText - Response body as text.
+ * @param status - HTTP response status.
+ * @param headers - Response headers to preserve or inspect.
+ * @returns The server error, or invalid_response when the envelope is malformed.
  */
 export function parseErrorEnvelope(bodyText, status, headers = new Headers()) {
     let parsed;
@@ -292,6 +332,9 @@ export function parseErrorEnvelope(bodyText, status, headers = new Headers()) {
     }
     return invalidResponseError(headers, status, bodyText, false);
 }
+/**
+ * Builds an invalid_response error with bounded diagnostics and request correlation.
+ */
 function invalidResponseError(headers, status, responseBody, responseBodyTruncated, cause) {
     return new BlazingAgentsError({
         code: "invalid_response",

package/dist/index.d.ts

@@ -16,11 +16,11 @@ export type { CreateMerchantConnectionBody, MerchantBindingResponse, MerchantBin
 export type { CreatePromptBody, PromptResponse, PromptsListQuery, PromptsResponse, UpdatePromptBody, } from "./contracts/entities/prompts.ts";
 export type { CreateProviderBody, ProviderListItem, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, ThinkingLevelsResponse, UpdateProviderBody, } from "./contracts/entities/providers.ts";
 export type { ChatSteerConsumedEvent, SessionActivity, SessionInput, SessionInputResponse, SessionInputState, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody, } from "./contracts/entities/session-inputs.ts";
-export type { ContinueToolApprovalsBody, SessionResponse, ToolApprovalDecision, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.ts";
+export type { ContinueToolApprovalsBody, SessionForkedFrom, SessionResponse, ToolApprovalDecision, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.ts";
 export { sessionResponseSchema } from "./contracts/entities/sessions.ts";
 export type { CreateSkillBody, Skill, SkillArchiveType, SkillCopyResult, SkillCopyResults, SkillDetail, SkillFile, SkillsListResponse, } from "./contracts/entities/skills.ts";
 export type { SessionUsageQuery, SessionUsageResponse, UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageTotals, } from "./contracts/entities/usage.ts";
-export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, } from "./contracts/entities/workspaces.ts";
+export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, WorkspaceTier, } from "./contracts/entities/workspaces.ts";
 export { BlazingAgentsDirectChatTransport, type BlazingAgentsDirectChatTransportOptions, } from "./direct-chat-transport.ts";
 export { BlazingAgentsError } from "./errors.ts";
 export { type ChatFunction, type ChatFunctionContext, type ChatFunctions, defineFunction, } from "./functions.ts";

package/dist/relay.d.ts

@@ -8,19 +8,42 @@ export interface RelayContext {
     userId: string;
 }
 export interface SessionOwnershipStore {
+    /**
+     * Looks up the end user who owns the Session.
+     * @param sessionId - Session to look up or record.
+     * @returns The owner ID, or undefined when no owner is recorded.
+     */
     ownerOf(sessionId: string): Promise<string | undefined>;
+    /**
+     * Records ownership of a newly created Session.
+     * @param sessionId - Session to look up or record.
+     * @param userId - End-user ID for request scope.
+     * @returns Resolves after ownership is stored.
+     */
     recordOwner(sessionId: string, userId: string): Promise<void>;
 }
 interface RelayOptions<Method extends keyof BlazingAgents> {
     client: Pick<BlazingAgents, Method>;
+    /**
+     * Resolves authenticated Agent and end-user context, or null for an unauthenticated request.
+     * @param request - Incoming HTTP request.
+     * @returns Authenticated context, or null when authentication fails.
+     */
     resolveContext(request: Request): Promise<RelayContext | null>;
 }
 /**
  * Relays useChat submissions. An assistant message carrying approval
  * responses submits the complete round and streams the continuation.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that checks Session ownership before resuming.
  */
 export declare function createChatRelay(options: RelayOptions<"chat" | "continueChat"> & {
     sessions: SessionOwnershipStore;
 }): (request: Request) => Promise<Response>;
+/**
+ * Creates an authenticated HTTP handler that validates prompts and relays text generation.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that validates prompts and relays text generation.
+ */
 export declare function createCompletionRelay(options: RelayOptions<"completion">): (request: Request) => Promise<Response>;
 export {};

package/dist/relay.js

@@ -15,6 +15,8 @@ const completionBodySchema = z.object({ prompt: z.string().trim().min(1) });
 /**
  * Relays useChat submissions. An assistant message carrying approval
  * responses submits the complete round and streams the continuation.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that checks Session ownership before resuming.
  */
 export function createChatRelay(options) {
     return async (request) => {
@@ -86,6 +88,9 @@ export function createChatRelay(options) {
         }
     };
 }
+/**
+ * Validates the Session and forwards the last assistant approval round.
+ */
 async function relayApprovalResponses(client, { functions, message, request, ...input }) {
     if (input.sessionId === undefined) {
         return errorResponse(400, "invalid_request", "Tool approval requires an existing Session.");
@@ -106,6 +111,11 @@ async function relayApprovalResponses(client, { functions, message, request, ...
     });
     return continuation.toResponse();
 }
+/**
+ * Creates an authenticated HTTP handler that validates prompts and relays text generation.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that validates prompts and relays text generation.
+ */
 export function createCompletionRelay(options) {
     return async (request) => {
         try {
@@ -128,6 +138,9 @@ export function createCompletionRelay(options) {
         }
     };
 }
+/**
+ * Maps validation and SDK failures to safe public error responses.
+ */
 function safeErrorResponse(error) {
     if (error instanceof z.ZodError || error instanceof SyntaxError) {
         return errorResponse(400, "invalid_request", "Invalid request body.");
@@ -143,6 +156,9 @@ function safeErrorResponse(error) {
     }
     return errorResponse(500, "internal_error", "Request failed.");
 }
+/**
+ * Builds a JSON error envelope with the selected HTTP status.
+ */
 function errorResponse(status, code, message, headers) {
     const responseHeaders = new Headers(headers);
     responseHeaders.set("content-type", "application/json");

package/dist/resources/agents.d.ts

@@ -1,2 +1,7 @@
 import type { AgentsResource, HttpConfig } from "../types.ts";
+/**
+ * Builds the Agents operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export declare function createAgentsResource(config: HttpConfig): AgentsResource;

package/dist/resources/agents.js

@@ -1,13 +1,24 @@
 import { agentResponseSchema, agentsResponseSchema, } from "../contracts/entities/agents.js";
 import { mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, } from "../contracts/entities/mcp-connections.js";
 import { requestJson } from "../http.js";
+/**
+ * Builds the Agents operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export function createAgentsResource(config) {
+    /**
+     * Updates agents.
+     */
     const update = async ({ agentId, abortSignal, ...body }) => requestJson(config, `/v1/agents/${agentId}`, {
         json: body,
         signal: abortSignal,
         method: "PUT",
     }, agentResponseSchema);
     return {
+        /**
+         * Creates agents.
+         */
         async create({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/agents", {
                 json: body,
@@ -15,6 +26,9 @@ export function createAgentsResource(config) {
                 method: "POST",
             }, agentResponseSchema);
         },
+        /**
+         * Lists one page of agents.
+         */
         async list(options = {}) {
             return await requestJson(config, "/v1/agents", {
                 signal: options.abortSignal,
@@ -26,22 +40,40 @@ export function createAgentsResource(config) {
                 },
             }, agentsResponseSchema);
         },
+        /**
+         * Retrieves agents.
+         */
         async get({ agentId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}`, { signal: abortSignal }, agentResponseSchema);
         },
+        /**
+         * Disables agents.
+         */
         async disable({ agentId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/disable`, { method: "POST", signal: abortSignal }, agentResponseSchema);
         },
+        /**
+         * Enables agents.
+         */
         async enable({ agentId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/enable`, { method: "POST", signal: abortSignal }, agentResponseSchema);
         },
+        /**
+         * Lists the Agent MCP attachments.
+         */
         async listMcpAttachments({ agentId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments`, { signal: abortSignal }, mcpAttachmentsResponseSchema);
         },
         update,
+        /**
+         * Updates one Agent MCP attachment.
+         */
         async updateMcpAttachment({ agentId, mcpConnectionId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments/${mcpConnectionId}`, { json: body, method: "PATCH", signal: abortSignal }, mcpAttachmentResponseSchema);
         },
+        /**
+         * Deletes agents.
+         */
         async delete({ agentId, includeArtifacts, abortSignal }) {
             await requestJson(config, `/v1/agents/${agentId}`, {
                 method: "DELETE",
@@ -49,6 +81,9 @@ export function createAgentsResource(config) {
                 signal: abortSignal,
             });
         },
+        /**
+         * Uploads an Agent avatar as multipart form data.
+         */
         async uploadAvatar({ agentId, file, abortSignal }) {
             const form = new FormData();
             form.append("file", file);
@@ -58,6 +93,9 @@ export function createAgentsResource(config) {
                 method: "POST",
             }, agentResponseSchema);
         },
+        /**
+         * Removes the Agent avatar.
+         */
         async removeAvatar({ agentId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/avatar`, { method: "DELETE", signal: abortSignal }, agentResponseSchema);
         },

package/dist/resources/artifacts.d.ts

@@ -1,5 +1,7 @@
 import type { ArtifactsResource, HttpConfig } from "../types.ts";
 /**
  * `client.artifacts` — Tenant-level metadata and direct download URLs.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export declare function createArtifactsResource(config: HttpConfig): ArtifactsResource;

package/dist/resources/artifacts.js

@@ -2,15 +2,26 @@ import { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsLis
 import { requestJson } from "../http.js";
 /**
  * `client.artifacts` — Tenant-level metadata and direct download URLs.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export function createArtifactsResource(config) {
     return {
+        /**
+         * Creates a temporary Artifact download URL.
+         */
         async createDownloadUrl({ artifactId, abortSignal }) {
             return await requestJson(config, `/v1/artifacts/${artifactId}/download-url`, { method: "POST", signal: abortSignal }, artifactDownloadUrlResponseSchema);
         },
+        /**
+         * Retrieves artifacts.
+         */
         async get({ artifactId, abortSignal }) {
             return await requestJson(config, `/v1/artifacts/${artifactId}`, { signal: abortSignal }, artifactListItemSchema);
         },
+        /**
+         * Lists one page of artifacts.
+         */
         async list({ abortSignal, ...options } = {}) {
             return await requestJson(config, "/v1/artifacts", {
                 signal: abortSignal,
@@ -21,6 +32,9 @@ export function createArtifactsResource(config) {
                 },
             }, artifactsListResponseSchema);
         },
+        /**
+         * Deletes artifacts.
+         */
         async delete({ artifactId, abortSignal }) {
             await requestJson(config, `/v1/artifacts/${artifactId}`, {
                 method: "DELETE",

package/dist/resources/chat-connections.d.ts

@@ -1,2 +1,7 @@
 import type { ChatConnectionsResource, HttpConfig } from "../types.ts";
+/**
+ * Builds the Chat Connections operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export declare function createChatConnectionsResource(config: HttpConfig): ChatConnectionsResource;

package/dist/resources/chat-connections.js

@@ -1,31 +1,63 @@
 import { chatConnectionSchema, chatConnectionsResponseSchema, } from "../contracts/entities/chat-connections.js";
 import { requestJson } from "../http.js";
+/**
+ * Builds the Chat Connections operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export function createChatConnectionsResource(config) {
     return {
+        /**
+         * Lists one page of chat connections.
+         */
         async list({ abortSignal } = {}) {
             return await requestJson(config, "/v1/chat-connections", { signal: abortSignal }, chatConnectionsResponseSchema);
         },
+        /**
+         * Creates chat connections.
+         */
         async create({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/chat-connections", { signal: abortSignal, method: "POST", json: body }, chatConnectionSchema);
         },
+        /**
+         * Retrieves chat connections.
+         */
         async get({ chatConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}`, { signal: abortSignal, method: "GET" }, chatConnectionSchema);
         },
+        /**
+         * Updates chat connections.
+         */
         async update({ chatConnectionId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}`, { signal: abortSignal, method: "PATCH", json: body }, chatConnectionSchema);
         },
+        /**
+         * Replaces the Chat Connection credentials.
+         */
         async rotateCredentials({ chatConnectionId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/credentials`, { signal: abortSignal, method: "POST", json: body }, chatConnectionSchema);
         },
+        /**
+         * Checks the Chat Connection health.
+         */
         async checkHealth({ chatConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/health`, { signal: abortSignal, method: "POST" }, chatConnectionSchema);
         },
+        /**
+         * Enables chat connections.
+         */
         async enable({ chatConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/enable`, { signal: abortSignal, method: "POST" }, chatConnectionSchema);
         },
+        /**
+         * Disables chat connections.
+         */
         async disable({ chatConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}/disable`, { signal: abortSignal, method: "POST" }, chatConnectionSchema);
         },
+        /**
+         * Deletes chat connections.
+         */
         async delete({ chatConnectionId, abortSignal }) {
             await requestJson(config, `/v1/chat-connections/${encodeURIComponent(chatConnectionId)}`, { signal: abortSignal, method: "DELETE" });
         },

package/dist/resources/chat-deliveries.d.ts

@@ -2,5 +2,7 @@ import type { ChatDeliveriesResource, HttpConfig } from "../types.ts";
 /**
  * `client.chatDeliveries` — `GET /v1/chat-deliveries`, the Tenant-wide
  * delivery feed across all Chat Connections, newest first.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export declare function createChatDeliveriesResource(config: HttpConfig): ChatDeliveriesResource;

package/dist/resources/chat-deliveries.js

@@ -3,9 +3,14 @@ import { requestJson } from "../http.js";
 /**
  * `client.chatDeliveries` — `GET /v1/chat-deliveries`, the Tenant-wide
  * delivery feed across all Chat Connections, newest first.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export function createChatDeliveriesResource(config) {
     return {
+        /**
+         * Lists one page of chat deliveries.
+         */
         async list({ abortSignal, status, ...query } = {}) {
             return await requestJson(config, "/v1/chat-deliveries", {
                 query: {

package/dist/resources/mcp-connections.d.ts

@@ -1,2 +1,7 @@
 import type { HttpConfig, McpConnectionsResource } from "../types.ts";
+/**
+ * Builds the Mcp Connections operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export declare function createMcpConnectionsResource(config: HttpConfig): McpConnectionsResource;

package/dist/resources/mcp-connections.js

@@ -1,5 +1,10 @@
 import { mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionsResponseSchema, mcpConnectionTestResponseSchema, reconnectMcpConnectionBodySchema, updateMcpConnectionBodySchema, } from "../contracts/entities/mcp-connections.js";
 import { requestJson } from "../http.js";
+/**
+ * Builds the Mcp Connections operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export function createMcpConnectionsResource(config) {
     const create = (async ({ abortSignal, ...body }) => requestJson(config, "/v1/mcp-connections", {
         json: body,
@@ -7,16 +12,28 @@ export function createMcpConnectionsResource(config) {
         method: "POST",
     }, mcpConnectionResponseSchema));
     return {
+        /**
+         * Starts OAuth authorization for mcp connections.
+         */
         async connect({ mcpConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}/connect`, { method: "POST", signal: abortSignal }, mcpConnectionOauthConnectResponseSchema);
         },
         create,
+        /**
+         * Lists one page of mcp connections.
+         */
         async list({ abortSignal } = {}) {
             return await requestJson(config, "/v1/mcp-connections", { signal: abortSignal }, mcpConnectionsResponseSchema);
         },
+        /**
+         * Retrieves mcp connections.
+         */
         async get({ mcpConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}`, { signal: abortSignal }, mcpConnectionResponseSchema);
         },
+        /**
+         * Updates mcp connections.
+         */
         async update({ mcpConnectionId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}`, {
                 json: updateMcpConnectionBodySchema.parse(body),
@@ -24,15 +41,24 @@ export function createMcpConnectionsResource(config) {
                 method: "PATCH",
             }, mcpConnectionResponseSchema);
         },
+        /**
+         * Deletes mcp connections.
+         */
         async delete({ mcpConnectionId, abortSignal }) {
             await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}`, {
                 method: "DELETE",
                 signal: abortSignal,
             });
         },
+        /**
+         * Tests mcp connections.
+         */
         async test({ mcpConnectionId, abortSignal }) {
             return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}/test`, { method: "POST", signal: abortSignal }, mcpConnectionTestResponseSchema);
         },
+        /**
+         * Reconnects mcp connections.
+         */
         async reconnect({ mcpConnectionId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}/reconnect`, {
                 json: reconnectMcpConnectionBodySchema.parse(body),

package/dist/resources/memories.d.ts

@@ -3,5 +3,7 @@ import type { HttpConfig, MemoriesResource } from "../types.ts";
  * `client.memories` — CRUD and query over `/v1/agents/:agentId/memories`.
  * Memories are Agent-nested; `userId` is stamped at creation and immutable,
  * while list can filter it (including explicit `''`) or full-text search.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export declare function createMemoriesResource(config: HttpConfig): MemoriesResource;

package/dist/resources/memories.js

@@ -4,9 +4,14 @@ import { requestJson } from "../http.js";
  * `client.memories` — CRUD and query over `/v1/agents/:agentId/memories`.
  * Memories are Agent-nested; `userId` is stamped at creation and immutable,
  * while list can filter it (including explicit `''`) or full-text search.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export function createMemoriesResource(config) {
     return {
+        /**
+         * Lists one page of memories.
+         */
         async list({ agentId, abortSignal, ...options }) {
             return await requestJson(config, `/v1/agents/${agentId}/memories`, {
                 signal: abortSignal,
@@ -18,15 +23,27 @@ export function createMemoriesResource(config) {
                 },
             }, memoriesListResponseSchema);
         },
+        /**
+         * Creates memories.
+         */
         async create({ agentId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/agents/${agentId}/memories`, { json: body, signal: abortSignal, method: "POST" }, memoryResponseSchema);
         },
+        /**
+         * Retrieves memories.
+         */
         async get({ agentId, memoryId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { signal: abortSignal }, memoryResponseSchema);
         },
+        /**
+         * Updates memories.
+         */
         async update({ agentId, memoryId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { json: body, signal: abortSignal, method: "PATCH" }, memoryResponseSchema);
         },
+        /**
+         * Deletes memories.
+         */
         async delete({ agentId, memoryId, abortSignal }) {
             await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { method: "DELETE", signal: abortSignal });
         },

package/dist/resources/merchant-bindings.d.ts

@@ -4,5 +4,7 @@ import type { HttpConfig, MerchantBindingsResource } from "../types.ts";
  * `/v1/merchant-connection/bindings`. `put` upserts the end user's provider
  * customer; the server validates the customer with the provider before
  * storing.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export declare function createMerchantBindingsResource(config: HttpConfig): MerchantBindingsResource;

package/dist/resources/merchant-bindings.js

@@ -5,15 +5,26 @@ import { requestJson } from "../http.js";
  * `/v1/merchant-connection/bindings`. `put` upserts the end user's provider
  * customer; the server validates the customer with the provider before
  * storing.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export function createMerchantBindingsResource(config) {
     return {
+        /**
+         * Lists one page of merchant bindings.
+         */
         async list({ abortSignal, ...query } = {}) {
             return await requestJson(config, "/v1/merchant-connection/bindings", { query, signal: abortSignal }, merchantBindingsResponseSchema);
         },
+        /**
+         * Validates and saves merchant bindings.
+         */
         async put({ userId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/merchant-connection/bindings/${encodeURIComponent(userId)}`, { json: body, method: "PUT", signal: abortSignal }, merchantBindingResponseSchema);
         },
+        /**
+         * Deletes merchant bindings.
+         */
         async delete({ userId, abortSignal }) {
             await requestJson(config, `/v1/merchant-connection/bindings/${encodeURIComponent(userId)}`, { method: "DELETE", signal: abortSignal });
         },

package/dist/resources/merchant-connection.d.ts

@@ -3,5 +3,7 @@ import type { HttpConfig, MerchantConnectionResource } from "../types.ts";
  * `client.merchantConnection` — get/create/update/retire over
  * `/v1/merchant-connection`. One connection per tenant; `credential` is
  * write-only and never returned.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
  */
 export declare function createMerchantConnectionResource(config: HttpConfig): MerchantConnectionResource;