@blazingagents/sdk 0.2.2 → 0.4.0

package/README.md

@@ -78,7 +78,7 @@ another nonempty string supported by the selected Model. Omission on creation
 means Provider default; omission on update preserves the saved value, while
 `thinkingLevel: null` clears it. Agent and Version responses include the
 selection, and `restoreVersion` restores it through ordinary validation.
-Use `client.providers.getThinkingLevels(providerId, model)` to read
+Use `client.providers.getThinkingLevels({ providerId, model })` to read
 `{ known, levels }`. Unknown capabilities permit custom values that can still
 be rejected during execution. Levels control reasoning, not a token/cost cap.
 
@@ -122,17 +122,50 @@ preserves user message IDs, regeneration targets, and `useChat` cancellation.
 Regeneration requires an existing Session. Reconnection returns `null`; the
 adapter does not retry interrupted Turns or resume their streams.
 
-### Cancel resource reads
+### Cancel requests
 
-Pass an optional `signal` to resource reads when leaving a screen or switching
-credentials:
+Pass an optional `abortSignal` in the request object for reads, writes, uploads,
+and generation:
 
 ```ts
 const controller = new AbortController();
-const agents = client.agents.list({ signal: controller.signal });
+const agents = client.agents.list({ abortSignal: controller.signal });
 controller.abort();
 await agents; // Rejects with the SDK's typed cancellation error.
 ```
 
 SDK response parsing strips unknown object fields while validating required
 fields and known field types. Request validation remains strict.
