@blazingagents/sdk 0.2.2 → 0.3.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,39 @@ 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.

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/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, 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,
                 },

package/dist/resources/sessions.js

@@ -9,16 +9,16 @@ import { requestJson, requestStream } from "../http.js";
  */
 export function createSessionsResource(config) {
     return {
-        async decideToolApproval(agentId, sessionId, approvalId, decision, options = {}) {
+        async decideToolApproval({ agentId, sessionId, approvalId, abortSignal, ...decision }) {
             return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approvals/${approvalId}`, {
                 json: decision,
                 method: "POST",
-                ...(options.signal ? { signal: options.signal } : {}),
+                signal: abortSignal,
             }, toolApprovalDecisionResponseSchema);
         },
-        async list(agentId, options = {}) {
+        async list({ agentId, ...options }) {
             return await requestJson(config, `/v1/agents/${agentId}/sessions`, {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: {
                     cursor: options.cursor,
                     limit: options.limit,
@@ -27,9 +27,9 @@ export function createSessionsResource(config) {
                 },
             }, sessionsListResponseSchema);
         },
-        async messages(agentId, sessionId, options = {}) {
+        async messages({ agentId, sessionId, ...options }) {
             return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/messages`, {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: {
                     cursor: options.cursor,
                     after: options.after,
@@ -37,15 +37,15 @@ export function createSessionsResource(config) {
                 },
             }, sessionMessagesResponseSchema);
         },
-        async joinToolApprovalContinuation(agentId, sessionId, continuationId, options = {}) {
-            const response = await requestStream(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approval-continuations/${continuationId}`, options.signal ? { signal: options.signal } : {});
+        async joinToolApprovalContinuation({ agentId, sessionId, continuationId, abortSignal, }) {
+            const response = await requestStream(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approval-continuations/${continuationId}`, { signal: abortSignal });
             return buildTerminalStreamResult(response, "continuation");
         },
-        async toolApprovals(agentId, sessionId, options = {}) {
-            return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approvals`, options, toolApprovalsResponseSchema);
+        async toolApprovals({ agentId, sessionId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approvals`, { signal: abortSignal }, toolApprovalsResponseSchema);
         },
-        async delete(agentId, sessionId, deleteArtifacts) {
-            await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}`, { method: "DELETE", query: { deleteArtifacts } });
+        async delete({ agentId, sessionId, deleteArtifacts, abortSignal }) {
+            await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}`, { method: "DELETE", query: { deleteArtifacts }, signal: abortSignal });
         },
     };
 }

package/dist/resources/skills.js

@@ -6,52 +6,56 @@ function fileUrl(agentId, input) {
 }
 export function createAgentSkillsResource(config, agentId) {
     return {
-        async copy({ skillId, to }) {
-            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}/copies`, { json: to, method: "POST" }, skillCopyResultsSchema);
+        async copy({ skillId, to, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}/copies`, { json: to, method: "POST", signal: abortSignal }, skillCopyResultsSchema);
         },
-        async create(body) {
-            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills`, { json: body, method: "POST" }, skillDetailSchema);
+        async create({ abortSignal, ...body }) {
+            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills`, { json: body, method: "POST", signal: abortSignal }, skillDetailSchema);
         },
-        async delete({ skillId }) {
-            await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}`, { method: "DELETE" });
+        async delete({ skillId, abortSignal }) {
+            await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}`, { method: "DELETE", signal: abortSignal });
         },
-        async deleteFile(input) {
+        async deleteFile({ abortSignal, ...input }) {
             return await requestJson(config, fileUrl(agentId, input), {
                 method: "DELETE",
+                signal: abortSignal,
             }, skillDetailSchema);
         },
-        async get({ skillId }, options = {}) {
-            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}`, options, skillDetailSchema);
+        async get({ skillId, abortSignal }) {
+            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/${encodeURIComponent(skillId)}`, { signal: abortSignal }, skillDetailSchema);
         },
-        async getFile(input, options = {}) {
-            const response = await requestStream(config, fileUrl(agentId, input), options);
+        async getFile({ abortSignal, ...input }) {
+            const response = await requestStream(config, fileUrl(agentId, input), {
+                signal: abortSignal,
+            });
             try {
                 return new Uint8Array(await response.arrayBuffer());
             }
             catch (cause) {
-                if (isRequestAborted(cause, options.signal)) {
+                if (isRequestAborted(cause, abortSignal)) {
                     throw requestAbortedError(cause);
                 }
                 throw cause;
             }
         },
-        async list({ cursor, limit, signal } = {}) {
-            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills`, { signal, query: { cursor, limit } }, skillsListResponseSchema);
+        async list({ cursor, limit, abortSignal } = {}) {
+            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills`, { signal: abortSignal, query: { cursor, limit } }, skillsListResponseSchema);
         },
-        async putFile({ content, ...input }) {
+        async putFile({ content, abortSignal, ...input }) {
             return await requestJson(config, fileUrl(agentId, input), {
                 body: content,
                 method: "PUT",
+                signal: abortSignal,
             }, skillDetailSchema);
         },
-        async upload({ source }) {
+        async upload({ source, abortSignal }) {
             const form = new FormData();
             form.set("type", source.type);
             const file = source.file instanceof Blob
                 ? source.file
                 : new Blob([source.file]);
             form.set("file", file, `skill.${source.type}`);
-            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/upload`, { body: form, method: "POST" }, skillDetailSchema);
+            return await requestJson(config, `/v1/agents/${encodeURIComponent(agentId)}/skills/upload`, { body: form, method: "POST", signal: abortSignal }, skillDetailSchema);
         },
     };
 }