@blazingagents/sdk 0.2.1 → 0.3.0

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

@@ -61,13 +61,13 @@ export declare const usageBucketSchema: z.ZodObject<{
     outputTokens: z.ZodNumber;
     requestCount: z.ZodNumber;
     durationMs: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export declare const usageTotalsSchema: z.ZodObject<{
     inputTokens: z.ZodNumber;
     outputTokens: z.ZodNumber;
     requestCount: z.ZodNumber;
     durationMs: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export declare const usageResponseSchema: z.ZodObject<{
     buckets: z.ZodArray<z.ZodObject<{
         day: z.ZodNullable<z.ZodString>;
@@ -80,14 +80,14 @@ export declare const usageResponseSchema: z.ZodObject<{
         outputTokens: z.ZodNumber;
         requestCount: z.ZodNumber;
         durationMs: z.ZodNumber;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     totals: z.ZodObject<{
         inputTokens: z.ZodNumber;
         outputTokens: z.ZodNumber;
         requestCount: z.ZodNumber;
         durationMs: z.ZodNumber;
-    }, z.core.$strict>;
-}, z.core.$strict>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export type UsageGroupBy = z.infer<typeof usageGroupBySchema>;
 export type UsageQuery = z.infer<typeof usageQuerySchema>;
 export type UsageBucket = z.infer<typeof usageBucketSchema>;

package/dist/contracts/entities/usage.js

@@ -100,7 +100,7 @@ export const usageBucketSchema = z
     requestCount: z.number().int().nonnegative(),
     durationMs: z.number().int().nonnegative(),
 })
-    .strict();
+    .strip();
 export const usageTotalsSchema = z
     .object({
     inputTokens: z.number().int().nonnegative(),
@@ -108,10 +108,10 @@ export const usageTotalsSchema = z
     requestCount: z.number().int().nonnegative(),
     durationMs: z.number().int().nonnegative(),
 })
-    .strict();
+    .strip();
 export const usageResponseSchema = z
     .object({
     buckets: z.array(usageBucketSchema),
     totals: usageTotalsSchema,
 })
-    .strict();
+    .strip();

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

@@ -21,15 +21,15 @@ export declare const workspaceSchema: z.ZodObject<{
     metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     networkPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"unrestricted">;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         allowedHosts: z.ZodArray<z.ZodString>;
         mode: z.ZodLiteral<"allowlist">;
-    }, z.core.$strict>, z.ZodObject<{
+    }, z.core.$strip>, z.ZodObject<{
         mode: z.ZodLiteral<"offline">;
-    }, z.core.$strict>], "mode">;
+    }, z.core.$strip>], "mode">;
     createdAt: z.ZodISODateTime;
     updatedAt: z.ZodISODateTime;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export declare const createWorkspaceBodySchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     userId: z.ZodDefault<z.ZodString>;
@@ -69,17 +69,17 @@ export declare const workspacesListResponseSchema: z.ZodObject<{
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         networkPolicy: z.ZodDiscriminatedUnion<[z.ZodObject<{
             mode: z.ZodLiteral<"unrestricted">;
-        }, z.core.$strict>, z.ZodObject<{
+        }, z.core.$strip>, z.ZodObject<{
             allowedHosts: z.ZodArray<z.ZodString>;
             mode: z.ZodLiteral<"allowlist">;
-        }, z.core.$strict>, z.ZodObject<{
+        }, z.core.$strip>, z.ZodObject<{
             mode: z.ZodLiteral<"offline">;
-        }, z.core.$strict>], "mode">;
+        }, z.core.$strip>], "mode">;
         createdAt: z.ZodISODateTime;
         updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
+    }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
+}, z.core.$strip>;
 export type Workspace = z.infer<typeof workspaceSchema>;
 export type WorkspaceBackup = z.infer<typeof workspaceBackupSchema>;
 export type WorkspaceNetworkPolicy = z.infer<typeof workspaceNetworkPolicySchema>;

package/dist/contracts/entities/workspaces.js

@@ -26,6 +26,11 @@ export const workspaceNetworkPolicySchema = z.discriminatedUnion("mode", [
         .strict(),
     z.object({ mode: z.literal("offline") }).strict(),
 ]);
+const workspaceNetworkPolicyResponseSchema = z.discriminatedUnion("mode", [
+    workspaceNetworkPolicySchema.options[0].strip(),
+    workspaceNetworkPolicySchema.options[1].strip(),
+    workspaceNetworkPolicySchema.options[2].strip(),
+]);
 export const workspaceSchema = z
     .object({
     id: workspaceIdSchema,
@@ -33,11 +38,11 @@ export const workspaceSchema = z
     name: workspaceNameSchema.nullable(),
     userId: userIdSchema,
     metadata: metadataSchema,
-    networkPolicy: workspaceNetworkPolicySchema,
+    networkPolicy: workspaceNetworkPolicyResponseSchema,
     createdAt: z.iso.datetime({ offset: true }),
     updatedAt: z.iso.datetime({ offset: true }),
 })