+
+### Migrating from 0.2.x to 0.3.0
+
+Resource and generation methods take a single request object, optional when no
+fields are required. Move positional identifiers, body fields, and request
+options into that object. Use `abortSignal` instead of
+`signal`; custom fetch implementations still receive the native `signal`.
+
+```ts
+// Before (0.2.x)
+client.agents.update(agentId, { name: "Builder" });
+client.sessions.messages(agentId, sessionId, { signal });
+client.agent(agentId).skills.list();
+
+// After (0.3.0)
+client.agents.update({ agentId, name: "Builder", abortSignal: signal });
+client.sessions.messages({ agentId, sessionId, abortSignal: signal });
+client.agent({ agentId }).skills.list({ abortSignal: signal });
+```
+
+`ResourceRequestOptions` replaces `ResourceReadOptions`. Cancellation stops the
+request; it does not roll back a mutation already accepted by the server.
+
+## Interactive resend
+
+Successful interactive exchanges are saved together. Failed or canceled execution
+leaves saved history unchanged, including the previous answer during regeneration;
+executed usage and Tool effects remain. Retain submitted text/images until success
+and resend edited or unchanged input through ordinary chat with a fresh message ID.
+Stop requests cancellation; a lost response can hide a saved exchange. Reuse the
+returned Session ID and load history normally on return. No outcome polling or
+automatic generation retry is needed. See the [chatbot guide](https://docs.blazingagents.com/getting-started/chatbot)
+and [working examples](https://github.com/blazingagents/examples).

package/dist/client.d.ts

@@ -13,7 +13,9 @@ export declare class BlazingAgents {
     readonly tenant: TenantResource;
     readonly workspaces: WorkspacesResource;
     constructor(options: BlazingAgentsOptions);
-    agent(agentId: string): AgentClient;
+    agent({ agentId }: {
+        agentId: string;
+    }): AgentClient;
     /**
      * `POST /v1/agents/:agentId/sessions` (create, no `sessionId`) or
      * `POST /v1/agents/:agentId/sessions/:sessionId` (resume). Returns the

package/dist/client.js

@@ -48,7 +48,7 @@ export class BlazingAgents {
         this.tenant = createTenantResource(this.config);
         this.workspaces = createWorkspacesResource(this.config);
     }
-    agent(agentId) {
+    agent({ agentId }) {
         return { skills: createAgentSkillsResource(this.config, agentId) };
     }
     /**

package/dist/contracts/entities/sessions.d.ts

@@ -29,6 +29,36 @@ export declare const sessionsListResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
+/**
+ * `GET /v1/sessions/latest` list item — one per Agent: the Agent's most
+ * recently updated Session (optionally among one end user's Sessions).
+ * Carries `agentId` because the list spans the whole Tenant.
+ */
+export declare const latestSessionListItemSchema: z.ZodObject<{
+    agentVersion: z.ZodNullable<z.ZodNumber>;
+    id: z.ZodString;
+    messageCount: z.ZodNumber;
+    lastMessagePreview: z.ZodNullable<z.ZodString>;
+    userId: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    agentId: z.ZodString;
+}, z.core.$strip>;
+export declare const latestSessionsListResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        agentVersion: z.ZodNullable<z.ZodNumber>;
+        id: z.ZodString;
+        messageCount: z.ZodNumber;
+        lastMessagePreview: z.ZodNullable<z.ZodString>;
+        userId: z.ZodString;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        agentId: z.ZodString;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
 /**
  * `GET /v1/agents/{agentId}/sessions/{sessionId}/messages` — transcript as
  * `UIMessage[]` verbatim, paginated backwards (newest page first) with an
@@ -146,6 +176,8 @@ export declare const toolApprovalDecisionResponseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type SessionListItem = z.infer<typeof sessionListItemSchema>;
 export type SessionsListResponse = z.infer<typeof sessionsListResponseSchema>;
+export type LatestSessionListItem = z.infer<typeof latestSessionListItemSchema>;
+export type LatestSessionsListResponse = z.infer<typeof latestSessionsListResponseSchema>;
 export type SessionMessage = z.infer<typeof sessionMessageSchema>;
 export type SessionMessagesResponse = z.infer<typeof sessionMessagesResponseSchema>;
 export type SessionMessagesQuery = z.infer<typeof sessionMessagesQuerySchema>;

package/dist/contracts/entities/sessions.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { paginatedResponseSchema } from "../api.js";
-import { sessionIdSchema } from "../ids.js";
+import { agentIdSchema, sessionIdSchema } from "../ids.js";
 import { DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT, } from "../limitations.js";
 import { agentVersionNumberSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
@@ -24,6 +24,15 @@ export const sessionListItemSchema = z
 })
     .strip();
 export const sessionsListResponseSchema = paginatedResponseSchema(sessionListItemSchema);
+/**
+ * `GET /v1/sessions/latest` list item — one per Agent: the Agent's most
+ * recently updated Session (optionally among one end user's Sessions).
+ * Carries `agentId` because the list spans the whole Tenant.
+ */
+export const latestSessionListItemSchema = sessionListItemSchema
+    .extend({ agentId: agentIdSchema })
+    .strip();
+export const latestSessionsListResponseSchema = paginatedResponseSchema(latestSessionListItemSchema);
 /**
  * `GET /v1/agents/{agentId}/sessions/{sessionId}/messages` — transcript as
  * `UIMessage[]` verbatim, paginated backwards (newest page first) with an

package/dist/contracts/index.d.ts

@@ -10,7 +10,7 @@ export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchem
 export { createPromptBodySchema, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.ts";
 export { createProviderBodySchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.ts";
 export type { ToolApprovalDecisionResponse, ToolApprovalsResponse, } from "./entities/sessions.ts";
-export { decideToolApprovalBodySchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.ts";
+export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.ts";
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";
 export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskListItemSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
 export { quotaSchema, subscriptionStatusSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.ts";

package/dist/contracts/index.js

@@ -9,7 +9,7 @@ export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema,
 export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, updateMemoryBodySchema, } from "./entities/memories.js";
 export { createPromptBodySchema, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.js";
 export { createProviderBodySchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.js";
-export { decideToolApprovalBodySchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.js";
+export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.js";
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.js";
 export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskListItemSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.js";
 export { quotaSchema, subscriptionStatusSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.js";

package/dist/direct-chat-transport.js

@@ -27,7 +27,7 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
             ...(this.#sessionId === undefined
                 ? { trigger: "submit-message" }
                 : { sessionId: this.#sessionId, trigger: input.trigger }),
-            signal: input.abortSignal,
+            abortSignal: input.abortSignal,
         });
         const stream = result.toStream();
         try {

package/dist/generation.js

@@ -18,7 +18,7 @@ export async function chat(config, input) {
         json: body,
         method: "POST",
         clientRequestId: input.clientRequestId,
-        ...(input.signal ? { signal: input.signal } : {}),
+        ...(input.abortSignal ? { signal: input.abortSignal } : {}),
     });
     return buildChatResult(response, input.sessionId);
 }
@@ -267,7 +267,7 @@ export async function completion(config, input) {
         json: body,
         method: "POST",
         clientRequestId: input.clientRequestId,
-        ...(input.signal ? { signal: input.signal } : {}),
+        ...(input.abortSignal ? { signal: input.abortSignal } : {}),
     });
     return buildCompletionResult(response);
 }
@@ -306,7 +306,7 @@ export async function objectGeneration(config, input) {
         json: body,
         method: "POST",
         clientRequestId: input.clientRequestId,
-        ...(input.signal ? { signal: input.signal } : {}),
+        ...(input.abortSignal ? { signal: input.abortSignal } : {}),
     });
     return buildObjectResult(response);
 }

package/dist/index.d.ts

@@ -18,4 +18,4 @@ export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetw
 export { BlazingAgentsDirectChatTransport, type BlazingAgentsDirectChatTransportOptions, } from "./direct-chat-transport.ts";
 export { BlazingAgentsError } from "./errors.ts";
 export { createChatRelay, createCompletionRelay, type RelayContext, type SessionOwnershipStore, } from "./relay.ts";
-export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, AgentVersionsListOptions, ArtifactsResource, AttributionInput, BlazingAgentsErrorCode, BlazingAgentsOptions, BlazingAgentsRequestOptions, BlazingAgentsUIMessage, BlazingAgentsUIMessageChunk, ChatInput, ChatMessageInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, KnownBlazingAgentsErrorCode, McpConnectionsResource, MemoriesListOptions, MemoriesResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceReadOptions, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";
+export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, AgentVersionsListOptions, ArtifactsResource, AttributionInput, BlazingAgentsErrorCode, BlazingAgentsOptions, BlazingAgentsRequestOptions, BlazingAgentsUIMessage, BlazingAgentsUIMessageChunk, ChatInput, ChatMessageInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, KnownBlazingAgentsErrorCode, LatestSessionsListOptions, McpConnectionsResource, MemoriesListOptions, MemoriesResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceRequestOptions, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";

package/dist/relay.js

@@ -34,7 +34,7 @@ export function createChatRelay(options) {
                 message: validated.data[0],
                 messageId: body.messageId,
                 metadata: context.metadata,
-                signal: request.signal,
+                abortSignal: request.signal,
                 userId: context.userId,
             };
             const result = await options.client.chat(body.sessionId === undefined
@@ -80,7 +80,7 @@ export function createCompletionRelay(options) {
                 agentId: context.agentId,
                 metadata: context.metadata,
                 prompt: body.prompt,
-                signal: request.signal,
+                abortSignal: request.signal,
                 userId: context.userId,
                 version: context.version,
             });

package/dist/resources/agents.js

@@ -8,49 +8,57 @@ import { requestJson } from "../http.js";
  * core wire schemas (parse-on-read).
  */
 export function createAgentsResource(config) {
-    const getVersion = async (agentId, version, options = {}) => requestJson(config, `/v1/agents/${agentId}/versions/${version}`, options, agentVersionSchema);
-    const update = async (agentId, body) => requestJson(config, `/v1/agents/${agentId}`, {
+    const getVersion = async ({ agentId, version, abortSignal, }) => requestJson(config, `/v1/agents/${agentId}/versions/${version}`, { signal: abortSignal }, agentVersionSchema);
+    const update = async ({ agentId, abortSignal, ...body }) => requestJson(config, `/v1/agents/${agentId}`, {
         json: body,
+        signal: abortSignal,
         method: "PUT",
     }, agentResponseSchema);
     return {
-        async create(body) {
+        async create({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/agents", {
                 json: body,
+                signal: abortSignal,
                 method: "POST",
             }, agentResponseSchema);
         },
         async list(options = {}) {
             return await requestJson(config, "/v1/agents", {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: {
                     userId: options.userId,
                     workspaceId: options.workspaceId,
                 },
             }, agentsResponseSchema);
         },
-        async get(agentId, options = {}) {
-            return await requestJson(config, `/v1/agents/${agentId}`, options, agentResponseSchema);
+        async get({ agentId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}`, { signal: abortSignal }, agentResponseSchema);
         },
-        async disable(agentId) {
-            return await requestJson(config, `/v1/agents/${agentId}/disable`, { method: "POST" }, agentResponseSchema);
+        async disable({ agentId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}/disable`, { method: "POST", signal: abortSignal }, agentResponseSchema);
         },
-        async enable(agentId) {
-            return await requestJson(config, `/v1/agents/${agentId}/enable`, { method: "POST" }, agentResponseSchema);
+        async enable({ agentId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}/enable`, { method: "POST", signal: abortSignal }, agentResponseSchema);
         },
         getVersion,
-        async listVersions(agentId, options = {}) {
+        async listVersions({ agentId, ...options }) {
             return await requestJson(config, `/v1/agents/${agentId}/versions`, {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: { cursor: options.cursor, limit: options.limit },
             }, agentVersionsResponseSchema);
         },
-        async listMcpAttachments(agentId, options = {}) {
-            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments`, options, mcpAttachmentsResponseSchema);
+        async listMcpAttachments({ agentId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments`, { signal: abortSignal }, mcpAttachmentsResponseSchema);
         },
-        async restoreVersion(agentId, versionNumber) {
-            const version = await getVersion(agentId, versionNumber);
-            return update(agentId, {
+        async restoreVersion({ agentId, version: versionNumber, abortSignal }) {
+            const version = await getVersion({
+                agentId,
+                version: versionNumber,
+                abortSignal,
+            });
+            return update({
+                agentId,
+                abortSignal,
                 name: version.name,
                 model: version.model,
                 thinkingLevel: version.thinkingLevel,
@@ -63,25 +71,27 @@ export function createAgentsResource(config) {
             });
         },
         update,
-        async updateMcpAttachment(agentId, mcpConnectionId, body) {
-            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments/${mcpConnectionId}`, { json: body, method: "PATCH" }, mcpAttachmentResponseSchema);
+        async updateMcpAttachment({ agentId, mcpConnectionId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments/${mcpConnectionId}`, { json: body, method: "PATCH", signal: abortSignal }, mcpAttachmentResponseSchema);
         },
-        async delete(agentId, includeArtifacts) {
+        async delete({ agentId, includeArtifacts, abortSignal }) {
             await requestJson(config, `/v1/agents/${agentId}`, {
                 method: "DELETE",
                 query: { includeArtifacts },
+                signal: abortSignal,
             });
         },
-        async uploadAvatar(agentId, file) {
+        async uploadAvatar({ agentId, file, abortSignal }) {
             const form = new FormData();
             form.append("file", file);
             return await requestJson(config, `/v1/agents/${agentId}/avatar`, {
                 body: form,
+                signal: abortSignal,
                 method: "POST",
             }, agentResponseSchema);
         },
-        async removeAvatar(agentId) {
-            return await requestJson(config, `/v1/agents/${agentId}/avatar`, { method: "DELETE" }, agentResponseSchema);
+        async removeAvatar({ agentId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}/avatar`, { method: "DELETE", signal: abortSignal }, agentResponseSchema);
         },
     };
 }

package/dist/resources/artifacts.js

@@ -5,15 +5,15 @@ import { requestJson } from "../http.js";
  */
 export function createArtifactsResource(config) {
     return {
-        async createDownloadUrl(artifactId) {
-            return await requestJson(config, `/v1/artifacts/${artifactId}/download-url`, { method: "POST" }, artifactDownloadUrlResponseSchema);
+        async createDownloadUrl({ artifactId, abortSignal }) {
+            return await requestJson(config, `/v1/artifacts/${artifactId}/download-url`, { method: "POST", signal: abortSignal }, artifactDownloadUrlResponseSchema);
         },
-        async get(artifactId, options = {}) {
-            return await requestJson(config, `/v1/artifacts/${artifactId}`, options, artifactListItemSchema);
+        async get({ artifactId, abortSignal }) {
+            return await requestJson(config, `/v1/artifacts/${artifactId}`, { signal: abortSignal }, artifactListItemSchema);
         },
-        async list(options = {}) {
+        async list({ abortSignal, ...options } = {}) {
             return await requestJson(config, "/v1/artifacts", {
-                signal: options.signal,
+                signal: abortSignal,
                 query: {
                     agentId: options.agentId,
                     sessionId: options.sessionId,
@@ -21,9 +21,10 @@ export function createArtifactsResource(config) {
                 },
             }, artifactsListResponseSchema);
         },
-        async delete(artifactId) {
+        async delete({ artifactId, abortSignal }) {
             await requestJson(config, `/v1/artifacts/${artifactId}`, {
                 method: "DELETE",
+                signal: abortSignal,
             });
         },
     };

package/dist/resources/mcp-connections.js

@@ -1,38 +1,42 @@
 import { mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionsResponseSchema, mcpConnectionTestResponseSchema, reconnectMcpConnectionBodySchema, updateMcpConnectionBodySchema, } from "../contracts/entities/mcp-connections.js";
 import { requestJson } from "../http.js";
 export function createMcpConnectionsResource(config) {
-    const create = (async (body) => requestJson(config, "/v1/mcp-connections", {
+    const create = (async ({ abortSignal, ...body }) => requestJson(config, "/v1/mcp-connections", {
         json: body,
+        signal: abortSignal,
         method: "POST",
     }, mcpConnectionResponseSchema));
     return {
-        async connect(id) {
-            return await requestJson(config, `/v1/mcp-connections/${id}/connect`, { method: "POST" }, mcpConnectionOauthConnectResponseSchema);
+        async connect({ mcpConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}/connect`, { method: "POST", signal: abortSignal }, mcpConnectionOauthConnectResponseSchema);
         },
         create,
-        async list(options = {}) {
-            return await requestJson(config, "/v1/mcp-connections", options, mcpConnectionsResponseSchema);
+        async list({ abortSignal } = {}) {
+            return await requestJson(config, "/v1/mcp-connections", { signal: abortSignal }, mcpConnectionsResponseSchema);
         },
-        async get(id, options = {}) {
-            return await requestJson(config, `/v1/mcp-connections/${id}`, options, mcpConnectionResponseSchema);
+        async get({ mcpConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}`, { signal: abortSignal }, mcpConnectionResponseSchema);
         },
-        async update(id, body) {
-            return await requestJson(config, `/v1/mcp-connections/${id}`, {
+        async update({ mcpConnectionId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}`, {
                 json: updateMcpConnectionBodySchema.parse(body),
+                signal: abortSignal,
                 method: "PATCH",
             }, mcpConnectionResponseSchema);
         },
-        async delete(id) {
-            await requestJson(config, `/v1/mcp-connections/${id}`, {
+        async delete({ mcpConnectionId, abortSignal }) {
+            await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}`, {
                 method: "DELETE",
+                signal: abortSignal,
             });
         },
-        async test(id) {
-            return await requestJson(config, `/v1/mcp-connections/${id}/test`, { method: "POST" }, mcpConnectionTestResponseSchema);
+        async test({ mcpConnectionId, abortSignal }) {
+            return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}/test`, { method: "POST", signal: abortSignal }, mcpConnectionTestResponseSchema);
         },
-        async reconnect(id, body) {
-            return await requestJson(config, `/v1/mcp-connections/${id}/reconnect`, {
+        async reconnect({ mcpConnectionId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/mcp-connections/${mcpConnectionId}/reconnect`, {
                 json: reconnectMcpConnectionBodySchema.parse(body),
+                signal: abortSignal,
                 method: "POST",
             }, mcpConnectionReconnectResultSchema);
         },

package/dist/resources/memories.js

@@ -7,9 +7,9 @@ import { requestJson } from "../http.js";
  */
 export function createMemoriesResource(config) {
     return {
-        async list(agentId, options = {}) {
+        async list({ agentId, abortSignal, ...options }) {
             return await requestJson(config, `/v1/agents/${agentId}/memories`, {
-                signal: options.signal,
+                signal: abortSignal,
                 query: {
                     ...(options.userId === undefined ? {} : { userId: options.userId }),
                     search: options.search,
@@ -18,17 +18,17 @@ export function createMemoriesResource(config) {
                 },
             }, memoriesListResponseSchema);
         },
-        async create(agentId, body) {
-            return await requestJson(config, `/v1/agents/${agentId}/memories`, { json: body, method: "POST" }, memoryResponseSchema);
+        async create({ agentId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/agents/${agentId}/memories`, { json: body, signal: abortSignal, method: "POST" }, memoryResponseSchema);
         },
-        async get(agentId, memoryId, options = {}) {
-            return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, options, memoryResponseSchema);
+        async get({ agentId, memoryId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { signal: abortSignal }, memoryResponseSchema);
         },
-        async update(agentId, memoryId, body) {
-            return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { json: body, method: "PATCH" }, memoryResponseSchema);
+        async update({ agentId, memoryId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { json: body, signal: abortSignal, method: "PATCH" }, memoryResponseSchema);
         },
-        async delete(agentId, memoryId) {
-            await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { method: "DELETE" });
+        async delete({ agentId, memoryId, abortSignal }) {
+            await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, { method: "DELETE", signal: abortSignal });
         },
     };
 }

package/dist/resources/prompts.js

@@ -6,31 +6,34 @@ import { requestJson } from "../http.js";
  */
 export function createPromptsResource(config) {
     return {
-        async create(body) {
+        async create({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/prompts", {
                 json: body,
+                signal: abortSignal,
                 method: "POST",
             }, promptResponseSchema);
         },
-        async list(userId, options = {}) {
+        async list({ userId, abortSignal } = {}) {
             return await requestJson(config, "/v1/prompts", {
-                ...options,
+                signal: abortSignal,
                 // Stryker disable next-line ConditionalExpression: URL serialization omits an undefined query value.
                 ...(userId === undefined ? {} : { query: { userId } }),
             }, promptsResponseSchema);
         },
-        async get(promptId, options = {}) {
-            return await requestJson(config, `/v1/prompts/${promptId}`, options, promptResponseSchema);
+        async get({ promptId, abortSignal }) {
+            return await requestJson(config, `/v1/prompts/${promptId}`, { signal: abortSignal }, promptResponseSchema);
         },
-        async update(promptId, body) {
+        async update({ promptId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/prompts/${promptId}`, {
                 json: body,
+                signal: abortSignal,
                 method: "PATCH",
             }, promptResponseSchema);
         },
-        async delete(promptId) {
+        async delete({ promptId, abortSignal }) {
             await requestJson(config, `/v1/prompts/${promptId}`, {
                 method: "DELETE",
+                signal: abortSignal,
             });
         },
     };

package/dist/resources/providers.js

@@ -5,33 +5,36 @@ import { requestJson } from "../http.js";
  */
 export function createProvidersResource(config) {
     return {
-        async create(body) {
+        async create({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/providers", {
                 json: body,
+                signal: abortSignal,
                 method: "POST",
             }, providerResponseSchema);
         },
-        async list(options = {}) {
-            return await requestJson(config, "/v1/providers", options, providersResponseSchema);
+        async list({ abortSignal } = {}) {
+            return await requestJson(config, "/v1/providers", { signal: abortSignal }, providersResponseSchema);
         },
-        async get(id, options = {}) {
-            return await requestJson(config, `/v1/providers/${id}`, options, providerResponseSchema);
+        async get({ providerId, abortSignal }) {
+            return await requestJson(config, `/v1/providers/${providerId}`, { signal: abortSignal }, providerResponseSchema);
         },
-        async listModels(id, options = {}) {
-            return await requestJson(config, `/v1/providers/${id}/models`, options, providerModelsResponseSchema);
+        async listModels({ providerId, abortSignal }) {
+            return await requestJson(config, `/v1/providers/${providerId}/models`, { signal: abortSignal }, providerModelsResponseSchema);
         },
-        async getThinkingLevels(id, model, options = {}) {
-            return await requestJson(config, `/v1/providers/${id}/thinking-levels`, { ...options, query: { model } }, thinkingLevelsResponseSchema);
+        async getThinkingLevels({ providerId, model, abortSignal }) {
+            return await requestJson(config, `/v1/providers/${providerId}/thinking-levels`, { signal: abortSignal, query: { model } }, thinkingLevelsResponseSchema);
         },
-        async update(id, body) {
-            return await requestJson(config, `/v1/providers/${id}`, {
+        async update({ providerId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/providers/${providerId}`, {
                 json: body,
+                signal: abortSignal,
                 method: "PATCH",
             }, providerResponseSchema);
         },
-        async delete(id, options = {}) {
-            await requestJson(config, `/v1/providers/${id}`, {
+        async delete({ providerId, abortSignal, ...options }) {
+            await requestJson(config, `/v1/providers/${providerId}`, {
                 method: "DELETE",
+                signal: abortSignal,
                 query: {
                     confirmVersionInvalidation: options.confirmVersionInvalidation,
                 },