@blazingagents/sdk 0.2.2 → 0.3.0

package/dist/resources/tasks.js

@@ -7,15 +7,16 @@ import { requestJson } from "../http.js";
  */
 export function createTasksResource(config) {
     return {
-        async create(body) {
+        async create({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/tasks", {
                 json: body,
+                signal: abortSignal,
                 method: "POST",
             }, createTaskResponseSchema);
         },
         async list(options = {}) {
             return await requestJson(config, "/v1/tasks", {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: {
                     agentId: options.agentId,
                     cursor: options.cursor,
@@ -25,35 +26,37 @@ export function createTasksResource(config) {
                 },
             }, tasksListResponseSchema);
         },
-        async get(taskId, options = {}) {
-            return await requestJson(config, `/v1/tasks/${taskId}`, options, taskResponseSchema);
+        async get({ taskId, abortSignal }) {
+            return await requestJson(config, `/v1/tasks/${taskId}`, { signal: abortSignal }, taskResponseSchema);
         },
-        async update(taskId, body) {
+        async update({ taskId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/tasks/${taskId}`, {
                 json: body,
+                signal: abortSignal,
                 method: "PATCH",
             }, taskResponseSchema);
         },
-        async delete(taskId) {
+        async delete({ taskId, abortSignal }) {
             await requestJson(config, `/v1/tasks/${taskId}`, {
                 method: "DELETE",
+                signal: abortSignal,
             });
         },
-        async createRun(taskId, body = {}) {
-            return await requestJson(config, `/v1/tasks/${taskId}/runs`, { json: body, method: "POST" }, createTaskRunResponseSchema);
+        async createRun({ taskId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/tasks/${taskId}/runs`, { json: body, method: "POST", signal: abortSignal }, createTaskRunResponseSchema);
         },
-        async listRuns(taskId, options = {}) {
+        async listRuns({ taskId, ...options }) {
             return await requestJson(config, `/v1/tasks/${taskId}/runs`, {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: { cursor: options.cursor, limit: options.limit },
             }, taskRunsListResponseSchema);
         },
-        async getRun(taskId, runId, options = {}) {
-            return await requestJson(config, `/v1/tasks/${taskId}/runs/${runId}`, options, taskRunResponseSchema);
+        async getRun({ taskId, runId, abortSignal }) {
+            return await requestJson(config, `/v1/tasks/${taskId}/runs/${runId}`, { signal: abortSignal }, taskRunResponseSchema);
         },
-        async runMessages(taskId, runId, options = {}) {
+        async runMessages({ taskId, runId, ...options }) {
             return await requestJson(config, `/v1/tasks/${taskId}/runs/${runId}/messages`, {
-                signal: options.signal,
+                signal: options.abortSignal,
                 query: {
                     cursor: options.cursor,
                     after: options.after,
@@ -61,8 +64,8 @@ export function createTasksResource(config) {
                 },
             }, taskRunMessagesResponseSchema);
         },
-        async cancelRun(taskId, runId) {
-            await requestJson(config, `/v1/tasks/${taskId}/runs/${runId}/cancel`, { method: "POST" });
+        async cancelRun({ taskId, runId, abortSignal }) {
+            await requestJson(config, `/v1/tasks/${taskId}/runs/${runId}/cancel`, { method: "POST", signal: abortSignal });
         },
     };
 }

package/dist/resources/tenant.js

@@ -6,12 +6,13 @@ import { requestJson } from "../http.js";
  */
 export function createTenantResource(config) {
     return {
-        async get(options = {}) {
-            return await requestJson(config, "/v1/tenant", options, tenantSettingsResponseSchema);
+        async get({ abortSignal } = {}) {
+            return await requestJson(config, "/v1/tenant", { signal: abortSignal }, tenantSettingsResponseSchema);
         },
-        async patch(body) {
+        async patch({ abortSignal, ...body }) {
             return await requestJson(config, "/v1/tenant", {
                 json: body,
+                signal: abortSignal,
                 method: "PATCH",
             }, tenantSettingsResponseSchema);
         },

package/dist/resources/usage.js

@@ -7,14 +7,14 @@ import { requestJson } from "../http.js";
  */
 export function createUsageResource(config) {
     return {
-        async get({ signal, ...query } = {}) {
+        async get({ abortSignal, ...query } = {}) {
             return await requestJson(config, "/v1/usage", {
                 query,
-                signal,
+                signal: abortSignal,
             }, usageResponseSchema);
         },
-        async getForAgent(agentId, { signal, ...query } = {}) {
-            return await requestJson(config, `/v1/agents/${agentId}/usage`, { query, signal }, usageResponseSchema);
+        async getForAgent({ agentId, abortSignal, ...query }) {
+            return await requestJson(config, `/v1/agents/${agentId}/usage`, { query, signal: abortSignal }, usageResponseSchema);
         },
     };
 }

package/dist/resources/workspaces.js

@@ -2,22 +2,23 @@ import { workspaceSchema, workspacesListResponseSchema, } from "../contracts/ent
 import { requestJson, requestStream } from "../http.js";
 export function createWorkspacesResource(config) {
     return {
-        async create(body = {}) {
+        async create({ abortSignal, ...body } = {}) {
             return await requestJson(config, "/v1/workspaces", {
                 json: body,
+                signal: abortSignal,
                 method: "POST",
             }, workspaceSchema);
         },
-        async delete({ workspaceId }) {
-            const response = await requestStream(config, `/v1/workspaces/${encodeURIComponent(workspaceId)}`, { method: "DELETE" });
+        async delete({ workspaceId, abortSignal }) {
+            const response = await requestStream(config, `/v1/workspaces/${encodeURIComponent(workspaceId)}`, { method: "DELETE", signal: abortSignal });
             return response.status === 202 ? "pending" : "completed";
         },
-        async get({ workspaceId }, options = {}) {
-            return await requestJson(config, `/v1/workspaces/${encodeURIComponent(workspaceId)}`, options, workspaceSchema);
+        async get({ workspaceId, abortSignal }) {
+            return await requestJson(config, `/v1/workspaces/${encodeURIComponent(workspaceId)}`, { signal: abortSignal }, workspaceSchema);
         },
-        async list(options = {}) {
+        async list({ abortSignal, ...options } = {}) {
             return await requestJson(config, "/v1/workspaces", {
-                signal: options.signal,
+                signal: abortSignal,
                 query: {
                     cursor: options.cursor,
                     limit: options.limit,
@@ -25,8 +26,8 @@ export function createWorkspacesResource(config) {
                 },
             }, workspacesListResponseSchema);
         },
-        async update({ workspaceId, ...body }) {
-            return await requestJson(config, `/v1/workspaces/${encodeURIComponent(workspaceId)}`, { json: body, method: "PUT" }, workspaceSchema);
+        async update({ workspaceId, abortSignal, ...body }) {
+            return await requestJson(config, `/v1/workspaces/${encodeURIComponent(workspaceId)}`, { json: body, signal: abortSignal, method: "PUT" }, workspaceSchema);
         },
     };
 }

package/dist/types.d.ts

@@ -99,19 +99,19 @@ interface ExistingSessionInput {
 }
 type ChatSessionInput = NewSessionInput | ExistingSessionInput;
 interface ChatMessageContentInput extends AttributionInput, CorrelatedRequestInput {
+    abortSignal?: AbortSignal;
     agentId: string;
     message: UIMessage;
     messageId?: string;
     promptId?: never;
-    signal?: AbortSignal;
     variables?: never;
 }
 interface ChatPromptContentInput extends AttributionInput, CorrelatedRequestInput {
+    abortSignal?: AbortSignal;
     agentId: string;
     message?: never;
     messageId?: string;
     promptId: string;
-    signal?: AbortSignal;
     variables?: Record<string, string>;
 }
 export type ChatMessageInput = ChatMessageContentInput & ChatSessionInput;
@@ -140,19 +140,19 @@ interface StatelessGenerationInput extends AttributionInput, CorrelatedRequestIn
     version?: number;
 }
 export interface CompletionPromptInput extends StatelessGenerationInput {
+    abortSignal?: AbortSignal;
     agentId: string;
     prompt: string;
     promptId?: never;
     schema?: never;
-    signal?: AbortSignal;
     variables?: never;
 }
 export interface CompletionPromptIdInput extends StatelessGenerationInput {
+    abortSignal?: AbortSignal;
     agentId: string;
     prompt?: never;
     promptId: string;
     schema?: never;
-    signal?: AbortSignal;
     variables?: Record<string, string>;
 }
 export type CompletionInput = CompletionPromptInput | CompletionPromptIdInput;
@@ -163,19 +163,19 @@ export interface CompletionResult {
     toResponse: () => Response;
 }
 export interface ObjectPromptInput extends StatelessGenerationInput {
+    abortSignal?: AbortSignal;
     agentId: string;
     prompt: string;
     promptId?: never;
     schema: Record<string, unknown>;
-    signal?: AbortSignal;
     variables?: never;
 }
 export interface ObjectPromptIdInput extends StatelessGenerationInput {
+    abortSignal?: AbortSignal;
     agentId: string;
     prompt?: never;
     promptId: string;
     schema: Record<string, unknown>;
-    signal?: AbortSignal;
     variables?: Record<string, string>;
 }
 export type ObjectInput = ObjectPromptInput | ObjectPromptIdInput;
@@ -185,130 +185,224 @@ export interface ObjectResult {
     requestId?: string;
     toResponse: () => Response;
 }
-export type ResourceReadOptions = Pick<RequestOptions, "signal">;
+export interface ResourceRequestOptions {
+    abortSignal?: AbortSignal;
+}
 export interface AgentsResource {
     /** Omitting `workspaceId` attaches a default Workspace with a lazy runtime. */
-    create(body: CreateAgentBody): Promise<Agent>;
+    create(input: CreateAgentBody & ResourceRequestOptions): Promise<Agent>;
     /** Deletes the Agent while preserving its attached Workspace. */
-    delete(agentId: string, includeArtifacts: boolean): Promise<void>;
-    disable(agentId: string): Promise<Agent>;
-    enable(agentId: string): Promise<Agent>;
-    get(agentId: string, options?: ResourceReadOptions): Promise<Agent>;
-    getVersion(agentId: string, version: number, options?: ResourceReadOptions): Promise<AgentVersion>;
-    list(options?: AgentsListOptions): Promise<AgentsResponse>;
-    listMcpAttachments(agentId: string, options?: ResourceReadOptions): Promise<McpAttachmentsResponse>;
-    listVersions(agentId: string, options?: AgentVersionsListOptions): Promise<AgentVersionsResponse>;
-    removeAvatar(agentId: string): Promise<Agent>;
-    /**
-     * Copies an immutable Version's configuration into the Agent through the
-     * ordinary update path, creating a new latest Version without rewriting history.
-     */
-    restoreVersion(agentId: string, version: number): Promise<Agent>;
+    delete(input: {
+        agentId: string;
+        includeArtifacts: boolean;
+    } & ResourceRequestOptions): Promise<void>;
+    disable(input: {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<Agent>;
+    enable(input: {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<Agent>;
+    get(input: {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<Agent>;
+    getVersion(input: {
+        agentId: string;
+        version: number;
+    } & ResourceRequestOptions): Promise<AgentVersion>;
+    list(input?: AgentsListOptions): Promise<AgentsResponse>;
+    listMcpAttachments(input: {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<McpAttachmentsResponse>;
+    listVersions(input: {
+        agentId: string;
+    } & AgentVersionsListOptions): Promise<AgentVersionsResponse>;
+    removeAvatar(input: {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<Agent>;
+    /** Copies an immutable Version into the Agent, creating a new latest Version. */
+    restoreVersion(input: {
+        agentId: string;
+        version: number;
+    } & ResourceRequestOptions): Promise<Agent>;
     /** A concrete `workspaceId` switches the Agent; detachment is unsupported. */
-    update(agentId: string, body: UpdateAgentBody): Promise<Agent>;
-    updateMcpAttachment(agentId: string, mcpConnectionId: string, body: UpdateMcpAttachmentBody): Promise<McpAttachmentResponse>;
-    uploadAvatar(agentId: string, file: File): Promise<Agent>;
+    update(input: UpdateAgentBody & {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<Agent>;
+    updateMcpAttachment(input: UpdateMcpAttachmentBody & {
+        agentId: string;
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<McpAttachmentResponse>;
+    uploadAvatar(input: {
+        agentId: string;
+        file: File;
+    } & ResourceRequestOptions): Promise<Agent>;
 }
 export interface AgentClient {
     readonly skills: AgentSkillsResource;
 }
-export interface AgentsListOptions extends ResourceReadOptions {
+export interface AgentsListOptions extends ResourceRequestOptions {
     userId?: string;
     workspaceId?: string;
 }
 export interface WorkspacesResource {
-    create(body?: CreateWorkspaceBody): Promise<Workspace>;
+    create(input?: CreateWorkspaceBody & ResourceRequestOptions): Promise<Workspace>;
     delete(input: {
         workspaceId: string;
-    }): Promise<"completed" | "pending">;
+    } & ResourceRequestOptions): Promise<"completed" | "pending">;
     get(input: {
         workspaceId: string;
-    }, options?: ResourceReadOptions): Promise<Workspace>;
-    list(options?: WorkspacesListOptions): Promise<WorkspacesListResponse>;
+    } & ResourceRequestOptions): Promise<Workspace>;
+    list(input?: WorkspacesListOptions): Promise<WorkspacesListResponse>;
     update(input: UpdateWorkspaceBody & {
         workspaceId: string;
-    }): Promise<Workspace>;
+    } & ResourceRequestOptions): Promise<Workspace>;
 }
-export interface WorkspacesListOptions extends ResourceReadOptions {
+export interface WorkspacesListOptions extends ResourceRequestOptions {
     cursor?: string;
     limit?: number;
     userId?: string;
 }
-export interface AgentVersionsListOptions extends ResourceReadOptions {
+export interface AgentVersionsListOptions extends ResourceRequestOptions {
     cursor?: string;
     limit?: number;
 }
-export interface ArtifactsListOptions extends ResourceReadOptions {
+export interface ArtifactsListOptions extends ResourceRequestOptions {
     agentId?: string;
     cursor?: string;
     sessionId?: string;
 }
 export interface ArtifactsResource {
-    createDownloadUrl(artifactId: string): Promise<ArtifactDownloadUrlResponse>;
-    delete(artifactId: string): Promise<void>;
-    get(artifactId: string, options?: ResourceReadOptions): Promise<ArtifactListItem>;
-    list(options?: ArtifactsListOptions): Promise<ArtifactsListResponse>;
+    createDownloadUrl(input: {
+        artifactId: string;
+    } & ResourceRequestOptions): Promise<ArtifactDownloadUrlResponse>;
+    delete(input: {
+        artifactId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    get(input: {
+        artifactId: string;
+    } & ResourceRequestOptions): Promise<ArtifactListItem>;
+    list(input?: ArtifactsListOptions): Promise<ArtifactsListResponse>;
 }
 export interface MemoriesResource {
-    create(agentId: string, body: CreateMemoryBody): Promise<MemoryResponse>;
-    delete(agentId: string, memoryId: string): Promise<void>;
-    get(agentId: string, memoryId: string, options?: ResourceReadOptions): Promise<MemoryResponse>;
-    list(agentId: string, options?: MemoriesListOptions): Promise<MemoriesListResponse>;
-    update(agentId: string, memoryId: string, body: UpdateMemoryBody): Promise<MemoryResponse>;
-}
-export interface MemoriesListOptions extends ResourceReadOptions {
+    create(input: CreateMemoryBody & {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<MemoryResponse>;
+    delete(input: {
+        agentId: string;
+        memoryId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    get(input: {
+        agentId: string;
+        memoryId: string;
+    } & ResourceRequestOptions): Promise<MemoryResponse>;
+    list(input: {
+        agentId: string;
+    } & MemoriesListOptions): Promise<MemoriesListResponse>;
+    update(input: UpdateMemoryBody & {
+        agentId: string;
+        memoryId: string;
+    } & ResourceRequestOptions): Promise<MemoryResponse>;
+}
+export interface MemoriesListOptions extends ResourceRequestOptions {
     cursor?: string;
     limit?: number;
     search?: string;
     userId?: string;
 }
 export interface PromptsResource {
-    create(body: CreatePromptBody): Promise<PromptResponse>;
-    delete(promptId: string): Promise<void>;
-    get(promptId: string, options?: ResourceReadOptions): Promise<PromptResponse>;
-    list(userId?: string, options?: ResourceReadOptions): Promise<PromptsResponse>;
-    update(promptId: string, body: UpdatePromptBody): Promise<PromptResponse>;
+    create(input: CreatePromptBody & ResourceRequestOptions): Promise<PromptResponse>;
+    delete(input: {
+        promptId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    get(input: {
+        promptId: string;
+    } & ResourceRequestOptions): Promise<PromptResponse>;
+    list(input?: {
+        userId?: string;
+    } & ResourceRequestOptions): Promise<PromptsResponse>;
+    update(input: UpdatePromptBody & {
+        promptId: string;
+    } & ResourceRequestOptions): Promise<PromptResponse>;
 }
 export interface ProvidersResource {
-    create(body: CreateProviderBody): Promise<ProviderResponse>;
-    delete(id: string, options?: DeleteProviderOptions): Promise<void>;
-    get(id: string, options?: ResourceReadOptions): Promise<ProviderResponse>;
-    getThinkingLevels(id: string, model: string, options?: ResourceReadOptions): Promise<ThinkingLevelsResponse>;
-    list(options?: ResourceReadOptions): Promise<ProvidersResponse>;
-    listModels(id: string, options?: ResourceReadOptions): Promise<ProviderModelsResponse>;
-    update(id: string, body: UpdateProviderBody): Promise<ProviderResponse>;
+    create(input: CreateProviderBody & ResourceRequestOptions): Promise<ProviderResponse>;
+    delete(input: DeleteProviderOptions & {
+        providerId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    get(input: {
+        providerId: string;
+    } & ResourceRequestOptions): Promise<ProviderResponse>;
+    getThinkingLevels(input: {
+        providerId: string;
+        model: string;
+    } & ResourceRequestOptions): Promise<ThinkingLevelsResponse>;
+    list(input?: ResourceRequestOptions): Promise<ProvidersResponse>;
+    listModels(input: {
+        providerId: string;
+    } & ResourceRequestOptions): Promise<ProviderModelsResponse>;
+    update(input: UpdateProviderBody & {
+        providerId: string;
+    } & ResourceRequestOptions): Promise<ProviderResponse>;
 }
 export interface McpConnectionsResource {
-    connect(id: string): Promise<McpConnectionOauthConnectResponse>;
-    create(body: CreateMcpConnectionBody): Promise<McpConnectionResponse>;
-    delete(id: string): Promise<void>;
-    get(id: string, options?: ResourceReadOptions): Promise<McpConnectionResponse>;
-    list(options?: ResourceReadOptions): Promise<McpConnectionsResponse>;
-    reconnect(id: string, body: ReconnectMcpConnectionBody): Promise<McpConnectionReconnectResult>;
-    test(id: string): Promise<McpConnectionTestResponse>;
-    update(id: string, body: UpdateMcpConnectionBody): Promise<McpConnectionResponse>;
-}
-export interface SessionsListOptions extends ResourceReadOptions {
+    connect(input: {
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<McpConnectionOauthConnectResponse>;
+    create(input: CreateMcpConnectionBody & ResourceRequestOptions): Promise<McpConnectionResponse>;
+    delete(input: {
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    get(input: {
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<McpConnectionResponse>;
+    list(input?: ResourceRequestOptions): Promise<McpConnectionsResponse>;
+    reconnect(input: ReconnectMcpConnectionBody & {
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<McpConnectionReconnectResult>;
+    test(input: {
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<McpConnectionTestResponse>;
+    update(input: UpdateMcpConnectionBody & {
+        mcpConnectionId: string;
+    } & ResourceRequestOptions): Promise<McpConnectionResponse>;
+}
+export interface SessionsListOptions extends ResourceRequestOptions {
     cursor?: string;
     limit?: number;
     userId?: string;
 }
-export interface SessionMessagesOptions extends ResourceReadOptions {
+export interface SessionMessagesOptions extends ResourceRequestOptions {
     after?: string;
     cursor?: string;
     limit?: number;
 }
 export interface SessionsResource {
-    decideToolApproval(agentId: string, sessionId: string, approvalId: string, decision: DecideToolApprovalBody, options?: {
-        signal?: AbortSignal;
-    }): Promise<ToolApprovalDecisionResponse>;
-    delete(agentId: string, sessionId: string, deleteArtifacts: boolean): Promise<void>;
-    joinToolApprovalContinuation(agentId: string, sessionId: string, continuationId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<TerminalStreamResult>;
-    list(agentId: string, options?: SessionsListOptions): Promise<SessionsListResponse>;
-    messages(agentId: string, sessionId: string, options?: SessionMessagesOptions): Promise<SessionMessagesResponse>;
-    toolApprovals(agentId: string, sessionId: string, options?: ResourceReadOptions): Promise<ToolApprovalsResponse>;
+    decideToolApproval(input: DecideToolApprovalBody & {
+        agentId: string;
+        sessionId: string;
+        approvalId: string;
+    } & ResourceRequestOptions): Promise<ToolApprovalDecisionResponse>;
+    delete(input: {
+        agentId: string;
+        sessionId: string;
+        deleteArtifacts: boolean;
+    } & ResourceRequestOptions): Promise<void>;
+    joinToolApprovalContinuation(input: {
+        agentId: string;
+        sessionId: string;
+        continuationId: string;
+    } & ResourceRequestOptions): Promise<TerminalStreamResult>;
+    list(input: {
+        agentId: string;
+    } & SessionsListOptions): Promise<SessionsListResponse>;
+    messages(input: {
+        agentId: string;
+        sessionId: string;
+    } & SessionMessagesOptions): Promise<SessionMessagesResponse>;
+    toolApprovals(input: {
+        agentId: string;
+        sessionId: string;
+    } & ResourceRequestOptions): Promise<ToolApprovalsResponse>;
 }
 export interface AgentSkillsResource {
     copy(input: {
@@ -316,72 +410,93 @@ export interface AgentSkillsResource {
         to: {
             agentIds: string[];
         };
-    }): Promise<SkillCopyResults>;
-    create(input: CreateSkillBody): Promise<SkillDetail>;
+    } & ResourceRequestOptions): Promise<SkillCopyResults>;
+    create(input: CreateSkillBody & ResourceRequestOptions): Promise<SkillDetail>;
     delete(input: {
         skillId: string;
-    }): Promise<void>;
+    } & ResourceRequestOptions): Promise<void>;
     deleteFile(input: {
         path: string;
         skillId: string;
-    }): Promise<SkillDetail>;
+    } & ResourceRequestOptions): Promise<SkillDetail>;
     get(input: {
         skillId: string;
-    }, options?: ResourceReadOptions): Promise<SkillDetail>;
+    } & ResourceRequestOptions): Promise<SkillDetail>;
     getFile(input: {
         path: string;
         skillId: string;
-    }, options?: ResourceReadOptions): Promise<Uint8Array>;
-    list(options?: SkillsListOptions): Promise<SkillsListResponse>;
+    } & ResourceRequestOptions): Promise<Uint8Array>;
+    list(input?: SkillsListOptions): Promise<SkillsListResponse>;
     putFile(input: {
         content: Blob | string | Uint8Array;
         path: string;
         skillId: string;
-    }): Promise<SkillDetail>;
+    } & ResourceRequestOptions): Promise<SkillDetail>;
     upload(input: {
         source: {
             file: Blob | Uint8Array;
             type: SkillArchiveType;
         };
-    }): Promise<SkillDetail>;
+    } & ResourceRequestOptions): Promise<SkillDetail>;
 }
-export interface SkillsListOptions extends ResourceReadOptions {
+export interface SkillsListOptions extends ResourceRequestOptions {
     cursor?: string;
     limit?: number;
 }
-export interface TasksListOptions extends ResourceReadOptions {
+export interface TasksListOptions extends ResourceRequestOptions {
     agentId?: string;
     cursor?: string;
     limit?: number;
     userId?: string;
 }
-export interface TaskRunsListOptions extends ResourceReadOptions {
+export interface TaskRunsListOptions extends ResourceRequestOptions {
     cursor?: string;
     limit?: number;
 }
-export interface TaskRunMessagesOptions extends ResourceReadOptions {
+export interface TaskRunMessagesOptions extends ResourceRequestOptions {
     after?: string;
     cursor?: string;
     limit?: number;
 }
 export interface TasksResource {
-    cancelRun(taskId: string, runId: string): Promise<void>;
-    create(body: CreateTaskBody): Promise<CreateTaskResponse>;
-    createRun(taskId: string, body?: CreateTaskRunBody): Promise<CreateTaskRunResponse>;
-    delete(taskId: string): Promise<void>;
-    get(taskId: string, options?: ResourceReadOptions): Promise<TaskResponse>;
-    getRun(taskId: string, runId: string, options?: ResourceReadOptions): Promise<TaskRunResponse>;
-    list(options?: TasksListOptions): Promise<TasksListResponse>;
-    listRuns(taskId: string, options?: TaskRunsListOptions): Promise<TaskRunsListResponse>;
-    runMessages(taskId: string, runId: string, options?: TaskRunMessagesOptions): Promise<TaskRunMessagesResponse>;
-    update(taskId: string, body: UpdateTaskBody): Promise<TaskResponse>;
+    cancelRun(input: {
+        taskId: string;
+        runId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    create(input: CreateTaskBody & ResourceRequestOptions): Promise<CreateTaskResponse>;
+    createRun(input: CreateTaskRunBody & {
+        taskId: string;
+    } & ResourceRequestOptions): Promise<CreateTaskRunResponse>;
+    delete(input: {
+        taskId: string;
+    } & ResourceRequestOptions): Promise<void>;
+    get(input: {
+        taskId: string;
+    } & ResourceRequestOptions): Promise<TaskResponse>;
+    getRun(input: {
+        taskId: string;
+        runId: string;
+    } & ResourceRequestOptions): Promise<TaskRunResponse>;
+    list(input?: TasksListOptions): Promise<TasksListResponse>;
+    listRuns(input: {
+        taskId: string;
+    } & TaskRunsListOptions): Promise<TaskRunsListResponse>;
+    runMessages(input: {
+        taskId: string;
+        runId: string;
+    } & TaskRunMessagesOptions): Promise<TaskRunMessagesResponse>;
+    update(input: UpdateTaskBody & {
+        taskId: string;
+    } & ResourceRequestOptions): Promise<TaskResponse>;
 }
 export interface TenantResource {
-    get(options?: ResourceReadOptions): Promise<TenantSettingsResponse>;
-    patch(body: UpdateTenantSettingsBody): Promise<TenantSettingsResponse>;
+    get(input?: ResourceRequestOptions): Promise<TenantSettingsResponse>;
+    patch(input: UpdateTenantSettingsBody & ResourceRequestOptions): Promise<TenantSettingsResponse>;
 }
 export interface UsageResource {
-    get(query?: Partial<UsageQuery> & ResourceReadOptions): Promise<UsageResponse>;
-    getForAgent(agentId: string, query?: Partial<UsageQuery> & ResourceReadOptions): Promise<UsageResponse>;
+    get(input?: Partial<UsageQuery> & ResourceRequestOptions): Promise<UsageResponse>;
+    getForAgent(input: Partial<UsageQuery> & {
+        agentId: string;
+    } & ResourceRequestOptions): Promise<UsageResponse>;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blazingagents/sdk",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "TypeScript SDK for the Blazing Agents API",
   "homepage": "https://docs.blazingagents.com",
   "bugs": {