@blazingagents/sdk 0.14.0 → 0.15.0

package/README.md

@@ -21,14 +21,17 @@ requires Node.js 24 or newer.
 - Public Zod contracts for validating API requests and responses.
 - Cursor pagination and binary transfers.
 - Request correlation and a typed, forward-compatible error model.
+- End-user scoped clients for user-owned resources and generation.
 
 ## Installation
 
 ```console
-npm install @blazingagents/sdk ai@7.0.84
+npm install @blazingagents/sdk ai@^7.0.84 zod@^4.5.4
 ```
 
-`ai` is a peer dependency. The SDK re-exports its `UIMessage` type.
+`ai` (`^7.0.84`) and `zod` (`^4.5.4`) are peer dependencies. The SDK
+re-exports AI SDK message types and Zod schemas, so consumers share these
+dependencies with the SDK.
 
 ## Quick start
 
@@ -70,232 +73,3 @@ npm run test:consumer
 ## License
 
 [MIT](LICENSE)
-
-### Thinking level
-
-Agent create/update accepts `thinkingLevel: "high"`, `"off"`, `"max"`, or
-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
-`{ known, levels }`. Unknown capabilities permit custom values that can still
-be rejected during execution. Levels control reasoning, not a token/cost cap.
-
-For native clients whose `Response` constructor does not support streaming bodies,
-use `result.toStream()` on chat or terminal continuation results to read the
-original SSE bytes. It shares one-shot ownership with `toResponse()`; choose one
-accessor per result. Stream errors and cancellation retain the same behavior.
-
-### Relay browser chat
-
-Tenant browser apps use `BlazingAgentsChatTransport` with their own backend.
-The backend holds the Tenant API key and authorizes each Session. The transport
-sends the newest user message and resumes with the server-minted Session ID.
-
-### Direct chat with the SDK
-
-For the platform dashboard or another runtime with an authorized credential,
-use `BlazingAgentsDirectChatTransport` with AI SDK `useChat`. It sends through
-`client.chat()` and decodes the stream without constructing a streaming
-`Response`. Inject a native streaming fetch implementation into `BlazingAgents`
-when the runtime requires one.
-
-```tsx
-import { useMemo } from "react";
-import { useChat } from "@ai-sdk/react";
-import { BlazingAgents, BlazingAgentsDirectChatTransport } from "@blazingagents/sdk";
-
-function Chat({ getCredential, agentId, initialSessionId, saveSessionId }) {
-  const transport = useMemo(
-    () => new BlazingAgentsDirectChatTransport({
-      getClient: async () => new BlazingAgents({ apiKey: await getCredential() }),
-      agentId,
-      sessionId: initialSessionId,
-      onSessionId: saveSessionId,
-    }),
-    [getCredential, agentId, initialSessionId, saveSessionId],
-  );
-  const chat = useChat({ transport });
-  // Render chat.messages and submit using chat.sendMessage({ text }).
-}
-```
-
-Install `@ai-sdk/react` for the React hook. Keep the transport stable for one
-Session; remount the chat with a new transport when switching Agents or
-Sessions. `getClient` runs before each request, so it can read a current
-dashboard credential. Return a `BlazingAgents` client with that credential.
-
-On Session creation, `version` pins the Agent Version, and `userId` and
-`metadata` set attribution. To invoke a stored Prompt, pass `promptId` and
-optional `variables` to the transport. Its first Turn sends those fields in
-place of the `useChat` user message. Later Turns send user messages and omit
-the create options, including `version`.
-
-`onSessionId` runs once for a newly created Session before stream consumption,
-so it can be saved even if streaming later fails. The transport preserves user
-message IDs, regeneration targets, and `useChat` cancellation. Regeneration
-requires an existing Session. When `useChat` submits tool approval responses,
-the transport sends each decision in order and streams the continuation. After
-reload, `reconnectToStream` joins a queued or running continuation for the
-supplied `sessionId`. It returns `null` when there is no active continuation.
-It does not retry an interrupted ordinary Turn.
-
-### Cancel requests
-
-Pass an optional `abortSignal` in the request object for reads, writes, uploads,
-and generation:
-
-```ts
-const controller = new AbortController();
-const agents = client.agents.list({ abortSignal: controller.signal });
-controller.abort();
-await agents; // Rejects with the SDK's typed cancellation error.
-```
-
-SDK response parsing strips unknown object fields while validating required
-fields and known field types. Request validation remains strict.
-
-### Migrating from 0.2.x to 0.3.0
-
-Resource and generation methods take a single request object, optional when no
-fields are required. Move positional identifiers, body fields, and request
-options into that object. Use `abortSignal` instead of
-`signal`; custom fetch implementations still receive the native `signal`.
-
-```ts
-// Before (0.2.x)
-client.agents.update(agentId, { name: "Builder" });
-client.sessions.messages(agentId, sessionId, { signal });
-client.agent(agentId).skills.list();
-
-// After (0.3.0)
-client.agents.update({ agentId, name: "Builder", abortSignal: signal });
-client.sessions.messages({ agentId, sessionId, abortSignal: signal });
-client.agent({ agentId }).skills.list({ abortSignal: signal });
-```
-
-`ResourceRequestOptions` replaces `ResourceReadOptions`. Cancellation stops the
-request; it does not roll back a mutation already accepted by the server.
-
-## Interactive resend
-
-Successful interactive exchanges are saved together. Failed or canceled execution
-leaves saved history unchanged, including the previous answer during regeneration;
-executed usage and Tool effects remain. Retain submitted text/images until success
-and resend edited or unchanged input through ordinary chat with a fresh message ID.
-Stop requests cancellation; a lost response can hide a saved exchange. Reuse the
-returned Session ID and load history normally on return. No outcome polling or
-automatic generation retry is needed. See the [chatbot guide](https://docs.blazingagents.com/getting-started/chatbot)
-and [working examples](https://github.com/blazingagents/examples).
-
-## Automatic context compaction
-
-Agents enable automatic compaction by default with a 16,384-token reserve.
-A larger reserve compacts earlier. Settings are included in Agent Versions.
-Compaction summarizes older history for the model while retaining the full
-Session transcript; summarization calls contribute to token usage.
-
-```ts
-await client.agents.update({
-  agentId: "ag_...",
-  autoCompaction: true,
-  compactionReserveTokens: 32768,
-});
-```
-
-### Tool approval policies (0.8.0)
-
-Agents and immutable Agent Versions expose separate `approvalInChat` and
-`approvalInTasks` policies. Create and update them through the ordinary Agent API:
-
-```ts
-await client.agents.update({
-  agentId,
-  approvalInChat: {
-    default: "full",
-    overrides: [
-      { tool: { type: "builtin", name: "bash" }, decision: "manual" },
-      {
-        tool: { type: "mcp", connectionId: "mcp_0123456789abcdef", name: "send_mail" },
-        decision: "auto",
-      },
-    ],
-  },
-  approvalInTasks: { default: "deny", overrides: [] },
-});
-```
-
-An exact tool override wins over the default. Both policies default to `full`
-with no overrides. `full` allows available tools, `deny` blocks execution,
-`manual` requires human review, and `auto` uses backend LLM review. Review errors
-block execution; escalation without an available human also blocks execution.
-Policies do not grant tool access. MCP references use the original remote tool
-name and connection ID; the backend validates attachment and discovery.
-
-Omitting a policy from an update preserves it. Supplying one replaces that whole
-policy; omitted or empty `overrides` clears its overrides. `restoreVersion`
-restores both policies alongside the other versioned fields.
-
-Interactive Sessions reuse `client.sessions.toolApprovals`,
-`client.sessions.decideToolApproval`, and
-`client.sessions.joinToolApprovalContinuation`. A configured backend human
-reviewer path is required. Tasks and stateless generations have no human
-continuation path and block manual or escalated calls; stateless generation uses
-`approvalInChat`. The SDK does not run an approval reviewer.
-
-Approval rows retain optional `tool`, `assistantMessageId`, `createdAt`, and
-`decidedAt` metadata. `tool` and `decidedAt` may be null (admin tools have no
-ordinary-policy reference). Persisted approval decisions remain
-`pending | approved | denied`; policy modes are `full | deny | manual | auto`.
-The root package exports `ApprovalDecision`, `ApprovalPolicy`, `ToolReference`,
-and `ToolApprovalState`; runtime policy schemas are exported from
-`@blazingagents/sdk/contracts`.
-
-## Slack and Telegram
-
-Use the [connection example](https://github.com/blazingagents/typescript-sdk/blob/main/examples/chat-integrations.md) to connect an existing
-Agent through REST. BA hosts the Chat SDK runtime, conversation history, and
-approval cards; no additional SDK resource is required.
-
-`client.chatDeliveries.list` reads the Tenant-wide delivery feed across all
-Chat Connections, newest first. `status` accepts `failed` and/or `ambiguous`;
-omitting it returns both. For example, the failed and ambiguous deliveries
-since a timestamp:
-
-```ts
-const page = await client.chatDeliveries.list({
-  status: ["failed", "ambiguous"],
-  since: "2026-09-01T00:00:00.000Z",
-});
-```
-
-## Merchant monetization
-
-Bill your own customers for model-token usage through your Polar or Dodo
-merchant account. Blazing Agents records usage per Turn and delivers it to
-your provider; your provider owns billing.
-
-```ts
-const client = new BlazingAgents({ apiKey: "ba_..." });
-
-// One-time: connect your merchant account (dashboard or API).
-await client.merchantConnection.create({
-  provider: "polar",
-  environment: "sandbox",
-  credential: "polar_oat_...", // organization access token
-});
-
-// On user onboarding in your backend: bind your user id to the
-// provider-side customer so usage is attributed correctly.
-await client.merchantBindings.put({
-  userId: "user_123",
-  customerId: "cust_polar_...",
-});
-```
-
-`client.merchantUsageEvents` exposes the delivery ledger (`list`, `get`,
-`summary`) and the operator actions `retry`, `release`, and `discard`. The
-optional eligibility guard (`guard` on the connection) refuses new
-executions when the bound customer lacks the required subscription or
-balance; it is a provider-reported check, not a spending lock.

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatConnectionsResource, ChatDeliveriesResource, ChatInput, ChatResult, CompletionInput, CompletionResult, McpConnectionsResource, MemoriesResource, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsResource, ObjectInput, ObjectResult, PromptsResource, ProvidersResource, SessionsResource, TasksResource, TenantResource, UsageResource, WorkspacesResource } from "./types.ts";
+import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatConnectionsResource, ChatDeliveriesResource, ChatInput, ChatResult, CompletionInput, CompletionResult, McpConnectionsResource, MemoriesResource, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsResource, ObjectInput, ObjectResult, PromptsResource, ProvidersResource, SessionsResource, TasksResource, TenantResource, UsageResource, UserClient, WorkspacesResource } from "./types.ts";
 export declare class BlazingAgents {
     private readonly config;
     readonly chatConnections: ChatConnectionsResource;
@@ -21,6 +21,8 @@ export declare class BlazingAgents {
     agent({ agentId }: {
         agentId: string;
     }): AgentClient;
+    /** Scope requests to one end user. IDs use printable ASCII, at most 256 characters, without leading or trailing spaces. */
+    forUser(userId: string): UserClient;
     /**
      * `POST /v1/agents/:agentId/sessions` (create, no `sessionId`) or
      * `POST /v1/agents/:agentId/sessions/:sessionId` (resume). Returns the

package/dist/client.js

@@ -1,3 +1,4 @@
+import { z } from "zod";
 import { chat, completion, objectGeneration } from "./generation.js";
 import { createAgentsResource } from "./resources/agents.js";
 import { createArtifactsResource } from "./resources/artifacts.js";
@@ -18,6 +19,30 @@ import { createUsageResource } from "./resources/usage.js";
 import { createWorkspacesResource } from "./resources/workspaces.js";
 const DEFAULT_BASE_URL = "https://api.blazingagents.com";
 const TRAILING_SLASH_RE = /\/+$/;
+const scopedUserIdSchema = z
+    .string()
+    .max(256)
+    .regex(/^[\x21-\x7E](?:[\x20-\x7E]*[\x21-\x7E])?$/);
+function createUserClient(config) {
+    const usage = createUsageResource(config);
+    return {
+        agents: createAgentsResource(config),
+        sessions: createSessionsResource(config),
+        prompts: createPromptsResource(config),
+        tasks: createTasksResource(config),
+        artifacts: createArtifactsResource(config),
+        workspaces: createWorkspacesResource(config),
+        memories: createMemoriesResource(config),
+        usage: { get: usage.get, sessions: usage.sessions },
+        agent: ({ agentId }) => ({
+            skills: createAgentSkillsResource(config, agentId),
+        }),
+        chat: (input) => chat(config, input),
+        completion: (input) => completion(config, input),
+        object: (input) => objectGeneration(config, input),
+        withOptions: (options) => createUserClient({ ...config, clientRequestId: options.clientRequestId }),
+    };
+}
 export class BlazingAgents {
     config;
     chatConnections;
@@ -66,6 +91,13 @@ export class BlazingAgents {
     agent({ agentId }) {
         return { skills: createAgentSkillsResource(this.config, agentId) };
     }
+    /** Scope requests to one end user. IDs use printable ASCII, at most 256 characters, without leading or trailing spaces. */
+    forUser(userId) {
+        return createUserClient({
+            ...this.config,
+            scopeUserId: scopedUserIdSchema.parse(userId),
+        });
+    }
     /**
      * `POST /v1/agents/:agentId/sessions` (create, no `sessionId`) or
      * `POST /v1/agents/:agentId/sessions/:sessionId` (resume). Returns the

package/dist/contracts/api.d.ts

@@ -23,13 +23,14 @@ export declare const apiErrorCodeSchema: z.ZodEnum<{
     agent_disabled: "agent_disabled";
     agent_mcp_connection_not_found: "agent_mcp_connection_not_found";
     agent_mcp_connections_invalid: "agent_mcp_connections_invalid";
-    agent_name_conflict: "agent_name_conflict";
     agent_version_not_found: "agent_version_not_found";
     api_key_limit_reached: "api_key_limit_reached";
     artifact_session_cap_reached: "artifact_session_cap_reached";
     chat_webhook_conflict: "chat_webhook_conflict";
     chat_webhook_registration_failed: "chat_webhook_registration_failed";
     checkout_evidence_mismatch: "checkout_evidence_mismatch";
+    forbidden: "forbidden";
+    idempotency_conflict: "idempotency_conflict";
     internal: "internal";
     invalid_cursor: "invalid_cursor";
     invalid_request: "invalid_request";
@@ -59,8 +60,6 @@ export declare const apiErrorCodeSchema: z.ZodEnum<{
     model_not_found: "model_not_found";
     model_validation_unavailable: "model_validation_unavailable";
     not_found: "not_found";
-    prompt_limit_reached: "prompt_limit_reached";
-    prompt_name_conflict: "prompt_name_conflict";
     prompt_variable_missing: "prompt_variable_missing";
     prompt_variable_unknown: "prompt_variable_unknown";
     provider_historical_use: "provider_historical_use";
@@ -102,13 +101,14 @@ export declare const apiErrorSchema: z.ZodObject<{
         agent_disabled: "agent_disabled";
         agent_mcp_connection_not_found: "agent_mcp_connection_not_found";
         agent_mcp_connections_invalid: "agent_mcp_connections_invalid";
-        agent_name_conflict: "agent_name_conflict";
         agent_version_not_found: "agent_version_not_found";
         api_key_limit_reached: "api_key_limit_reached";
         artifact_session_cap_reached: "artifact_session_cap_reached";
         chat_webhook_conflict: "chat_webhook_conflict";
         chat_webhook_registration_failed: "chat_webhook_registration_failed";
         checkout_evidence_mismatch: "checkout_evidence_mismatch";
+        forbidden: "forbidden";
+        idempotency_conflict: "idempotency_conflict";
         internal: "internal";
         invalid_cursor: "invalid_cursor";
         invalid_request: "invalid_request";
@@ -138,8 +138,6 @@ export declare const apiErrorSchema: z.ZodObject<{
         model_not_found: "model_not_found";
         model_validation_unavailable: "model_validation_unavailable";
         not_found: "not_found";
-        prompt_limit_reached: "prompt_limit_reached";
-        prompt_name_conflict: "prompt_name_conflict";
         prompt_variable_missing: "prompt_variable_missing";
         prompt_variable_unknown: "prompt_variable_unknown";
         provider_historical_use: "provider_historical_use";
@@ -186,13 +184,14 @@ export declare const apiErrorResponseSchema: z.ZodObject<{
             agent_disabled: "agent_disabled";
             agent_mcp_connection_not_found: "agent_mcp_connection_not_found";
             agent_mcp_connections_invalid: "agent_mcp_connections_invalid";
-            agent_name_conflict: "agent_name_conflict";
             agent_version_not_found: "agent_version_not_found";
             api_key_limit_reached: "api_key_limit_reached";
             artifact_session_cap_reached: "artifact_session_cap_reached";
             chat_webhook_conflict: "chat_webhook_conflict";
             chat_webhook_registration_failed: "chat_webhook_registration_failed";
             checkout_evidence_mismatch: "checkout_evidence_mismatch";
+            forbidden: "forbidden";
+            idempotency_conflict: "idempotency_conflict";
             internal: "internal";
             invalid_cursor: "invalid_cursor";
             invalid_request: "invalid_request";
@@ -222,8 +221,6 @@ export declare const apiErrorResponseSchema: z.ZodObject<{
             model_not_found: "model_not_found";
             model_validation_unavailable: "model_validation_unavailable";
             not_found: "not_found";
-            prompt_limit_reached: "prompt_limit_reached";
-            prompt_name_conflict: "prompt_name_conflict";
             prompt_variable_missing: "prompt_variable_missing";
             prompt_variable_unknown: "prompt_variable_unknown";
             provider_historical_use: "provider_historical_use";

package/dist/contracts/api.js

@@ -18,8 +18,10 @@ export const apiErrorIssueSchema = z
  */
 export const apiErrorCodeSchema = z.enum([
     "invalid_request",
+    "idempotency_conflict",
     "validation_failed",
     "unauthorized",
+    "forbidden",
     "not_found",
     "quota_exceeded",
     "subscription_required",
@@ -33,14 +35,11 @@ export const apiErrorCodeSchema = z.enum([
     "agent_version_not_found",
     "agent_mcp_connection_not_found",
     "agent_mcp_connections_invalid",
-    "agent_name_conflict",
     "provider_required",
     "api_key_limit_reached",
     "artifact_session_cap_reached",
     "invalid_cursor",
     "message_not_found",
-    "prompt_limit_reached",
-    "prompt_name_conflict",
     "prompt_variable_missing",
     "prompt_variable_unknown",
     "provider_in_use",

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

@@ -121,7 +121,7 @@ export declare const agentSchema: z.ZodObject<{
     }>;
 }, z.core.$strip>;
 export declare const agentsResponseSchema: z.ZodObject<{
-    agents: z.ZodArray<z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
         approvalInChat: z.ZodDefault<z.ZodObject<{
             default: z.ZodEnum<{
                 auto: "auto";
@@ -228,6 +228,7 @@ export declare const agentsResponseSchema: z.ZodObject<{
             disabled: "disabled";
         }>;
     }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export declare const agentResponseSchema: z.ZodObject<{
     approvalInChat: z.ZodDefault<z.ZodObject<{
@@ -337,6 +338,8 @@ export declare const agentResponseSchema: z.ZodObject<{
     }>;
 }, z.core.$strip>;
 export declare const agentsListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     userId: z.ZodOptional<z.ZodString>;
     workspaceId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/contracts/entities/agents.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { cursorSchema, paginatedResponseSchema } from "../api.js";
 import { agentIdSchema, mcpConnectionIdSchema, providerIdSchema, tenantIdSchema, workspaceIdSchema, } from "../ids.js";
-import { DEFAULT_AGENT_VERSIONS_LIST_LIMIT, MAX_AGENT_INSTRUCTIONS_LENGTH, MAX_AGENT_NAME_LENGTH, MAX_AGENT_VERSIONS_LIST_LIMIT, MAX_MCP_CONNECTIONS_PER_AGENT, } from "../limitations.js";
+import { DEFAULT_AGENT_VERSIONS_LIST_LIMIT, DEFAULT_AGENTS_LIST_LIMIT, MAX_AGENT_INSTRUCTIONS_LENGTH, MAX_AGENT_NAME_LENGTH, MAX_AGENT_VERSIONS_LIST_LIMIT, MAX_AGENTS_LIST_LIMIT, MAX_MCP_CONNECTIONS_PER_AGENT, } from "../limitations.js";
 import { atLeastOneFieldMessage, hasObjectKeys, hasUniqueValues, } from "../utils.js";
 import { approvalPolicySchema } from "./agent-approval.js";
 import { agentToolGroupIds } from "./agent-tools.js";
@@ -77,14 +77,17 @@ export const agentSchema = z
     message: providerModelPairMessage,
     path: ["providerId"],
 });
-export const agentsResponseSchema = z
-    .object({
-    agents: z.array(agentSchema),
-})
-    .strip();
+export const agentsResponseSchema = paginatedResponseSchema(agentSchema);
 export const agentResponseSchema = agentSchema;
 export const agentsListQuerySchema = z
     .object({
+    cursor: cursorSchema.optional(),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_AGENTS_LIST_LIMIT)
+        .default(DEFAULT_AGENTS_LIST_LIMIT),
     userId: userIdSchema.optional(),
     workspaceId: workspaceIdSchema.optional(),
 })

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

@@ -20,7 +20,7 @@ export declare const promptSchema: z.ZodObject<{
     updatedAt: z.ZodISODateTime;
 }, z.core.$strip>;
 export declare const promptsResponseSchema: z.ZodObject<{
-    prompts: z.ZodArray<z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         tenantId: z.ZodString;
         agentId: z.ZodNullable<z.ZodString>;
@@ -32,7 +32,14 @@ export declare const promptsResponseSchema: z.ZodObject<{
         createdAt: z.ZodISODateTime;
         updatedAt: z.ZodISODateTime;
     }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
+export declare const promptsListQuerySchema: z.ZodObject<{
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    userId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
 export declare const promptResponseSchema: z.ZodObject<{
     id: z.ZodString;
     tenantId: z.ZodString;
@@ -61,6 +68,7 @@ export declare const updatePromptBodySchema: z.ZodObject<{
 export declare function renderPromptTemplate(template: string, values: Record<string, string>): string;
 export type Prompt = z.infer<typeof promptSchema>;
 export type PromptsResponse = z.infer<typeof promptsResponseSchema>;
+export type PromptsListQuery = z.infer<typeof promptsListQuerySchema>;
 export type PromptResponse = z.infer<typeof promptResponseSchema>;
 export type CreatePromptBody = z.input<typeof createPromptBodySchema>;
 export type UpdatePromptBody = z.infer<typeof updatePromptBodySchema>;

package/dist/contracts/entities/prompts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
+import { cursorSchema, paginatedResponseSchema } from "../api.js";
 import { agentIdSchema, promptIdSchema, tenantIdSchema } from "../ids.js";
-import { MAX_PROMPT_NAME_LENGTH, MAX_PROMPT_TEMPLATE_BYTES, MAX_PROMPT_VARIABLES, } from "../limitations.js";
+import { DEFAULT_PROMPTS_LIST_LIMIT, MAX_PROMPT_NAME_LENGTH, MAX_PROMPT_TEMPLATE_BYTES, MAX_PROMPT_VARIABLES, MAX_PROMPTS_LIST_LIMIT, } from "../limitations.js";
 import { atLeastOneFieldMessage, hasObjectKeys } from "../utils.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
 export const promptVariableTokenPattern = /{{([\s\S]*?)}}/g;
@@ -59,11 +60,20 @@ export const promptSchema = z
     updatedAt: z.iso.datetime({ offset: true }),
 })
     .strip();
-export const promptsResponseSchema = z
+export const promptsResponseSchema = paginatedResponseSchema(promptSchema);
+export const promptsListQuerySchema = z
     .object({
-    prompts: z.array(promptSchema),
+    cursor: cursorSchema.optional(),
+    limit: z.coerce
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_PROMPTS_LIST_LIMIT)
+        .default(DEFAULT_PROMPTS_LIST_LIMIT),
+    userId: userIdSchema.optional(),
+    agentId: agentIdSchema.optional(),
 })
-    .strip();
+    .strict();
 export const promptResponseSchema = promptSchema;
 export const createPromptBodySchema = z
     .object({

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

@@ -44,12 +44,9 @@ export declare const taskScheduleInputSchema: z.ZodDiscriminatedUnion<[z.ZodObje
 export type TaskScheduleInput = z.infer<typeof taskScheduleInputSchema>;
 /**
  * `POST /v1/tasks` — schedule present = scheduled task; absent = on-demand.
- * `submit: true` enqueues a run immediately (on-demand's only trigger
- * alongside creation) with a server-minted random run id. This path is
- * NOT idempotent — each call creates a new task + new run. For run-level
- * idempotency, use `POST /v1/tasks/{taskId}/runs` with an idempotency key
- * (the task must already exist so the deterministic run id is stable
- * across replays).
+ * `submit: true` enqueues a run immediately. An optional `idempotencyKey`
+ * makes retries return the original Task and initial run id. Without a key,
+ * each call creates a new Task. Run creation has its own idempotency key.
  */
 export declare const createTaskBodySchema: z.ZodObject<{
     agentId: z.ZodString;
@@ -76,6 +73,7 @@ export declare const createTaskBodySchema: z.ZodObject<{
     }, z.core.$strict>], "kind">>>;
     enabled: z.ZodDefault<z.ZodBoolean>;
     submit: z.ZodDefault<z.ZodBoolean>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
     userId: z.ZodDefault<z.ZodString>;
     metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;

package/dist/contracts/entities/tasks.js

@@ -106,12 +106,9 @@ const taskNameSchema = z.string().trim().min(1).max(MAX_TASK_NAME_LENGTH);
 const taskPromptSchema = z.string().trim().min(1).max(MAX_TASK_PROMPT_LENGTH);
 /**
  * `POST /v1/tasks` — schedule present = scheduled task; absent = on-demand.
- * `submit: true` enqueues a run immediately (on-demand's only trigger
- * alongside creation) with a server-minted random run id. This path is
- * NOT idempotent — each call creates a new task + new run. For run-level
- * idempotency, use `POST /v1/tasks/{taskId}/runs` with an idempotency key
- * (the task must already exist so the deterministic run id is stable
- * across replays).
+ * `submit: true` enqueues a run immediately. An optional `idempotencyKey`
+ * makes retries return the original Task and initial run id. Without a key,
+ * each call creates a new Task. Run creation has its own idempotency key.
  */
 export const createTaskBodySchema = z
     .object({
@@ -122,6 +119,7 @@ export const createTaskBodySchema = z
     schedule: taskScheduleInputSchema.nullable().default(null),
     enabled: z.boolean().default(true),
     submit: z.boolean().default(false),
+    idempotencyKey: z.string().trim().min(1).optional(),
     userId: userIdSchema.default(""),
     metadata: metadataSchema.default({}),
 })

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

@@ -77,6 +77,22 @@ export declare const usageTotalsSchema: z.ZodObject<{
     requestCount: z.ZodNumber;
     durationMs: z.ZodNumber;
 }, z.core.$strip>;
+export declare const sessionUsageQuerySchema: z.ZodObject<{
+    sessionIds: z.ZodArray<z.ZodString>;
+    from: z.ZodOptional<z.ZodISODate>;
+    to: z.ZodOptional<z.ZodISODate>;
+}, z.core.$strict>;
+export declare const sessionUsageResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodString;
+        totals: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            requestCount: z.ZodNumber;
+            durationMs: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const usageResponseSchema: z.ZodObject<{
     buckets: z.ZodArray<z.ZodObject<{
         day: z.ZodNullable<z.ZodString>;
@@ -224,3 +240,5 @@ export type UsageTotals = z.infer<typeof usageTotalsSchema>;
 export type UsageResponse = z.infer<typeof usageResponseSchema>;
 export type UsageOverviewQuery = z.infer<typeof usageOverviewQuerySchema>;
 export type UsageOverviewResponse = z.infer<typeof usageOverviewResponseSchema>;
+export type SessionUsageQuery = z.infer<typeof sessionUsageQuerySchema>;
+export type SessionUsageResponse = z.infer<typeof sessionUsageResponseSchema>;

package/dist/contracts/entities/usage.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { agentIdSchema, sessionIdSchema } from "../ids.js";
 import { DEFAULT_USAGE_OVERVIEW_TOP_N, DEFAULT_USAGE_RANGE_DAYS, DEFAULT_USAGE_SESSION_TOP_N, MAX_USAGE_OVERVIEW_TOP_N, MAX_USAGE_RANGE_DAYS, MAX_USAGE_SESSION_TOP_N, } from "../limitations.js";
+import { hasUniqueValues } from "../utils.js";
 import { userIdSchema } from "./attribution.js";
 function validateUsageRange(value, ctx) {
     if ((value.from === undefined) !== (value.to === undefined)) {
@@ -122,6 +123,33 @@ export const usageTotalsSchema = z
     durationMs: z.number().int().nonnegative(),
 })
     .strip();
+export const sessionUsageQuerySchema = z
+    .object({
+    sessionIds: z
+        .array(sessionIdSchema)
+        .min(1)
+        .max(100)
+        .refine(hasUniqueValues, {
+        message: "Session ids must be unique.",
+    }),
+    from: z.iso.date().optional(),
+    to: z.iso.date().optional(),
+})
+    .strict()
+    .superRefine(validateUsageRange);
+export const sessionUsageResponseSchema = z
+    .object({
+    data: z
+        .array(z
+        .object({
+        sessionId: sessionIdSchema,
+        totals: usageTotalsSchema,
+    })
+        .strip())
+        .min(1)
+        .max(100),
+})
+    .strip();
 export const usageResponseSchema = z
     .object({
     buckets: z.array(usageBucketSchema),

package/dist/contracts/index.d.ts

@@ -2,7 +2,7 @@
 export { receivedApiErrorResponseSchema } from "./api.ts";
 export type { ApprovalDecision, ApprovalPolicy, ToolReference, } from "./entities/agent-approval.ts";
 export { approvalDecisionSchema, approvalPolicySchema, toolReferenceSchema, } from "./entities/agent-approval.ts";
-export { agentResponseSchema, agentSchema, agentStatusSchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.ts";
+export { agentResponseSchema, agentSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.ts";
 export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.ts";
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.ts";
 export type { PromptVariables, UsageSummary } from "./entities/chat.ts";
@@ -11,14 +11,14 @@ export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseS
 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 { createMerchantConnectionBodySchema, merchantBindingResponseSchema, merchantBindingsResponseSchema, merchantConnectionResponseSchema, merchantConnectionSchema, merchantConnectionStatusSchema, merchantCustomerBindingSchema, merchantEnvironmentSchema, merchantGuardSchema, merchantProviderSchema, merchantUsageEventNextAction, merchantUsageEventNextActionSchema, merchantUsageEventSchema, merchantUsageEventStatusSchema, merchantUsageEventsResponseSchema, merchantUsageSummaryQuerySchema, merchantUsageSummaryResponseSchema, merchantUsageSummarySchema, merchantWorkflowIssueSchema, updateMerchantConnectionBodySchema, upsertMerchantBindingBodySchema, } from "./entities/merchant.ts";
-export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptSchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.ts";
+export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptSchema, promptsListQuerySchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.ts";
 export { createProviderBodySchema, providerListItemSchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.ts";
 export type { ToolApprovalDecisionResponse, ToolApprovalsResponse, } from "./entities/sessions.ts";
 export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.ts";
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";
-export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskListItemSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
+export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
 export { quotaSchema, subscriptionStatusSchema, tenantDeletionSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.ts";
-export type { UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageResponse, UsageTotals, } from "./entities/usage.ts";
-export { usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.ts";
+export type { SessionUsageQuery, SessionUsageResponse, UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageResponse, UsageTotals, } from "./entities/usage.ts";
+export { sessionUsageQuerySchema, sessionUsageResponseSchema, usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.ts";
 export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceSchema, workspacesListResponseSchema, } from "./entities/workspaces.ts";
 export { agentIdSchema, apiKeyTokenSchema, isAdminAgentId, promptIdSchema, sessionIdSchema, } from "./ids.ts";

package/dist/contracts/index.js

@@ -2,7 +2,7 @@
 // biome-ignore lint/performance/noBarrelFile: public contract entry point
 export { receivedApiErrorResponseSchema } from "./api.js";
 export { approvalDecisionSchema, approvalPolicySchema, toolReferenceSchema, } from "./entities/agent-approval.js";
-export { agentResponseSchema, agentSchema, agentStatusSchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.js";
+export { agentResponseSchema, agentSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.js";
 export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.js";
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.js";
 export { blazingAgentsChatMessageMetadataSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, generationRequestBodySchema, jsonSchemaShapeSchema, promptVariablesSchema, usageSummarySchema, } from "./entities/chat.js";
@@ -10,12 +10,12 @@ export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseS
 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 { createMerchantConnectionBodySchema, merchantBindingResponseSchema, merchantBindingsResponseSchema, merchantConnectionResponseSchema, merchantConnectionSchema, merchantConnectionStatusSchema, merchantCustomerBindingSchema, merchantEnvironmentSchema, merchantGuardSchema, merchantProviderSchema, merchantUsageEventNextAction, merchantUsageEventNextActionSchema, merchantUsageEventSchema, merchantUsageEventStatusSchema, merchantUsageEventsResponseSchema, merchantUsageSummaryQuerySchema, merchantUsageSummaryResponseSchema, merchantUsageSummarySchema, merchantWorkflowIssueSchema, updateMerchantConnectionBodySchema, upsertMerchantBindingBodySchema, } from "./entities/merchant.js";
-export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptSchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.js";
+export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptSchema, promptsListQuerySchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.js";
 export { createProviderBodySchema, providerListItemSchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.js";
 export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.js";
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.js";
-export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskListItemSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.js";
+export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.js";
 export { quotaSchema, subscriptionStatusSchema, tenantDeletionSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.js";
-export { usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.js";
+export { sessionUsageQuerySchema, sessionUsageResponseSchema, usageOverviewQuerySchema, usageOverviewResponseSchema, usageResponseSchema, } from "./entities/usage.js";
 export { createWorkspaceBodySchema, updateWorkspaceBodySchema, workspaceSchema, workspacesListResponseSchema, } from "./entities/workspaces.js";
 export { agentIdSchema, apiKeyTokenSchema, isAdminAgentId, promptIdSchema, sessionIdSchema, } from "./ids.js";

package/dist/contracts/limitations.d.ts

@@ -29,10 +29,8 @@ export declare const MAX_SKILL_COMPATIBILITY_LENGTH = 500;
 export declare const MAX_SKILL_COPY_DESTINATIONS = 30;
 export declare const DEFAULT_SKILLS_LIST_LIMIT = 50;
 export declare const MAX_SKILLS_LIST_LIMIT = 100;
-/**
- * Prompts — max 100 per tenant, ~10 KB template cap, name ≤ 80.
- */
-export declare const MAX_PROMPTS_PER_TENANT = 100;
+export declare const DEFAULT_PROMPTS_LIST_LIMIT = 50;
+export declare const MAX_PROMPTS_LIST_LIMIT = 100;
 export declare const MAX_PROMPT_TEMPLATE_BYTES: number;
 export declare const MAX_PROMPT_VARIABLES = 10;
 export declare const MAX_PROMPT_NAME_LENGTH = 80;
@@ -73,6 +71,8 @@ export declare const MAX_MCP_ATTACHMENT_METADATA_KEY_LENGTH = 64;
 export declare const MAX_MCP_REQUEST_CONTEXT_BYTES: number;
 /** Agents — name ≤ 80, instructions ≤ 3000. */
 export declare const MAX_AGENT_NAME_LENGTH = 80;
+export declare const DEFAULT_AGENTS_LIST_LIMIT = 50;
+export declare const MAX_AGENTS_LIST_LIMIT = 100;
 export declare const MAX_AGENT_INSTRUCTIONS_LENGTH = 3000;
 export declare const DEFAULT_AGENT_VERSIONS_LIST_LIMIT = 50;
 export declare const MAX_AGENT_VERSIONS_LIST_LIMIT = 200;

package/dist/contracts/limitations.js

@@ -30,10 +30,8 @@ export const MAX_SKILL_COMPATIBILITY_LENGTH = 500;
 export const MAX_SKILL_COPY_DESTINATIONS = 30;
 export const DEFAULT_SKILLS_LIST_LIMIT = 50;
 export const MAX_SKILLS_LIST_LIMIT = 100;
-/**
- * Prompts — max 100 per tenant, ~10 KB template cap, name ≤ 80.
- */
-export const MAX_PROMPTS_PER_TENANT = 100;
+export const DEFAULT_PROMPTS_LIST_LIMIT = 50;
+export const MAX_PROMPTS_LIST_LIMIT = 100;
 export const MAX_PROMPT_TEMPLATE_BYTES = 10 * 1024;
 export const MAX_PROMPT_VARIABLES = 10;
 export const MAX_PROMPT_NAME_LENGTH = 80;
@@ -74,6 +72,8 @@ export const MAX_MCP_ATTACHMENT_METADATA_KEY_LENGTH = 64;
 export const MAX_MCP_REQUEST_CONTEXT_BYTES = 16 * 1024;
 /** Agents — name ≤ 80, instructions ≤ 3000. */
 export const MAX_AGENT_NAME_LENGTH = 80;
+export const DEFAULT_AGENTS_LIST_LIMIT = 50;
+export const MAX_AGENTS_LIST_LIMIT = 100;
 export const MAX_AGENT_INSTRUCTIONS_LENGTH = 3000;
 export const DEFAULT_AGENT_VERSIONS_LIST_LIMIT = 50;
 export const MAX_AGENT_VERSIONS_LIST_LIMIT = 200;

package/dist/http.js

@@ -76,6 +76,9 @@ async function rawRequest(config, path, options) {
         ...(clientRequestId === undefined
             ? {}
             : { "x-client-request-id": clientRequestId }),
+        ...(config.scopeUserId === undefined
+            ? {}
+            : { "X-BA-User-Id": config.scopeUserId }),
     };
     let body = options.body ?? null;
     if (options.json !== undefined) {

package/dist/index.d.ts

@@ -7,17 +7,18 @@ export type { UIMessage } from "ai";
 export { BlazingAgentsChatTransport, type BlazingAgentsChatTransportOptions, } from "./chat-transport.ts";
 export { BlazingAgents } from "./client.ts";
 export type { ApprovalDecision, ApprovalPolicy, ToolReference, } from "./contracts/entities/agent-approval.ts";
-export type { Agent, AgentResponse, AgentsResponse, AgentVersion, AgentVersionsListQuery, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody, } from "./contracts/entities/agents.ts";
+export type { Agent, AgentResponse, AgentsListQuery, AgentsResponse, AgentVersion, AgentVersionsListQuery, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody, } from "./contracts/entities/agents.ts";
 export type { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse, } from "./contracts/entities/artifacts.ts";
 export type { ChatConfiguration, ChatConnection, ChatConnectionsResponse, ChatCredentials, ChatDeliveriesResponse, ChatDelivery, ChatDeliveryListStatus, ChatDeliveryStatus, ChatHealth, ChatIdentity, CreateChatConnectionBody, RotateChatConnectionBody, TenantChatDelivery, UpdateChatConnectionBody, } from "./contracts/entities/chat-connections.ts";
 export type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionAuthType, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionStatus, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody, } from "./contracts/entities/mcp-connections.ts";
 export type { CreateMerchantConnectionBody, MerchantBindingResponse, MerchantBindingsResponse, MerchantConnection, MerchantConnectionResponse, MerchantCustomerBinding, MerchantGuard, MerchantProviderKind, MerchantUsageEvent, MerchantUsageEventResponse, MerchantUsageEventStatus, MerchantUsageEventsResponse, MerchantUsageSummary, MerchantUsageSummaryResponse, UpdateMerchantConnectionBody, UpsertMerchantBindingBody, } from "./contracts/entities/merchant.ts";
+export type { CreatePromptBody, PromptResponse, PromptsListQuery, PromptsResponse, UpdatePromptBody, } from "./contracts/entities/prompts.ts";
 export type { CreateProviderBody, ProviderListItem, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, ThinkingLevelsResponse, UpdateProviderBody, } from "./contracts/entities/providers.ts";
 export type { ToolApprovalDecisionResponse, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.ts";
 export type { CreateSkillBody, Skill, SkillArchiveType, SkillCopyResult, SkillCopyResults, SkillDetail, SkillFile, SkillsListResponse, } from "./contracts/entities/skills.ts";
-export type { UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageTotals, } from "./contracts/entities/usage.ts";
+export type { SessionUsageQuery, SessionUsageResponse, UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageTotals, } from "./contracts/entities/usage.ts";
 export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, } from "./contracts/entities/workspaces.ts";
 export { 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, ChatConnectionsResource, ChatDeliveriesListOptions, ChatDeliveriesResource, ChatInput, ChatMessageInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, KnownBlazingAgentsErrorCode, LatestSessionsListOptions, McpConnectionsResource, MemoriesListOptions, MemoriesResource, MerchantBindingsListOptions, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsListOptions, MerchantUsageEventsResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceRequestOptions, 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, ChatConnectionsResource, ChatDeliveriesListOptions, ChatDeliveriesResource, ChatInput, ChatMessageInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, KnownBlazingAgentsErrorCode, LatestSessionsListOptions, McpConnectionsResource, MemoriesListOptions, MemoriesResource, MerchantBindingsListOptions, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsListOptions, MerchantUsageEventsResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceRequestOptions, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, UserClient, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";

package/dist/resources/agents.d.ts

@@ -1,8 +1,2 @@
 import type { AgentsResource, HttpConfig } from "../types.ts";
-/**
- * `client.agents` — full CRUD over `/v1/agents`. The list endpoint is
- * unpaginated (bounded by the 100/tenant cap); create/update bodies are
- * the core zod contracts' input shapes. Responses are parsed against the
- * core wire schemas (parse-on-read).
- */
 export declare function createAgentsResource(config: HttpConfig): AgentsResource;

package/dist/resources/agents.js

@@ -1,12 +1,6 @@
 import { agentResponseSchema, agentsResponseSchema, agentVersionSchema, agentVersionsResponseSchema, } from "../contracts/entities/agents.js";
 import { mcpAttachmentResponseSchema, mcpAttachmentsResponseSchema, } from "../contracts/entities/mcp-connections.js";
 import { requestJson } from "../http.js";
-/**
- * `client.agents` — full CRUD over `/v1/agents`. The list endpoint is
- * unpaginated (bounded by the 100/tenant cap); create/update bodies are
- * the core zod contracts' input shapes. Responses are parsed against the
- * core wire schemas (parse-on-read).
- */
 export function createAgentsResource(config) {
     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}`, {
@@ -26,6 +20,8 @@ export function createAgentsResource(config) {
             return await requestJson(config, "/v1/agents", {
                 signal: options.abortSignal,
                 query: {
+                    cursor: options.cursor,
+                    limit: options.limit,
                     userId: options.userId,
                     workspaceId: options.workspaceId,
                 },

package/dist/resources/prompts.d.ts

@@ -1,6 +1,2 @@
 import type { HttpConfig, PromptsResource } from "../types.ts";
-/**
- * `client.prompts` — CRUD over `/v1/prompts`. The list endpoint is
- * unpaginated (bounded by the 100/tenant cap).
- */
 export declare function createPromptsResource(config: HttpConfig): PromptsResource;

package/dist/resources/prompts.js

@@ -1,9 +1,5 @@
 import { promptResponseSchema, promptsResponseSchema, } from "../contracts/entities/prompts.js";
 import { requestJson } from "../http.js";
-/**
- * `client.prompts` — CRUD over `/v1/prompts`. The list endpoint is
- * unpaginated (bounded by the 100/tenant cap).
- */
 export function createPromptsResource(config) {
     return {
         async create({ abortSignal, ...body }) {
@@ -13,10 +9,10 @@ export function createPromptsResource(config) {
                 method: "POST",
             }, promptResponseSchema);
         },
-        async list({ userId, agentId, abortSignal } = {}) {
+        async list({ userId, agentId, cursor, limit, abortSignal } = {}) {
             return await requestJson(config, "/v1/prompts", {
                 signal: abortSignal,
-                query: { userId, agentId },
+                query: { userId, agentId, cursor, limit },
             }, promptsResponseSchema);
         },
         async get({ promptId, abortSignal }) {

package/dist/resources/usage.js

@@ -1,4 +1,4 @@
-import { usageOverviewResponseSchemaForQuery, usageResponseSchema, } from "../contracts/entities/usage.js";
+import { sessionUsageQuerySchema, sessionUsageResponseSchema, usageOverviewResponseSchemaForQuery, usageResponseSchema, } from "../contracts/entities/usage.js";
 import { requestJson } from "../http.js";
 /**
  * `client.usage` — get over `/v1/usage` (tenant-wide) and
@@ -7,6 +7,14 @@ import { requestJson } from "../http.js";
  */
 export function createUsageResource(config) {
     return {
+        async sessions({ abortSignal, ...input }) {
+            const body = sessionUsageQuerySchema.parse(input);
+            return await requestJson(config, "/v1/usage/sessions", {
+                method: "POST",
+                json: body,
+                signal: abortSignal,
+            }, sessionUsageResponseSchema);
+        },
         async get({ abortSignal, ...query } = {}) {
             return await requestJson(config, "/v1/usage", {
                 query,

package/dist/types.d.ts

@@ -13,7 +13,7 @@ import type { DecideToolApprovalBody, LatestSessionsListResponse, SessionMessage
 import type { CreateSkillBody, SkillArchiveType, SkillCopyResults, SkillDetail, SkillsListResponse } from "./contracts/entities/skills.ts";
 import type { CreateTaskBody, CreateTaskResponse, CreateTaskRunBody, CreateTaskRunResponse, TaskResponse, TaskRunMessagesResponse, TaskRunResponse, TaskRunsListResponse, TasksListResponse, UpdateTaskBody } from "./contracts/entities/tasks.ts";
 import type { TenantSettingsResponse, UpdateTenantSettingsBody } from "./contracts/entities/tenants.ts";
-import type { UsageOverviewQuery, UsageOverviewResponse, UsageQuery, UsageResponse } from "./contracts/entities/usage.ts";
+import type { SessionUsageQuery, SessionUsageResponse, UsageOverviewQuery, UsageOverviewResponse, UsageQuery, UsageResponse } from "./contracts/entities/usage.ts";
 import type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspacesListResponse } from "./contracts/entities/workspaces.ts";
 export type KnownBlazingAgentsErrorCode = ApiErrorCode | "invalid_response" | "network_error" | "request_aborted" | "stream_error";
 export type BlazingAgentsErrorCode = KnownBlazingAgentsErrorCode | (string & {});
@@ -46,6 +46,7 @@ export interface HttpConfig {
     clientRequestId?: string;
     fetch?: BlazingAgentsFetch;
     onResponse?: ((response: ResponseObservation) => void) | undefined;
+    scopeUserId?: string;
 }
 export interface BlazingAgentsOptions {
     apiKey: string;
@@ -57,6 +58,23 @@ export interface BlazingAgentsOptions {
 export interface BlazingAgentsRequestOptions {
     clientRequestId: string;
 }
+export interface UserClient {
+    agent(input: {
+        agentId: string;
+    }): AgentClient;
+    readonly agents: AgentsResource;
+    readonly artifacts: ArtifactsResource;
+    chat(input: ChatInput): Promise<ChatResult>;
+    completion(input: CompletionInput): Promise<CompletionResult>;
+    readonly memories: MemoriesResource;
+    object(input: ObjectInput): Promise<ObjectResult>;
+    readonly prompts: PromptsResource;
+    readonly sessions: SessionsResource;
+    readonly tasks: TasksResource;
+    readonly usage: Pick<UsageResource, "get" | "sessions">;
+    withOptions(options: BlazingAgentsRequestOptions): UserClient;
+    readonly workspaces: WorkspacesResource;
+}
 export interface ResponseObservation {
     clientRequestId?: string;
     durationMs: number;
@@ -234,6 +252,8 @@ export interface AgentClient {
     readonly skills: AgentSkillsResource;
 }
 export interface AgentsListOptions extends ResourceRequestOptions {
+    cursor?: string;
+    limit?: number;
     userId?: string;
     workspaceId?: string;
 }
@@ -313,6 +333,8 @@ export interface PromptsResource {
     list(input?: {
         userId?: string;
         agentId?: string;
+        cursor?: string;
+        limit?: number;
     } & ResourceRequestOptions): Promise<PromptsResponse>;
     update(input: UpdatePromptBody & {
         promptId: string;
@@ -506,6 +528,7 @@ export interface UsageResource {
     } & ResourceRequestOptions): Promise<UsageResponse>;
     /** Returns totals, daily usage, and bounded Agent, user, and model rankings. */
     overview(input?: Partial<UsageOverviewQuery> & ResourceRequestOptions): Promise<UsageOverviewResponse>;
+    sessions(input: SessionUsageQuery & ResourceRequestOptions): Promise<SessionUsageResponse>;
 }
 /**
  * `client.merchantConnection` — the tenant's own Polar/Dodo merchant

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blazingagents/sdk",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "TypeScript SDK for the Blazing Agents API",
   "homepage": "https://docs.blazingagents.com",
   "bugs": {
@@ -35,26 +35,28 @@
     "lint": "ultracite check",
     "prepack": "npm run build",
     "test": "vitest run --coverage",
-    "test:consumer": "npm run build && tsc -p tsconfig.consumer.json && vitest run -c vitest.consumer.config.mts",
+    "test:consumer": "node test-consumer.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.tests.json"
   },
   "dependencies": {
     "croner": "10.0.1",
     "nanoid": "6.0.1",
-    "yaml": "2.9.0",
-    "zod": "4.5.4"
+    "yaml": "2.9.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.8",
+    "@types/json-schema": "7.0.15",
     "@types/node": "^26.4.0",
     "@vitest/coverage-v8": "^4.1.10",
     "ai": "^7.0.84",
     "typescript": "^7.0.2",
     "ultracite": "^7.10.2",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "zod": "4.5.4"
   },
   "peerDependencies": {
-    "ai": "^7.0.84"
+    "ai": "^7.0.84",
+    "zod": "^4.5.4"
   },
   "engines": {
     "node": ">=24"