@blazingagents/sdk 0.12.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
 

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;

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()),

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>;

package/dist/contracts/entities/tasks.js

@@ -199,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

package/dist/contracts/index.d.ts

@@ -11,7 +11,7 @@ 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, 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

@@ -10,7 +10,7 @@ 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, 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/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/package.json

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