-    .strict();
+    .strip();
 export const createWorkspaceBodySchema = z
     .object({
     name: workspaceNameSchema.optional(),

package/dist/contracts/index.d.ts

@@ -8,7 +8,7 @@ export { blazingAgentsChatMessageMetadataSchema, chatModeSchema, chatRequestBody
 export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.ts";
 export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchema, memorySchema, updateMemoryBodySchema, } from "./entities/memories.ts";
 export { createPromptBodySchema, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.ts";
-export { createProviderBodySchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, updateProviderBodySchema, } from "./entities/providers.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 { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";

package/dist/contracts/index.js

@@ -8,7 +8,7 @@ export { blazingAgentsChatMessageMetadataSchema, chatModeSchema, chatRequestBody
 export { approveMcpOauthAuthorizationBodySchema, createMcpConnectionBodySchema, mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, mcpConnectionAuthTypeSchema, mcpConnectionOauthConnectResponseSchema, mcpConnectionReconnectResultSchema, mcpConnectionResponseSchema, mcpConnectionStatusSchema, mcpConnectionsResponseSchema, mcpConnectionTestErrorCodeSchema, mcpConnectionTestResponseSchema, mcpOauthAuthorizationLaunchResponseSchema, reconnectMcpConnectionBodySchema, updateMcpAttachmentBodySchema, updateMcpConnectionBodySchema, } from "./entities/mcp-connections.js";
 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, updateProviderBodySchema, } from "./entities/providers.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 { 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";

package/dist/direct-chat-transport.d.ts

@@ -0,0 +1,16 @@
+import { type ChatTransport, DefaultChatTransport, type UIMessage } from "ai";
+import type { BlazingAgents } from "./client.ts";
+export interface BlazingAgentsDirectChatTransportOptions {
+    agentId: string;
+    client: BlazingAgents;
+    /** Receives the Session ID before the response stream is consumed. */
+    onSessionId?: (sessionId: string) => Promise<void> | void;
+    sessionId?: string;
+}
+/** Connects useChat directly to the SDK, including native streaming fetch clients. */
+export declare class BlazingAgentsDirectChatTransport<UI_MESSAGE extends UIMessage = UIMessage> extends DefaultChatTransport<UI_MESSAGE> {
+    #private;
+    constructor(options: BlazingAgentsDirectChatTransportOptions);
+    sendMessages(input: Parameters<ChatTransport<UI_MESSAGE>["sendMessages"]>[0]): Promise<ReadableStream<import("ai").UIMessageChunk<unknown, import("ai").UIDataTypes>>>;
+    reconnectToStream(_input: Parameters<ChatTransport<UI_MESSAGE>["reconnectToStream"]>[0]): Promise<null>;
+}

package/dist/direct-chat-transport.js

@@ -0,0 +1,49 @@
+import { DefaultChatTransport } from "ai";
+import { sessionIdSchema } from "./contracts/ids.js";
+/** Connects useChat directly to the SDK, including native streaming fetch clients. */
+export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
+    #options;
+    #sessionId;
+    constructor(options) {
+        super();
+        this.#options = options;
+        this.#sessionId =
+            options.sessionId === undefined
+                ? undefined
+                : sessionIdSchema.parse(options.sessionId);
+    }
+    async sendMessages(input) {
+        if (input.trigger === "regenerate-message" && !this.#sessionId) {
+            throw new Error("Regeneration requires an existing Session.");
+        }
+        const message = input.messages.findLast((item) => item.role === "user");
+        if (!message) {
+            throw new Error("Chat submission requires a user message.");
+        }
+        const result = await this.#options.client.chat({
+            agentId: this.#options.agentId,
+            message,
+            messageId: input.messageId,
+            ...(this.#sessionId === undefined
+                ? { trigger: "submit-message" }
+                : { sessionId: this.#sessionId, trigger: input.trigger }),
+            abortSignal: input.abortSignal,
+        });
+        const stream = result.toStream();
+        try {
+            const sessionId = await result.sessionId;
+            if (this.#sessionId === undefined) {
+                this.#sessionId = sessionId;
+                await this.#options.onSessionId?.(sessionId);
+            }
+        }
+        catch (error) {
+            await stream.cancel(error).catch(() => undefined);
+            throw error;
+        }
+        return this.processResponseStream(stream);
+    }
+    reconnectToStream(_input) {
+        return Promise.resolve(null);
+    }
+}

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);
 }
@@ -131,6 +131,7 @@ export function buildTerminalStreamResult(response, resourceName) {
     };
     return {
         requestId,
+        toStream: claimBody,
         toResponse: () => {
             const headers = replacementResponseHeaders(requestId, location);
             headers.set("content-type", "text/event-stream");
@@ -266,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);
 }
@@ -305,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/http.d.ts

