@blazingagents/sdk 0.22.0 → 0.24.0

package/dist/chat-transport.d.ts

@@ -5,6 +5,12 @@ export type BlazingAgentsChatTransportOptions<UI_MESSAGE extends UIMessage = UIM
      * @param sessionId - Session to look up or record.
      */
     onSessionId?: (sessionId: string) => Promise<void> | void;
+    /**
+     * Receives the running Turn ID from each response that names one, before
+     * its stream is consumed. Pass it to Stop.
+     * @param turnId - Turn the response runs.
+     */
+    onTurnId?: (turnId: string) => Promise<void> | void;
     /** An authorized Session ID used to resume after a remount or reload. */
     sessionId?: string;
 };

package/dist/chat-transport.js

@@ -1,6 +1,6 @@
 import { lastAssistantMessageIsCompleteWithApprovalResponses, } from "ai";
 import { ChatStreamTransport } from "./chat-stream-transport.js";
-import { sessionIdSchema } from "./contracts/ids.js";
+import { sessionIdSchema, turnIdSchema } from "./contracts/ids.js";
 /**
  * Adapts AI SDK chat requests to the Blazing Agents backend-relay shape and
  * resumes with the server-minted Session ID returned in `Location`.
@@ -13,27 +13,34 @@ export class BlazingAgentsChatTransport {
      * @param options - Configuration for this operation.
      */
     constructor(options = {}) {
-        const { onSessionId, sessionId, ...transportOptions } = options;
+        const { onSessionId, onTurnId, sessionId, ...transportOptions } = options;
         const transportFetch = transportOptions.fetch ?? globalThis.fetch;
         this.#sessionId =
             sessionId === undefined ? undefined : sessionIdSchema.parse(sessionId);
         this.#transport = new ChatStreamTransport({
             ...transportOptions,
-            /** Reads the first Session ID from Location before returning the response. */
+            /** Reads the first Session ID and each Turn ID before returning the response. */
             fetch: async (input, init) => {
                 const response = await transportFetch(input, init);
-                if (response.ok && this.#sessionId === undefined) {
-                    try {
+                if (!response.ok) {
+                    return response;
+                }
+                try {
+                    if (this.#sessionId === undefined) {
                         const location = response.headers.get("location");
                         const candidate = location?.split("/").pop();
                         this.#sessionId = sessionIdSchema.parse(candidate);
                         await onSessionId?.(this.#sessionId);
                     }
-                    catch (error) {
-                        await response.body?.cancel(error).catch(() => undefined);
-                        throw error;
+                    const turnId = turnIdSchema.safeParse(response.headers.get("x-ba-turn-id"));
+                    if (turnId.success) {
+                        await onTurnId?.(turnId.data);
                     }
                 }
+                catch (error) {
+                    await response.body?.cancel(error).catch(() => undefined);
+                    throw error;
+                }
                 return response;
             },
             /** Selects the user message or complete approval round for the relay request. */

package/dist/contracts/entities/spending-limits.d.ts

@@ -53,7 +53,6 @@ export declare const spendingLimitResponseSchema: z.ZodObject<{
         availableUsd: z.ZodNumber;
     }, z.core.$strict>>;
     nextResetAt: z.ZodNullable<z.ZodISODateTime>;
-    scheduleChangeAt: z.ZodNullable<z.ZodISODateTime>;
 }, z.core.$strict>;
 export declare const spendingLimitStopDetailsSchema: z.ZodObject<{
     scope: z.ZodEnum<{
@@ -76,7 +75,6 @@ export type SpendingLimit = z.infer<typeof spendingLimitSchema>;
 export type SpendingLimitResponse = z.infer<typeof spendingLimitResponseSchema>;
 export type SpendingLimitStopDetails = z.infer<typeof spendingLimitStopDetailsSchema>;
 export type UpdateSpendingLimitBody = z.infer<typeof updateSpendingLimitBodySchema>;
-/** A schedule edit uses the active period end as `after` for its first new boundary. */
 export declare function nextSpendingLimitReset(schedule: Pick<SpendingLimit, "resetStartDate" | "resetInterval">, after: string | Date): string;
 export declare const spendingLimitStopEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"data-model-spending-limit">;

package/dist/contracts/entities/spending-limits.js

@@ -34,7 +34,6 @@ export const spendingLimitResponseSchema = z
     spendingLimit: spendingLimitSchema.nullable(),
     period: spendingLimitPeriodSchema.nullable(),
     nextResetAt: z.iso.datetime({ offset: true }).nullable(),
-    scheduleChangeAt: z.iso.datetime({ offset: true }).nullable(),
 })
     .strict()
     .meta({ id: "ModelSpendingLimitStatus" });
@@ -48,7 +47,6 @@ export const spendingLimitStopDetailsSchema = z
     nextResetAt: z.iso.datetime({ offset: true }).nullable(),
 })
     .strict();
-/** A schedule edit uses the active period end as `after` for its first new boundary. */
 export function nextSpendingLimitReset(schedule, after) {
     const anchor = new Date(`${schedule.resetStartDate}T00:00:00.000Z`);
     const instant = new Date(after).getTime();

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

@@ -17,6 +17,12 @@ export type BlazingAgentsDirectChatTransportOptions = {
      * @param sessionId - Session to look up or record.
      */
     onSessionId?: (sessionId: string) => Promise<void> | void;
+    /**
+     * Receives the running Turn ID before the response stream is consumed.
+     * Pass it to Stop.
+     * @param turnId - Turn the response runs.
+     */
+    onTurnId?: (turnId: string) => Promise<void> | void;
     sessionId?: string;
     userId?: string;
 } & ({

package/dist/direct-chat-transport.js

@@ -96,7 +96,8 @@ export class BlazingAgentsDirectChatTransport extends ChatStreamTransport {
         return this.#processChatResult(result);
     }
     /**
-     * Claims the chat stream and records the first Session ID before decoding chunks.
+     * Claims the chat stream and records the first Session ID and the Turn ID
+     * before decoding chunks.
      */
     async #processChatResult(result) {
         const stream = result.toStream();
@@ -106,6 +107,7 @@ export class BlazingAgentsDirectChatTransport extends ChatStreamTransport {
                 this.#sessionId = sessionId;
                 await this.#options.onSessionId?.(sessionId);
             }
+            await this.#reportTurnId(result);
         }
         catch (error) {
             await stream.cancel(error).catch(() => undefined);
@@ -141,6 +143,21 @@ export class BlazingAgentsDirectChatTransport extends ChatStreamTransport {
             decisions,
             functions: this.#options.functions ?? {},
         });
-        return this.processResponseStream(continuation.toStream());
+        const stream = continuation.toStream();
+        try {
+            await this.#reportTurnId(continuation);
+        }
+        catch (error) {
+            await stream.cancel(error).catch(() => undefined);
+            throw error;
+        }
+        return this.processResponseStream(stream);
+    }
+    /** Reports the Turn ID when the response names one. */
+    async #reportTurnId(result) {
+        const turnId = await result.turnId.catch(() => undefined);
+        if (turnId !== undefined) {
+            await this.#options.onTurnId?.(turnId);
+        }
     }
 }

package/dist/generation.js

@@ -1,5 +1,5 @@
 import { createTextStreamResponse, parsePartialJson } from "ai";
-import { sessionIdSchema } from "./contracts/ids.js";
+import { sessionIdSchema, turnIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
 import { dispatchChatFunctions, toChatFunctionDefinitions, } from "./functions.js";
 import { requestStream } from "./http.js";
@@ -165,12 +165,24 @@ function buildChatResult(config, response, resumeSessionId, dispatch) {
     sessionIdPromise.catch(() => {
         /* no-op — prevents unhandled rejection if the caller never awaits */
     });
+    const turnId = turnIdSchema.safeParse(response.headers.get("x-ba-turn-id"));
+    const turnIdPromise = turnId.success
+        ? Promise.resolve(turnId.data)
+        : Promise.reject(new BlazingAgentsError({
+            code: "stream_error",
+            message: "The server did not return a valid turn id (X-BA-Turn-Id header).",
+            requestId: response.headers.get("x-request-id") ?? undefined,
+        }, { cause: turnId.error }));
+    turnIdPromise.catch(() => {
+        /* no-op — prevents unhandled rejection if the caller never awaits */
+    });
     const { functions } = dispatch;
     const streamResponse = functions && sessionId !== undefined
         ? withFilteredBody(response, (body) => dispatchChatFunctions(config, { ...dispatch, functions, sessionId }, body))
         : response;
     return {
         sessionId: sessionIdPromise,
+        turnId: turnIdPromise,
         ...buildTerminalStreamResult(streamResponse, "chat"),
     };
 }
@@ -183,6 +195,7 @@ function buildChatResult(config, response, resumeSessionId, dispatch) {
 export function buildTerminalStreamResult(response, resourceName, filter) {
     const requestId = response.headers.get("x-request-id") ?? undefined;
     const location = response.headers.get("location");
+    const turnId = response.headers.get("x-ba-turn-id");
     let bodyClaimed = false;
     /**
      * Claims the response body once and normalizes stream failures.
@@ -207,7 +220,7 @@ export function buildTerminalStreamResult(response, resourceName, filter) {
         toStream: claimBody,
         /** Claims the response relay once. */
         toResponse: () => {
-            const headers = replacementResponseHeaders(requestId, location);
+            const headers = replacementResponseHeaders(requestId, location, turnId);
             headers.set("content-type", "text/event-stream");
             headers.set("cache-control", "no-cache");
             headers.set("connection", "keep-alive");
@@ -318,7 +331,7 @@ function responseBodyStream(response, requestId, resourceName) {
 /**
  * Copies request correlation and Session location into relay response headers.
  */
-function replacementResponseHeaders(requestId, location) {
+function replacementResponseHeaders(requestId, location, turnId) {
     const headers = new Headers();
     if (requestId !== undefined) {
         headers.set("x-request-id", requestId);
@@ -326,6 +339,9 @@ function replacementResponseHeaders(requestId, location) {
     if (location !== null) {
         headers.set("location", location);
     }
+    if (turnId !== null) {
+        headers.set("x-ba-turn-id", turnId);
+    }
     return headers;
 }
 /**
@@ -501,7 +517,7 @@ function buildStatelessGenerationStreams(response, resourceName) {
                 }, { cause: new Error(message) });
             }
             responseBodyClaimed = true;
-            const headers = replacementResponseHeaders(requestId, location);
+            const headers = replacementResponseHeaders(requestId, location, null);
             headers.set("content-type", "text/plain; charset=utf-8");
             try {
                 return createTextStreamResponse({

package/dist/types.d.ts

@@ -200,6 +200,12 @@ export interface ChatResult {
      * @throws BlazingAgentsError - If the response body has already been claimed.
      */
     toStream: () => ReadableStream<Uint8Array>;
+    /**
+     * Resolves to the id of the Turn this response runs, read from the
+     * `X-BA-Turn-Id` header. Pass it to `sessions.stop()` to stop the Turn.
+     * Rejects with `stream_error` when the header is missing or malformed.
+     */
+    turnId: Promise<string>;
 }
 export interface TerminalStreamResult {
     requestId?: string;

package/package.json

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