@blazingagents/sdk 0.11.0 → 0.13.0

package/README.md

@@ -87,40 +87,59 @@ 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.
 
-### Direct native chat
+### Relay browser chat
 
-For a direct SDK integration, use `BlazingAgentsDirectChatTransport` with AI SDK
-`useChat`. It sends through `client.chat()` and uses AI SDK's stream decoder
-without constructing a streaming `Response`. Inject your native streaming fetch
-implementation into `BlazingAgents` when the runtime requires one.
+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 { BlazingAgentsDirectChatTransport } from "@blazingagents/sdk";
+import { BlazingAgents, BlazingAgentsDirectChatTransport } from "@blazingagents/sdk";
 
-function Chat({ client, agentId, initialSessionId, saveSessionId }) {
+function Chat({ getCredential, agentId, initialSessionId, saveSessionId }) {
   const transport = useMemo(
     () => new BlazingAgentsDirectChatTransport({
-      client,
+      getClient: async () => new BlazingAgents({ apiKey: await getCredential() }),
       agentId,
       sessionId: initialSessionId,
       onSessionId: saveSessionId,
     }),
-    [client, agentId, initialSessionId, 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 chat;
-remount the chat with a new transport when switching credentials, Agents, or
-Sessions. `onSessionId` runs once for a newly created Session before stream
-consumption, so it can be saved even if streaming later fails. The adapter
-preserves user message IDs, regeneration targets, and `useChat` cancellation.
-Regeneration requires an existing Session. Reconnection returns `null`; the
-adapter does not retry interrupted Turns or resume their streams.
+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
 
@@ -239,6 +258,18 @@ Use the [connection example](https://github.com/blazingagents/typescript-sdk/blo
 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

package/dist/client.d.ts

@@ -1,7 +1,8 @@
-import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatConnectionsResource, 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, WorkspacesResource } from "./types.ts";
 export declare class BlazingAgents {
     private readonly config;
     readonly chatConnections: ChatConnectionsResource;
+    readonly chatDeliveries: ChatDeliveriesResource;
     readonly agents: AgentsResource;
     readonly sessions: SessionsResource;
     readonly providers: ProvidersResource;

package/dist/client.js

@@ -2,6 +2,7 @@ import { chat, completion, objectGeneration } from "./generation.js";
 import { createAgentsResource } from "./resources/agents.js";
 import { createArtifactsResource } from "./resources/artifacts.js";
 import { createChatConnectionsResource } from "./resources/chat-connections.js";
+import { createChatDeliveriesResource } from "./resources/chat-deliveries.js";
 import { createMcpConnectionsResource } from "./resources/mcp-connections.js";
 import { createMemoriesResource } from "./resources/memories.js";
 import { createMerchantBindingsResource } from "./resources/merchant-bindings.js";
@@ -20,6 +21,7 @@ const TRAILING_SLASH_RE = /\/+$/;
 export class BlazingAgents {
     config;
     chatConnections;
+    chatDeliveries;
     agents;
     sessions;
     providers;
@@ -45,6 +47,7 @@ export class BlazingAgents {
             onResponse: options.onResponse,
         };
         this.chatConnections = createChatConnectionsResource(this.config);
+        this.chatDeliveries = createChatDeliveriesResource(this.config);
         this.agents = createAgentsResource(this.config);
         this.sessions = createSessionsResource(this.config);
         this.providers = createProvidersResource(this.config);

package/dist/contracts/entities/chat-connections.d.ts

@@ -187,3 +187,105 @@ export declare const chatConnectionsResponseSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ChatConnectionsResponse = z.output<typeof chatConnectionsResponseSchema>;
 export type RotateChatConnectionBody = z.input<typeof rotateChatConnectionBodySchema>;
+export declare const chatDeliveryStatusSchema: z.ZodEnum<{
+    ambiguous: "ambiguous";
+    confirmed: "confirmed";
+    failed: "failed";
+    pending: "pending";
+}>;
+export type ChatDeliveryStatus = z.infer<typeof chatDeliveryStatusSchema>;
+export declare const chatDeliveryListStatusSchema: z.ZodEnum<{
+    ambiguous: "ambiguous";
+    failed: "failed";
+}>;
+export type ChatDeliveryListStatus = z.infer<typeof chatDeliveryListStatusSchema>;
+export declare const chatDeliverySchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        card: "card";
+        reply: "reply";
+    }>;
+    status: z.ZodEnum<{
+        ambiguous: "ambiguous";
+        confirmed: "confirmed";
+        failed: "failed";
+        pending: "pending";
+    }>;
+    attempt: z.ZodNumber;
+    credentialVersion: z.ZodNumber;
+    representation: z.ZodString;
+    diagnostic: z.ZodNullable<z.ZodString>;
+    receipts: z.ZodOptional<z.ZodUnknown>;
+    sessionId: z.ZodString;
+    messageId: z.ZodNullable<z.ZodString>;
+    approvalId: z.ZodNullable<z.ZodString>;
+    threadId: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type ChatDelivery = z.infer<typeof chatDeliverySchema>;
+export declare const tenantChatDeliverySchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        card: "card";
+        reply: "reply";
+    }>;
+    status: z.ZodEnum<{
+        ambiguous: "ambiguous";
+        confirmed: "confirmed";
+        failed: "failed";
+        pending: "pending";
+    }>;
+    attempt: z.ZodNumber;
+    credentialVersion: z.ZodNumber;
+    representation: z.ZodString;
+    diagnostic: z.ZodNullable<z.ZodString>;
+    receipts: z.ZodOptional<z.ZodUnknown>;
+    sessionId: z.ZodString;
+    messageId: z.ZodNullable<z.ZodString>;
+    approvalId: z.ZodNullable<z.ZodString>;
+    threadId: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    connectionId: z.ZodString;
+    agentId: z.ZodString;
+    platform: z.ZodEnum<{
+        slack: "slack";
+        telegram: "telegram";
+    }>;
+}, z.core.$strip>;
+export type TenantChatDelivery = z.infer<typeof tenantChatDeliverySchema>;
+export declare const chatDeliveriesResponseSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            card: "card";
+            reply: "reply";
+        }>;
+        status: z.ZodEnum<{
+            ambiguous: "ambiguous";
+            confirmed: "confirmed";
+            failed: "failed";
+            pending: "pending";
+        }>;
+        attempt: z.ZodNumber;
+        credentialVersion: z.ZodNumber;
+        representation: z.ZodString;
+        diagnostic: z.ZodNullable<z.ZodString>;
+        receipts: z.ZodOptional<z.ZodUnknown>;
+        sessionId: z.ZodString;
+        messageId: z.ZodNullable<z.ZodString>;
+        approvalId: z.ZodNullable<z.ZodString>;
+        threadId: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        connectionId: z.ZodString;
+        agentId: z.ZodString;
+        platform: z.ZodEnum<{
+            slack: "slack";
+            telegram: "telegram";
+        }>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ChatDeliveriesResponse = z.infer<typeof chatDeliveriesResponseSchema>;

package/dist/contracts/entities/chat-connections.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { agentIdSchema, chatConnectionIdSchema, tenantIdSchema, } from "../ids.js";
+import { agentIdSchema, chatConnectionIdSchema, chatDeliveryIdSchema, tenantIdSchema, } from "../ids.js";
 const secret = z
     .string()
     .min(8)
@@ -140,3 +140,39 @@ export const chatConnectionSchema = z
 export const chatConnectionsResponseSchema = z
     .object({ chatConnections: z.array(chatConnectionSchema) })
     .strip();
+export const chatDeliveryStatusSchema = z.enum([
+    "pending",
+    "confirmed",
+    "failed",
+    "ambiguous",
+]);
+export const chatDeliveryListStatusSchema = z.enum(["failed", "ambiguous"]);
+export const chatDeliverySchema = z
+    .object({
+    id: chatDeliveryIdSchema,
+    kind: z.enum(["reply", "card"]),
+    status: chatDeliveryStatusSchema,
+    attempt: z.number().int().nonnegative(),
+    credentialVersion: z.number().int().nonnegative(),
+    representation: z.string(),
+    diagnostic: z.string().nullable(),
+    receipts: z.unknown().optional(),
+    sessionId: z.string(),
+    messageId: z.string().nullable(),
+    approvalId: z.string().nullable(),
+    threadId: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+})
+    .strip();
+export const tenantChatDeliverySchema = chatDeliverySchema.extend({
+    connectionId: chatConnectionIdSchema,
+    agentId: agentIdSchema,
+    platform: z.enum(["slack", "telegram"]),
+});
+export const chatDeliveriesResponseSchema = z
+    .object({
+    data: z.array(tenantChatDeliverySchema),
+    nextCursor: z.string().nullable(),
+})
+    .strip();

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

@@ -30,11 +30,13 @@ export declare const usageSummarySchema: z.ZodObject<{
     metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     modelId: z.ZodString;
     outputTokens: z.ZodNumber;
+    reasoningTokens: z.ZodNullable<z.ZodNumber>;
     turnId: z.ZodString;
     sessionId: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>;
     stepUsages: z.ZodArray<z.ZodObject<{
         inputTokens: z.ZodNumber;
         outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNullable<z.ZodNumber>;
         stepNumber: z.ZodNumber;
     }, z.core.$strip>>;
     startedAt: z.ZodISODateTime;
@@ -61,11 +63,13 @@ export declare const blazingAgentsChatMessageMetadataSchema: z.ZodObject<{
             metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             modelId: z.ZodString;
             outputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNullable<z.ZodNumber>;
             turnId: z.ZodString;
             sessionId: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>;
             stepUsages: z.ZodArray<z.ZodObject<{
                 inputTokens: z.ZodNumber;
                 outputTokens: z.ZodNumber;
+                reasoningTokens: z.ZodNullable<z.ZodNumber>;
                 stepNumber: z.ZodNumber;
             }, z.core.$strip>>;
             startedAt: z.ZodISODateTime;
@@ -96,19 +100,10 @@ type ExclusivePromptInput<Literal extends object> = (Literal & {
 /**
  * `POST /v1/agents/{agentId}/sessions` (create) and
  * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
- * The platform mints the `ss_` session id on the create path and returns
- * it via the `Location` header; the URL presence (no id → create, id
- * present → resume) is the mode — there is no `id` or `mode` field here.
- * `message` is the literal input; the prompt-invocation alternative
- * (`promptId` + `variables`) is mutually exclusive with `message` — both
- * present or neither → 400 invalid_request. `variables` is only allowed
- * on the prompt-invocation path: a request carrying both `message` and
- * `variables` (without `promptId`) is a mixed shape and is rejected
- * (strict both ways). The route layer resolves the prompt template,
- * renders, and substitutes a server-constructed user `UIMessage` with a
- * single text part carrying the rendered string. `trigger` /
- * `messageId` are turn-level concerns (regenerate rides on the resume
- * route only — enforced by the route layer, not the schema).
+ * The URL selects the mode; on create the platform mints the `ss_` id and
+ * returns it in `Location`. Exactly one of `message` or `promptId` is
+ * required, and `variables` requires `promptId`. Regenerate is resume-only,
+ * enforced by the route layer rather than this schema.
  */
 export declare const chatRequestBodySchema: z.ZodObject<{
     message: z.ZodOptional<z.ZodUnknown>;

package/dist/contracts/entities/chat.js

@@ -31,12 +31,14 @@ export const usageSummarySchema = z
     metadata: z.record(z.string(), z.unknown()),
     modelId: agentModelIdSchema,
     outputTokens: z.number().int().min(0),
+    reasoningTokens: z.number().int().min(0).nullable(),
     turnId: turnIdSchema,
     sessionId: z.union([sessionIdSchema, z.literal("")]),
     stepUsages: z.array(z
         .object({
         inputTokens: z.number().int().min(0),
         outputTokens: z.number().int().min(0),
+        reasoningTokens: z.number().int().min(0).nullable(),
         stepNumber: z.number().int().min(0),
     })
         .strip()),
@@ -61,19 +63,10 @@ export const promptVariablesSchema = z.record(z.string(), z.string());
 /**
  * `POST /v1/agents/{agentId}/sessions` (create) and
  * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
- * The platform mints the `ss_` session id on the create path and returns
- * it via the `Location` header; the URL presence (no id → create, id
- * present → resume) is the mode — there is no `id` or `mode` field here.
- * `message` is the literal input; the prompt-invocation alternative
- * (`promptId` + `variables`) is mutually exclusive with `message` — both
- * present or neither → 400 invalid_request. `variables` is only allowed
- * on the prompt-invocation path: a request carrying both `message` and
- * `variables` (without `promptId`) is a mixed shape and is rejected
- * (strict both ways). The route layer resolves the prompt template,
- * renders, and substitutes a server-constructed user `UIMessage` with a
- * single text part carrying the rendered string. `trigger` /
- * `messageId` are turn-level concerns (regenerate rides on the resume
- * route only — enforced by the route layer, not the schema).
+ * The URL selects the mode; on create the platform mints the `ss_` id and
+ * returns it in `Location`. Exactly one of `message` or `promptId` is
+ * required, and `variables` requires `promptId`. Regenerate is resume-only,
+ * enforced by the route layer rather than this schema.
  */
 export const chatRequestBodySchema = z
     .object({
@@ -89,11 +82,8 @@ export const chatRequestBodySchema = z
     messageId: z.string().min(1).optional(),
     version: agentVersionNumberSchema.optional(),
     /**
-     * End-user attribution for the session + this turn's usage
-     * (ADR-0001). `userId` is opaque text (`''` = tenant-level); it stamps
-     * the session row at lazy materialization (create path) and every
-     * `token_usage_*` row this turn records. `metadata` is a mutable jsonb
-     * object carried onto the same rows. Both default to tenant-level.
+     * End-user attribution (ADR-0001), stamped on the Session at lazy
+     * materialization and on every usage row this Turn records.
      */
     userId: userIdSchema.default(""),
     metadata: metadataSchema.default({}),

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

@@ -36,9 +36,8 @@ export declare const providerSchema: z.ZodObject<{
     updatedAt: z.ZodISODateTime;
 }, z.core.$strict>;
 /**
- * Wire response — `GET /v1/providers/{id}` shape per
- * ticket 12: `{ id, name, providerType, baseUrl, keyFragment, createdAt,
- * updatedAt }`. The Vault pointer and tenant id are write-only/internal.
+ * `GET /v1/providers/{id}` wire response. The Vault pointer and tenant id
+ * stay internal.
  */
 export declare const providerResponseSchema: z.ZodObject<{
     id: z.ZodString;

package/dist/contracts/entities/providers.js

@@ -39,9 +39,8 @@ export const providerSchema = z
 })
     .strict();
 /**
- * Wire response — `GET /v1/providers/{id}` shape per
- * ticket 12: `{ id, name, providerType, baseUrl, keyFragment, createdAt,
- * updatedAt }`. The Vault pointer and tenant id are write-only/internal.
+ * `GET /v1/providers/{id}` wire response. The Vault pointer and tenant id
+ * stay internal.
  */
 export const providerResponseSchema = z
     .object({

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

@@ -1,10 +1,7 @@
 import { z } from "zod";
 /**
- * `GET /v1/agents/{agentId}/sessions` list item — the public wire shape:
- * `{ id, agentVersion, createdAt, updatedAt, messageCount,
- * lastMessagePreview, userId, metadata }`. `agentId`/`tenantId` are internal
- * (used for filtering) and never leak to the wire. `userId`/`metadata` are
- * stamped at lazy materialization (the first successful turn's attribution).
+ * `GET /v1/agents/{agentId}/sessions` list item. `agentId`/`tenantId` never
+ * leak to the wire; `userId`/`metadata` come from the first successful Turn.
  */
 export declare const sessionListItemSchema: z.ZodObject<{
     agentVersion: z.ZodNullable<z.ZodNumber>;

package/dist/contracts/entities/sessions.js

@@ -6,11 +6,8 @@ import { toolReferenceSchema } from "./agent-approval.js";
 import { agentSchema, agentVersionNumberSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
 /**
- * `GET /v1/agents/{agentId}/sessions` list item — the public wire shape:
- * `{ id, agentVersion, createdAt, updatedAt, messageCount,
- * lastMessagePreview, userId, metadata }`. `agentId`/`tenantId` are internal
- * (used for filtering) and never leak to the wire. `userId`/`metadata` are
- * stamped at lazy materialization (the first successful turn's attribution).
+ * `GET /v1/agents/{agentId}/sessions` list item. `agentId`/`tenantId` never
+ * leak to the wire; `userId`/`metadata` come from the first successful Turn.
  */
 export const sessionListItemSchema = z
     .object({
@@ -75,7 +72,6 @@ export const sessionMessagesResponseSchema = z
     latestCursor: z.string().nullable(),
 })
     .strip();
-// Query params for the messages endpoint.
 export const sessionMessagesQuerySchema = z
     .object({
     limit: z

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

@@ -212,6 +212,7 @@ export declare const taskListItemSchema: z.ZodObject<{
         }>;
         finishedAt: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strip>>;
+    nextFireAt: z.ZodNullable<z.ZodISODateTime>;
 }, z.core.$strip>;
 export declare const tasksListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
@@ -259,6 +260,7 @@ export declare const tasksListResponseSchema: z.ZodObject<{
             }>;
             finishedAt: z.ZodNullable<z.ZodISODateTime>;
         }, z.core.$strip>>;
+        nextFireAt: z.ZodNullable<z.ZodISODateTime>;
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
@@ -301,6 +303,10 @@ export declare const taskResponseSchema: z.ZodObject<{
     createdAt: z.ZodISODateTime;
     updatedAt: z.ZodISODateTime;
 }, z.core.$strip>;
+/**
+ * Task run record. `userId`/`metadata` are copied from the task at enqueue
+ * and carried onto the run's Session and usage facts.
+ */
 export declare const taskRunSchema: z.ZodObject<{
     id: z.ZodString;
     taskId: z.ZodString;
@@ -422,6 +428,10 @@ export declare const createTaskResponseSchema: z.ZodObject<{
 export declare const createTaskRunResponseSchema: z.ZodObject<{
     runId: z.ZodString;
 }, z.core.$strip>;
+/**
+ * `GET .../runs/{runId}/messages` — the run transcript plus `status`,
+ * `error`, and `finishedAt`, so one poll loop can follow the run.
+ */
 export declare const taskRunMessagesResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
         id: z.ZodString;

package/dist/contracts/entities/tasks.js

@@ -126,8 +126,7 @@ export const createTaskBodySchema = z
     metadata: metadataSchema.default({}),
 })
     .strict();
-// `PATCH /v1/tasks/{taskId}` — name/prompt/schedule/enabled/metadata;
-// agentId + userId immutable.
+// `PATCH /v1/tasks/{taskId}` — `agentId` and `userId` are immutable.
 export const updateTaskBodySchema = z
     .object({
     agentVersion: agentVersionNumberSchema.nullable().optional(),
@@ -200,6 +199,7 @@ export const taskLatestRunSchema = z
     .strip();
 export const taskListItemSchema = taskSchema.extend({
     latestRun: taskLatestRunSchema.nullable(),
+    nextFireAt: z.iso.datetime({ offset: true }).nullable(),
 });
 export const tasksListResponseSchema = paginatedResponseSchema(taskListItemSchema);
 export const tasksListQuerySchema = z
@@ -210,9 +210,10 @@ export const tasksListQuerySchema = z
 })
     .strict();
 export const taskResponseSchema = taskSchema;
-// Task run record. `userId`/`metadata` are inherited from the task at
-// enqueue (immutable thereafter); the run's session and usage facts carry
-// the same attribution.
+/**
+ * Task run record. `userId`/`metadata` are copied from the task at enqueue
+ * and carried onto the run's Session and usage facts.
+ */
 export const taskRunSchema = z
     .object({
     id: taskRunIdSchema,
@@ -249,9 +250,10 @@ export const createTaskRunResponseSchema = z
     runId: taskRunIdSchema,
 })
     .strip();
-// `GET .../runs/{runId}/messages` — task-run session transcript, paginated,
-// plus `status`, `error`, and `finishedAt` for a single client poll loop.
-// `latestCursor` remains the tail position for the next `?after=` request.
+/**
+ * `GET .../runs/{runId}/messages` — the run transcript plus `status`,
+ * `error`, and `finishedAt`, so one poll loop can follow the run.
+ */
 export const taskRunMessagesResponseSchema = sessionMessagesResponseSchema
     .extend({
     error: z.string().nullable(),

package/dist/contracts/ids.d.ts

@@ -58,3 +58,4 @@ export declare const apiKeyFragmentSchema: z.ZodString;
 export declare const providerKeyFragmentSchema: z.ZodString;
 export type TurnId = z.infer<typeof turnIdSchema>;
 export declare const chatConnectionIdSchema: z.ZodString;
+export declare const chatDeliveryIdSchema: z.ZodString;

package/dist/contracts/ids.js

@@ -84,3 +84,4 @@ export const apiKeyFragmentSchema = z.string().regex(/^ba_[0-9A-Za-z]{2}$/);
 // Provider key fragment — last 4 chars of the secret, display-only.
 export const providerKeyFragmentSchema = z.string().min(1).max(4);
 export const chatConnectionIdSchema = z.string().regex(/^cc_[0-9A-Za-z]{16}$/);
+export const chatDeliveryIdSchema = z.string().regex(/^cd_[0-9A-Za-z]{16}$/);

package/dist/contracts/index.d.ts

@@ -7,11 +7,11 @@ export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsLis
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.ts";
 export type { PromptVariables, UsageSummary } from "./entities/chat.ts";
 export { blazingAgentsChatMessageMetadataSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, generationRequestBodySchema, jsonSchemaShapeSchema, promptVariablesSchema, usageSummarySchema, } from "./entities/chat.ts";
-export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, rotateChatConnectionBodySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.ts";
+export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatDeliveriesResponseSchema, chatDeliveryListStatusSchema, chatDeliverySchema, chatDeliveryStatusSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, rotateChatConnectionBodySchema, tenantChatDeliverySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.ts";
 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, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.ts";
+export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptSchema, 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";

package/dist/contracts/index.js

@@ -6,11 +6,11 @@ export { agentResponseSchema, agentSchema, agentStatusSchema, agentsResponseSche
 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";
-export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, rotateChatConnectionBodySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.js";
+export { chatConfigurationSchema, chatConnectionSchema, chatConnectionsResponseSchema, chatCredentialsSchema, chatDeliveriesResponseSchema, chatDeliveryListStatusSchema, chatDeliverySchema, chatDeliveryStatusSchema, chatHealthCheckSchema, chatHealthSchema, chatIdentitySchema, createChatConnectionBodySchema, rotateChatConnectionBodySchema, tenantChatDeliverySchema, updateChatConnectionBodySchema, } from "./entities/chat-connections.js";
 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, promptResponseSchema, promptSchema, promptsResponseSchema, updatePromptBodySchema, } from "./entities/prompts.js";
+export { createPromptBodySchema, parsePromptVariables, promptResponseSchema, promptSchema, 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";

package/dist/contracts/limitations.d.ts

@@ -7,14 +7,9 @@
  */
 export declare const MAX_API_KEYS_PER_TENANT = 5;
 export declare const MAX_API_KEY_NAME_LENGTH = 80;
-/**
- * API key token shape — `ba_` + 40 base62 chars (~230 bits entropy).
- * The prefix and body/fragment lengths live in `ids.ts` alongside the
- * generators and schemas.
- */
+/** API key token shape — `ba_` + 40 base62 chars (~230 bits entropy). */
 export declare const API_KEY_BODY_LENGTH = 40;
 export declare const API_KEY_FRAGMENT_BODY_LENGTH = 2;
-/** Workspaces. */
 export declare const MAX_WORKSPACE_NAME_LENGTH = 80;
 export declare const MAX_WORKSPACE_ARCHIVE_ENTRIES = 16384;
 export declare const DEFAULT_WORKSPACES_LIST_LIMIT = 50;

package/dist/contracts/limitations.js

@@ -7,15 +7,10 @@
  */
 export const MAX_API_KEYS_PER_TENANT = 5;
 export const MAX_API_KEY_NAME_LENGTH = 80;
-/**
- * API key token shape — `ba_` + 40 base62 chars (~230 bits entropy).
- * The prefix and body/fragment lengths live in `ids.ts` alongside the
- * generators and schemas.
- */
+/** API key token shape — `ba_` + 40 base62 chars (~230 bits entropy). */
 export const API_KEY_BODY_LENGTH = 40;
 // Display fragment — `ba_` + first 2 chars of the random body.
 export const API_KEY_FRAGMENT_BODY_LENGTH = 2;
-/** Workspaces. */
 export const MAX_WORKSPACE_NAME_LENGTH = 80;
 export const MAX_WORKSPACE_ARCHIVE_ENTRIES = 16_384;
 export const DEFAULT_WORKSPACES_LIST_LIMIT = 50;

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

@@ -1,16 +1,25 @@
 import { type ChatTransport, DefaultChatTransport, type UIMessage } from "ai";
 import type { BlazingAgents } from "./client.ts";
-export interface BlazingAgentsDirectChatTransportOptions {
+export type BlazingAgentsDirectChatTransportOptions = {
     agentId: string;
-    client: BlazingAgents;
+    getClient: () => BlazingAgents | Promise<BlazingAgents>;
+    metadata?: Record<string, unknown>;
     /** Receives the Session ID before the response stream is consumed. */
     onSessionId?: (sessionId: string) => Promise<void> | void;
     sessionId?: string;
-}
+    userId?: string;
+    version?: number;
+} & ({
+    promptId: string;
+    variables?: Record<string, string>;
+} | {
+    promptId?: never;
+    variables?: never;
+});
 /** 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>;
+    reconnectToStream(_input: Parameters<ChatTransport<UI_MESSAGE>["reconnectToStream"]>[0]): Promise<ReadableStream<import("ai").UIMessageChunk<unknown, import("ai").UIDataTypes>> | null>;
 }

package/dist/direct-chat-transport.js

@@ -1,4 +1,4 @@
-import { DefaultChatTransport } from "ai";
+import { DefaultChatTransport, isToolUIPart, lastAssistantMessageIsCompleteWithApprovalResponses, } from "ai";
 import { sessionIdSchema } from "./contracts/ids.js";
 /** Connects useChat directly to the SDK, including native streaming fetch clients. */
 export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
@@ -16,19 +16,55 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
         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 last = input.messages.at(-1);
+        if (last?.role === "assistant" &&
+            lastAssistantMessageIsCompleteWithApprovalResponses({
+                messages: input.messages,
+            })) {
+            return await this.#sendApprovalContinuation(input, last);
         }
-        const result = await this.#options.client.chat({
+        const client = await this.#options.getClient();
+        const common = {
             agentId: this.#options.agentId,
-            message,
             messageId: input.messageId,
-            ...(this.#sessionId === undefined
-                ? { trigger: "submit-message" }
-                : { sessionId: this.#sessionId, trigger: input.trigger }),
             abortSignal: input.abortSignal,
-        });
+        };
+        let result;
+        if (this.#sessionId === undefined) {
+            const create = {
+                ...common,
+                trigger: "submit-message",
+                version: this.#options.version,
+                userId: this.#options.userId,
+                metadata: this.#options.metadata,
+            };
+            if (this.#options.promptId === undefined) {
+                const message = input.messages.findLast((item) => item.role === "user");
+                if (!message) {
+                    throw new Error("Chat submission requires a user message.");
+                }
+                result = await client.chat({ ...create, message });
+            }
+            else {
+                result = await client.chat({
+                    ...create,
+                    promptId: this.#options.promptId,
+                    variables: this.#options.variables,
+                });
+            }
+        }
+        else {
+            const message = input.messages.findLast((item) => item.role === "user");
+            if (!message) {
+                throw new Error("Chat submission requires a user message.");
+            }
+            result = await client.chat({
+                ...common,
+                message,
+                sessionId: this.#sessionId,
+                trigger: input.trigger,
+            });
+        }
         const stream = result.toStream();
         try {
             const sessionId = await result.sessionId;
@@ -43,7 +79,52 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
         }
         return this.processResponseStream(stream);
     }
-    reconnectToStream(_input) {
-        return Promise.resolve(null);
+    async reconnectToStream(_input) {
+        if (this.#sessionId === undefined) {
+            return null;
+        }
+        const { continuation } = await (await this.#options.getClient()).sessions.toolApprovals({
+            agentId: this.#options.agentId,
+            sessionId: this.#sessionId,
+        });
+        if (continuation?.state !== "queued" && continuation?.state !== "running") {
+            return null;
+        }
+        const result = await (await this.#options.getClient()).sessions.joinToolApprovalContinuation({
+            agentId: this.#options.agentId,
+            sessionId: this.#sessionId,
+            continuationId: continuation.id,
+        });
+        return this.processResponseStream(result.toStream());
+    }
+    async #sendApprovalContinuation(input, last) {
+        if (this.#sessionId === undefined) {
+            throw new Error("Tool approval requires an existing Session.");
+        }
+        const lastStep = last.parts.findLastIndex((part) => part.type === "step-start");
+        let continuationId;
+        for (const part of last.parts.slice(lastStep + 1)) {
+            if (isToolUIPart(part) && part.state === "approval-responded") {
+                const decision = await (await this.#options.getClient()).sessions.decideToolApproval({
+                    agentId: this.#options.agentId,
+                    sessionId: this.#sessionId,
+                    approvalId: part.approval.id,
+                    approved: part.approval.approved,
+                    reason: part.approval.reason,
+                    abortSignal: input.abortSignal,
+                });
+                continuationId = decision.continuationId;
+            }
+        }
+        if (continuationId === undefined) {
+            throw new Error("Tool approval response is missing an approval.");
+        }
+        const continuation = await (await this.#options.getClient()).sessions.joinToolApprovalContinuation({
+            agentId: this.#options.agentId,
+            sessionId: this.#sessionId,
+            continuationId,
+            abortSignal: input.abortSignal,
+        });
+        return this.processResponseStream(continuation.toStream());
     }
 }

package/dist/generation.js

@@ -2,7 +2,6 @@ import { createTextStreamResponse, parsePartialJson } from "ai";
 import { sessionIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
 import { requestStream } from "./http.js";
-// --- chat ---
 export async function chat(config, input) {
     const body = buildChatBody(input);
     /**
@@ -259,7 +258,6 @@ function buildStatelessGenerationBody(input, output) {
     }
     return body;
 }
-// --- completion ---
 export async function completion(config, input) {
     const body = buildStatelessGenerationBody(input, { type: "text" });
     const path = `/v1/agents/${input.agentId}/generation`;
@@ -280,11 +278,6 @@ function buildCompletionResult(response) {
         }
         return text;
     })();
-    /**
-     * Attach a no-op rejection handler so the promise doesn't trigger an
-     * unhandled-rejection warning if the caller only uses `textStream` or
-     * `toResponse()` without awaiting `text`.
-     */
     textPromise.catch(() => {
         /* no-op — prevents unhandled rejection if the caller never awaits */
     });
@@ -295,7 +288,6 @@ function buildCompletionResult(response) {
         toResponse,
     };
 }
-// --- object ---
 export async function objectGeneration(config, input) {
     const body = buildStatelessGenerationBody(input, {
         type: "object",
@@ -360,7 +352,6 @@ function buildObjectResult(response) {
         toResponse,
     };
 }
-// --- helpers ---
 function buildStatelessGenerationStreams(response, resourceName) {
     const requestId = response.headers.get("x-request-id") ?? undefined;
     const location = response.headers.get("location");

package/dist/http.js

@@ -4,12 +4,6 @@ const DIAGNOSTIC_BODY_LIMIT_BYTES = 64 * 1024;
 const INVALID_RESPONSE_MESSAGE = "The server returned an invalid response.";
 const NETWORK_ERROR_MESSAGE = "Network request failed (fetch threw before any HTTP exchange).";
 const REQUEST_ABORTED_MESSAGE = "The request was aborted before any HTTP response.";
-/**
- * The fetch client — a thin wrapper in the stripe/openai-node shape.
- * `apiKey` rides the `Authorization: Bearer ${apiKey}` header; `baseUrl`
- * defaults to `DEFAULT_BASE_URL` in `client.ts`
- * (`https://api.blazingagents.com`). No OpenAI wire compatibility.
- */
 function buildUrl(baseUrl, path, query) {
     const url = `${baseUrl}${path}`;
     if (!query) {

package/dist/index.d.ts

@@ -2,9 +2,6 @@
  * `@blazingagents/sdk` — the resource-style client SDK for the
  * Blazing Agents `/v1` API. `ai` is a peer dependency (`^7`);
  * `UIMessage` is re-exported from `ai`, never redeclared.
- *
- * This is the package's entry point — a barrel file that re-exports the
- * public surface from the internal modules.
  */
 export type { UIMessage } from "ai";
 export { BlazingAgentsChatTransport, type BlazingAgentsChatTransportOptions, } from "./chat-transport.ts";
@@ -12,7 +9,7 @@ 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 { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse, } from "./contracts/entities/artifacts.ts";
-export type { ChatConfiguration, ChatConnection, ChatConnectionsResponse, ChatCredentials, ChatHealth, ChatIdentity, CreateChatConnectionBody, RotateChatConnectionBody, UpdateChatConnectionBody, } from "./contracts/entities/chat-connections.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 { CreateProviderBody, ProviderListItem, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, ThinkingLevelsResponse, UpdateProviderBody, } from "./contracts/entities/providers.ts";
@@ -23,4 +20,4 @@ export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetw
 export { BlazingAgentsDirectChatTransport, type BlazingAgentsDirectChatTransportOptions, } from "./direct-chat-transport.ts";
 export { BlazingAgentsError } from "./errors.ts";
 export { createChatRelay, createCompletionRelay, type RelayContext, type SessionOwnershipStore, } from "./relay.ts";
-export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, AgentVersionsListOptions, ArtifactsResource, AttributionInput, BlazingAgentsErrorCode, BlazingAgentsOptions, BlazingAgentsRequestOptions, BlazingAgentsUIMessage, BlazingAgentsUIMessageChunk, ChatConnectionsResource, 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, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";

package/dist/index.js

@@ -2,9 +2,6 @@
  * `@blazingagents/sdk` — the resource-style client SDK for the
  * Blazing Agents `/v1` API. `ai` is a peer dependency (`^7`);
  * `UIMessage` is re-exported from `ai`, never redeclared.
- *
- * This is the package's entry point — a barrel file that re-exports the
- * public surface from the internal modules.
  */
 // biome-ignore lint/performance/noBarrelFile: package entry point
 export { BlazingAgentsChatTransport, } from "./chat-transport.js";

package/dist/resources/chat-deliveries.d.ts

@@ -0,0 +1,6 @@
+import type { ChatDeliveriesResource, HttpConfig } from "../types.ts";
+/**
+ * `client.chatDeliveries` — `GET /v1/chat-deliveries`, the Tenant-wide
+ * delivery feed across all Chat Connections, newest first.
+ */
+export declare function createChatDeliveriesResource(config: HttpConfig): ChatDeliveriesResource;

package/dist/resources/chat-deliveries.js

@@ -0,0 +1,20 @@
+import { chatDeliveriesResponseSchema } from "../contracts/entities/chat-connections.js";
+import { requestJson } from "../http.js";
+/**
+ * `client.chatDeliveries` — `GET /v1/chat-deliveries`, the Tenant-wide
+ * delivery feed across all Chat Connections, newest first.
+ */
+export function createChatDeliveriesResource(config) {
+    return {
+        async list({ abortSignal, status, ...query } = {}) {
+            return await requestJson(config, "/v1/chat-deliveries", {
+                query: {
+                    ...query,
+                    // Multi-value filters serialize as one comma-separated parameter.
+                    status: status?.length ? status.join(",") : undefined,
+                },
+                signal: abortSignal,
+            }, chatDeliveriesResponseSchema);
+        },
+    };
+}

package/dist/types.d.ts

@@ -3,7 +3,7 @@ import type { ApiErrorCode } from "./contracts/api.ts";
 import type { Agent, AgentsResponse, AgentVersion, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody } from "./contracts/entities/agents.ts";
 import type { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse } from "./contracts/entities/artifacts.ts";
 import type { BlazingAgentsChatMessageMetadata } from "./contracts/entities/chat.ts";
-import type { ChatConnection, ChatConnectionsResponse, CreateChatConnectionBody, RotateChatConnectionBody, UpdateChatConnectionBody } from "./contracts/entities/chat-connections.ts";
+import type { ChatConnection, ChatConnectionsResponse, ChatDeliveriesResponse, ChatDeliveryListStatus, CreateChatConnectionBody, RotateChatConnectionBody, UpdateChatConnectionBody } from "./contracts/entities/chat-connections.ts";
 import type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionsResponse, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody } from "./contracts/entities/mcp-connections.ts";
 import type { CreateMemoryBody, MemoriesListResponse, MemoryResponse, UpdateMemoryBody } from "./contracts/entities/memories.ts";
 import type { CreateMerchantConnectionBody, MerchantBindingResponse, MerchantBindingsResponse, MerchantConnectionResponse, MerchantUsageEventResponse, MerchantUsageEventStatus, MerchantUsageEventsResponse, MerchantUsageSummaryResponse, UpdateMerchantConnectionBody, UpsertMerchantBindingBody } from "./contracts/entities/merchant.ts";
@@ -19,11 +19,7 @@ export type KnownBlazingAgentsErrorCode = ApiErrorCode | "invalid_response" | "n
 export type BlazingAgentsErrorCode = KnownBlazingAgentsErrorCode | (string & {});
 export type BlazingAgentsFetch = (input: string, init?: BlazingAgentsRequestInit) => Promise<Response>;
 export interface BlazingAgentsRequestInit extends RequestInit {
-    /**
-     * The SDK never sends multipart bodies via the global `FormData`; the
-     * skill upload path passes a `FormData` instance directly. This slot
-     * exists only so the type carries the union cleanly.
-     */
+    /** Widened so multipart uploads can pass a `FormData` body. */
     body?: BodyInit | FormData | null;
 }
 export interface RequestOptions {
@@ -34,11 +30,6 @@ export interface RequestOptions {
      * automatically by `fetch` when given a `FormData` body).
      */
     headers?: Record<string, string>;
-    /**
-     * JSON body (object — serialized by the helper) or `undefined` for
-     * GET/DELETE. Multipart uploads bypass this and pass `FormData` via
-     * `extra.body`.
-     */
     json?: unknown;
     method?: string;
     /**
@@ -600,4 +591,19 @@ export interface ChatConnectionsResource {
         chatConnectionId: string;
     } & ResourceRequestOptions): Promise<ChatConnection>;
 }
+export interface ChatDeliveriesListOptions extends ResourceRequestOptions {
+    cursor?: string;
+    limit?: number;
+    /** ISO 8601 date-time; inclusive lower bound on `createdAt`. */
+    since?: string;
+    /** `failed` and/or `ambiguous`; omitted means both. */
+    status?: readonly ChatDeliveryListStatus[];
+}
+/**
+ * `client.chatDeliveries` — the Tenant's deliveries across all Chat
+ * Connections behind `GET /v1/chat-deliveries`, newest first.
+ */
+export interface ChatDeliveriesResource {
+    list(input?: ChatDeliveriesListOptions): Promise<ChatDeliveriesResponse>;
+}
 export {};

package/package.json

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