@@ -13,6 +13,8 @@ export declare function requestJson<T>(config: HttpConfig, path: string, options
  * Non-2xx bodies are decoded before a caller can observe a streaming body.
  */
 export declare function requestStream(config: HttpConfig, path: string, options?: RequestOptions): Promise<Response>;
+export declare function isRequestAborted(cause: unknown, signal?: AbortSignal): boolean;
+export declare function requestAbortedError(cause: unknown): BlazingAgentsError;
 /**
  * Decodes a response body with the tolerant consumer schema. Unknown future
  * codes and fields remain valid; malformed responses never infer a domain

package/dist/http.js

@@ -135,14 +135,14 @@ async function errorFromResponse(response, signal) {
     }
     return parseErrorEnvelope(read.diagnosticBody, response.status, headers);
 }
-function isRequestAborted(cause, signal) {
+export function isRequestAborted(cause, signal) {
     return (signal?.aborted === true ||
         (cause !== null &&
             typeof cause === "object" &&
             "name" in cause &&
             cause.name === "AbortError"));
 }
-function requestAbortedError(cause) {
+export function requestAbortedError(cause) {
     return new BlazingAgentsError({
         code: "request_aborted",
         message: cause instanceof Error ? cause.message : REQUEST_ABORTED_MESSAGE,

package/dist/index.d.ts

@@ -12,9 +12,10 @@ export { BlazingAgents } from "./client.ts";
 export type { Agent, AgentResponse, AgentsResponse, AgentVersion, AgentVersionsListQuery, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody, } from "./contracts/entities/agents.ts";
 export type { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse, } from "./contracts/entities/artifacts.ts";
 export type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionAuthType, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionStatus, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody, } from "./contracts/entities/mcp-connections.ts";
-export type { CreateProviderBody, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, UpdateProviderBody, } from "./contracts/entities/providers.ts";
+export type { CreateProviderBody, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, ThinkingLevelsResponse, UpdateProviderBody, } from "./contracts/entities/providers.ts";
 export type { CreateSkillBody, Skill, SkillArchiveType, SkillCopyResult, SkillCopyResults, SkillDetail, SkillFile, SkillsListResponse, } from "./contracts/entities/skills.ts";
 export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, } from "./contracts/entities/workspaces.ts";
+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, 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/index.js

@@ -9,5 +9,6 @@
 // biome-ignore lint/performance/noBarrelFile: package entry point
 export { BlazingAgentsChatTransport, } from "./chat-transport.js";
 export { BlazingAgents } from "./client.js";
+export { BlazingAgentsDirectChatTransport, } from "./direct-chat-transport.js";
 export { BlazingAgentsError } from "./errors.js";
 export { createChatRelay, createCompletionRelay, } from "./relay.js";

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,47 +8,60 @@ import { requestJson } from "../http.js";
  * core wire schemas (parse-on-read).
  */
 export function createAgentsResource(config) {
-    const getVersion = async (agentId, version) => requestJson(config, `/v1/agents/${agentId}/versions/${version}`, {}, 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.abortSignal,
                 query: {
                     userId: options.userId,
                     workspaceId: options.workspaceId,
                 },
             }, agentsResponseSchema);
         },
-        async get(agentId) {
-            return await requestJson(config, `/v1/agents/${agentId}`, {}, 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 = {}) {
-            return await requestJson(config, `/v1/agents/${agentId}/versions`, { query: { cursor: options.cursor, limit: options.limit } }, agentVersionsResponseSchema);
+        async listVersions({ agentId, ...options }) {
+            return await requestJson(config, `/v1/agents/${agentId}/versions`, {
+                signal: options.abortSignal,
+                query: { cursor: options.cursor, limit: options.limit },
+            }, agentVersionsResponseSchema);
         },
-        async listMcpAttachments(agentId) {
-            return await requestJson(config, `/v1/agents/${agentId}/mcp-attachments`, {}, 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,
                 providerId: version.providerId,
                 memoryInjectionEnabled: version.memoryInjectionEnabled,
                 tools: version.tools,
@@ -58,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,14 +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) {
-            return await requestJson(config, `/v1/artifacts/${artifactId}`, {}, 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: abortSignal,
                 query: {
                     agentId: options.agentId,
                     sessionId: options.sessionId,
@@ -20,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() {
-            return await requestJson(config, "/v1/mcp-connections", {}, mcpConnectionsResponseSchema);
+        async list({ abortSignal } = {}) {
+            return await requestJson(config, "/v1/mcp-connections", { signal: abortSignal }, mcpConnectionsResponseSchema);
         },
-        async get(id) {
-            return await requestJson(config, `/v1/mcp-connections/${id}`, {}, 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,8 +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: abortSignal,
                 query: {
                     ...(options.userId === undefined ? {} : { userId: options.userId }),
                     search: options.search,
@@ -17,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) {
-            return await requestJson(config, `/v1/agents/${agentId}/memories/${memoryId}`, {}, 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,30 +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) {
+        async list({ userId, abortSignal } = {}) {
             return await requestJson(config, "/v1/prompts", {
+                signal: abortSignal,
                 // Stryker disable next-line ConditionalExpression: URL serialization omits an undefined query value.
                 ...(userId === undefined ? {} : { query: { userId } }),
             }, promptsResponseSchema);
         },
-        async get(promptId) {
-            return await requestJson(config, `/v1/prompts/${promptId}`, {}, 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,
             });
         },
     };