@blazingagents/sdk 0.14.0 → 0.16.0

package/dist/contracts/index.js

@@ -1,21 +1,22 @@
 /** Public runtime schemas for the Blazing Agents HTTP API. */
 // 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 { approvalDecisionSchema, approvalPolicySchema, toolExecutionReferenceSchema, toolReferenceSchema, } from "./entities/agent-approval.js";
+export { chatFunctionNameSchema } from "./entities/agent-tools.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";
+export { blazingAgentsChatMessageMetadataSchema, chatFunctionCallEventSchema, chatFunctionDefinitionSchema, chatFunctionDefinitionsSchema, chatFunctionOutcomeSchema, chatModeSchema, chatRequestBodySchema, chatTriggerSchema, claimChatFunctionBodySchema, claimChatFunctionResponseSchema, generationRequestBodySchema, jsonSchemaShapeSchema, MAX_CHAT_FUNCTION_DEFINITIONS_BYTES, MAX_CHAT_FUNCTION_PAYLOAD_BYTES, MAX_CHAT_FUNCTIONS, promptVariablesSchema, resolveChatFunctionBodySchema, resolveChatFunctionResponseSchema, resumeToolApprovalContinuationBodySchema, usageSummarySchema, } from "./entities/chat.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, 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";
+export { agentIdSchema, apiKeyTokenSchema, functionCallIdSchema, 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/direct-chat-transport.d.ts

@@ -1,7 +1,10 @@
 import { type ChatTransport, DefaultChatTransport, type UIMessage } from "ai";
 import type { BlazingAgents } from "./client.ts";
+import type { ChatFunctions } from "./functions.ts";
 export type BlazingAgentsDirectChatTransportOptions = {
     agentId: string;
+    /** Caller-local functions for every Turn and approved continuation of this chat. */
+    functions?: ChatFunctions;
     getClient: () => BlazingAgents | Promise<BlazingAgents>;
     metadata?: Record<string, unknown>;
     /** Receives the Session ID before the response stream is consumed. */

package/dist/direct-chat-transport.js

@@ -1,4 +1,5 @@
-import { DefaultChatTransport, isToolUIPart, lastAssistantMessageIsCompleteWithApprovalResponses, } from "ai";
+import { DefaultChatTransport, lastAssistantMessageIsCompleteWithApprovalResponses, } from "ai";
+import { decideApprovalResponses } from "./approvals.js";
 import { sessionIdSchema } from "./contracts/ids.js";
 /** Connects useChat directly to the SDK, including native streaming fetch clients. */
 export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
@@ -26,6 +27,7 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
         const client = await this.#options.getClient();
         const common = {
             agentId: this.#options.agentId,
+            functions: this.#options.functions,
             messageId: input.messageId,
             abortSignal: input.abortSignal,
         };
@@ -83,17 +85,19 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
         if (this.#sessionId === undefined) {
             return null;
         }
-        const { continuation } = await (await this.#options.getClient()).sessions.toolApprovals({
+        const client = await this.#options.getClient();
+        const { continuation } = await client.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({
+        const result = await client.resumeChat({
             agentId: this.#options.agentId,
             sessionId: this.#sessionId,
             continuationId: continuation.id,
+            functions: this.#options.functions ?? {},
         });
         return this.processResponseStream(result.toStream());
     }
@@ -101,29 +105,23 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
         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;
-            }
-        }
+        const client = await this.#options.getClient();
+        const target = {
+            agentId: this.#options.agentId,
+            sessionId: this.#sessionId,
+            abortSignal: input.abortSignal,
+        };
+        const continuationId = await decideApprovalResponses(client, {
+            ...target,
+            message: last,
+        });
         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,
+        const continuation = await client.resumeChat({
+            ...target,
             continuationId,
-            abortSignal: input.abortSignal,
+            functions: this.#options.functions ?? {},
         });
         return this.processResponseStream(continuation.toStream());
     }

package/dist/functions.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { type ChatFunctionCallEvent, type ChatFunctionDefinitions } from "./contracts/entities/chat.ts";
+import type { HttpConfig } from "./types.ts";
+export interface ChatFunctionContext {
+    /** The function call ID; a new user resend produces a new key. */
+    idempotencyKey: string;
+    /** Aborts at the call deadline or when the chat stream ends. */
+    signal: AbortSignal;
+}
+export interface ChatFunction<Schema extends z.ZodType = z.ZodType, Output = unknown> {
+    description: string;
+    execute(input: z.output<Schema>, context: ChatFunctionContext): Output | Promise<Output>;
+    inputSchema: Schema;
+}
+export type ChatFunctions = Record<string, ChatFunction>;
+/** Declares a caller-local function whose handler input is inferred from its Zod schema. */
+export declare function defineFunction<Schema extends z.ZodType, Output>(definition: ChatFunction<Schema, Output>): ChatFunction<Schema, Output>;
+export declare function toChatFunctionDefinitions(functions: ChatFunctions): ChatFunctionDefinitions;
+export interface FunctionDispatchTarget {
+    abortSignal?: AbortSignal;
+    agentId: string;
+    functions: ChatFunctions;
+    sessionId: string;
+}
+interface FunctionEventHandlers {
+    onCall?(call: ChatFunctionCallEvent["data"], fail: (error: unknown) => void): void;
+    onCancel?(): void;
+    onEnd?(): void;
+}
+/**
+ * Reads native SSE eagerly and returns it without private function events,
+ * so slow consumers never delay a call. A recognized but malformed event
+ * fails the stream.
+ */
+export declare function stripFunctionEvents(body: ReadableStream<Uint8Array>, { onCall, onCancel, onEnd }?: FunctionEventHandlers): ReadableStream<Uint8Array>;
+/** Strips private function events and executes claimed calls without blocking the read loop. */
+export declare function dispatchChatFunctions(config: HttpConfig, target: FunctionDispatchTarget, body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+export {};

package/dist/functions.js

@@ -0,0 +1,299 @@
+import { z } from "zod";
+import { chatFunctionCallEventSchema, chatFunctionDefinitionsSchema, chatFunctionOutcomeSchema, claimChatFunctionResponseSchema, resolveChatFunctionResponseSchema, } from "./contracts/entities/chat.js";
+import { BlazingAgentsError } from "./errors.js";
+import { requestJson } from "./http.js";
+/** Declares a caller-local function whose handler input is inferred from its Zod schema. */
+export function defineFunction(definition) {
+    return definition;
+}
+export function toChatFunctionDefinitions(functions) {
+    try {
+        return chatFunctionDefinitionsSchema.parse(Object.fromEntries(Object.entries(functions).map(([name, fn]) => {
+            const { $schema: _, ...inputSchema } = z.toJSONSchema(fn.inputSchema, { io: "input" });
+            return [name, { description: fn.description, inputSchema }];
+        })));
+    }
+    catch (cause) {
+        throw new BlazingAgentsError({
+            code: "invalid_request",
+            message: `Invalid chat functions: ${cause instanceof z.ZodError ? z.prettifyError(cause) : String(cause)}`,
+        }, { cause });
+    }
+}
+const EVENT_BOUNDARY = /\r\n\r\n|\n\n/;
+const LINE_BREAK = /\r?\n/;
+const DELAY_SECONDS = /^\d+$/;
+const FUNCTION_CALL_TYPE = "data-ba-function-call";
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2000;
+/** Results may retry past the deadline to recover an already accepted receipt. */
+const RESULT_RETRY_GRACE_MS = 30_000;
+/**
+ * `undefined` forwards the SSE block unchanged; `null` marks a recognized
+ * but malformed function event.
+ */
+function functionCallFrom(block) {
+    const data = block
+        .split(LINE_BREAK)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(line.startsWith("data: ") ? 6 : 5))
+        .join("\n");
+    if (!data.includes(FUNCTION_CALL_TYPE)) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        /** Unparseable frames naming the private event never reach the browser. */
+        return null;
+    }
+    if (parsed?.type !== FUNCTION_CALL_TYPE) {
+        return;
+    }
+    return chatFunctionCallEventSchema.safeParse(parsed).data ?? null;
+}
+function retryAfterMs(headers) {
+    const value = headers?.get("retry-after");
+    if (!value) {
+        return;
+    }
+    const ms = DELAY_SECONDS.test(value)
+        ? Number(value) * 1000
+        : Date.parse(value) - Date.now();
+    return Number.isNaN(ms) ? undefined : Math.max(0, ms);
+}
+function retryDelayMs({ code, headers, status }, attempt) {
+    const retryable = status === undefined
+        ? code === "network_error"
+        : status === 408 || status === 429 || status >= 500;
+    if (!retryable) {
+        return;
+    }
+    return (retryAfterMs(headers) ??
+        Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS));
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+/**
+ * POSTs one protocol request, retrying transient failures with the same
+ * body until `until` or abort. A 409 is a lost or stale race; other
+ * permanent failures throw.
+ */
+async function postWithRetry(config, path, json, schema, until, signal) {
+    for (let attempt = 1;; attempt += 1) {
+        const remaining = until - Date.now();
+        if (signal.aborted || remaining <= 0) {
+            return "expired";
+        }
+        try {
+            await requestJson(config, path, {
+                json,
+                method: "POST",
+                signal: AbortSignal.any([signal, AbortSignal.timeout(remaining)]),
+            }, schema);
+            return "accepted";
+        }
+        catch (caught) {
+            const next = afterFailure(caught, attempt, until, signal);
+            if (typeof next === "string") {
+                return next;
+            }
+            await sleep(next, signal);
+        }
+    }
+}
+/** Classifies a failed attempt as a lost race, an exhausted budget, or the delay before retrying; permanent failures rethrow. */
+function afterFailure(caught, attempt, until, signal) {
+    const error = BlazingAgentsError.isInstance(caught) ? caught : undefined;
+    if (error?.status === 409) {
+        return "conflict";
+    }
+    if (signal.aborted || Date.now() >= until) {
+        return "expired";
+    }
+    const delay = error && retryDelayMs(error, attempt);
+    if (delay === undefined) {
+        throw caught;
+    }
+    return Date.now() + delay >= until ? "expired" : delay;
+}
+const invalidResult = {
+    kind: "error",
+    message: "Function returned an invalid result.",
+};
+/** Resolves `undefined` when the call became late or aborted before customer code could start. */
+async function execute(functions, { id, name, input }, deadline, signal) {
+    const fn = Object.hasOwn(functions, name) ? functions[name] : undefined;
+    if (fn === undefined) {
+        return { kind: "error", message: `Function ${name} is not available.` };
+    }
+    /** Refinements and transforms are customer code too. */
+    if (signal.aborted || Date.now() >= deadline) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = await fn.inputSchema.safeParseAsync(input);
+    }
+    catch {
+        /** Zod rethrows errors thrown inside refinements and transforms. */
+        return { kind: "error", message: "Invalid function input." };
+    }
+    if (!parsed.success) {
+        return { kind: "error", message: "Invalid function input." };
+    }
+    if (signal.aborted || Date.now() >= deadline) {
+        return;
+    }
+    let value;
+    try {
+        value = await fn.execute(parsed.data, { idempotencyKey: id, signal });
+    }
+    catch {
+        return { kind: "error", message: "Function execution failed." };
+    }
+    try {
+        /** Only plain JSON is accepted; undefined, NaN, Dates and class instances are invalid. */
+        return (chatFunctionOutcomeSchema.safeParse({ kind: "output", value }).data ??
+            invalidResult);
+    }
+    catch {
+        /** Cyclic values fail serialization in the size check. */
+        return invalidResult;
+    }
+}
+/**
+ * Reads native SSE eagerly and returns it without private function events,
+ * so slow consumers never delay a call. A recognized but malformed event
+ * fails the stream.
+ */
+export function stripFunctionEvents(body, { onCall, onCancel, onEnd } = {}) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let output;
+    let finished = false;
+    const fail = (error) => {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        output.error(error);
+        reader.cancel(error).catch(() => undefined);
+    };
+    const handleBlock = (block, raw) => {
+        const call = functionCallFrom(block);
+        if (call === undefined) {
+            if (raw && !finished) {
+                output.enqueue(encoder.encode(raw));
+            }
+        }
+        else if (call === null) {
+            fail(new BlazingAgentsError({
+                code: "stream_error",
+                message: "The server sent a malformed function call event.",
+            }));
+        }
+        else {
+            onCall?.(call.data, fail);
+        }
+    };
+    const pump = async () => {
+        let buffer = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                for (let match = EVENT_BOUNDARY.exec(buffer); match; match = EVENT_BOUNDARY.exec(buffer)) {
+                    const end = match.index + match[0].length;
+                    handleBlock(buffer.slice(0, match.index), buffer.slice(0, end));
+                    buffer = buffer.slice(end);
+                }
+            }
+            handleBlock("", buffer + decoder.decode());
+            if (!finished) {
+                finished = true;
+                output.close();
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            onEnd?.();
+        }
+    };
+    return new ReadableStream({
+        start(controller) {
+            output = controller;
+            pump();
+        },
+        async cancel(reason) {
+            finished = true;
+            onCancel?.();
+            await reader.cancel(reason);
+        },
+    });
+}
+/** Strips private function events and executes claimed calls without blocking the read loop. */
+export function dispatchChatFunctions(config, target, body) {
+    /** Caller abort or consumer cancellation: stops every retry. */
+    const stop = new AbortController();
+    /** Also aborted when the stream ends: stops claims and handlers. */
+    const handlers = new AbortController();
+    const abort = () => stop.abort();
+    stop.signal.addEventListener("abort", () => handlers.abort(), {
+        once: true,
+    });
+    target.abortSignal?.addEventListener("abort", abort, { once: true });
+    if (target.abortSignal?.aborted) {
+        abort();
+    }
+    const dispatched = new Set();
+    const runCall = async (call) => {
+        const path = `/v1/agents/${target.agentId}/sessions/${target.sessionId}/function-calls/${call.id}`;
+        const claimRequestId = crypto.randomUUID();
+        const deadline = Date.parse(call.deadlineAt);
+        const claim = await postWithRetry(config, `${path}/claim`, { claimRequestId }, claimChatFunctionResponseSchema, deadline, handlers.signal);
+        if (claim !== "accepted") {
+            return;
+        }
+        /**
+         * A grant can arrive just before the deadline and be processed after it,
+         * or after abort; `execute` rechecks immediately before customer code.
+         */
+        const outcome = await execute(target.functions, call, deadline, AbortSignal.any([
+            handlers.signal,
+            AbortSignal.timeout(Math.max(0, deadline - Date.now())),
+        ]));
+        if (outcome === undefined) {
+            return;
+        }
+        await postWithRetry(config, `${path}/result`, { claimRequestId, outcome }, resolveChatFunctionResponseSchema, deadline + RESULT_RETRY_GRACE_MS, stop.signal);
+    };
+    return stripFunctionEvents(body, {
+        onCall(call, fail) {
+            if (!dispatched.has(call.id)) {
+                dispatched.add(call.id);
+                runCall(call).catch(fail);
+            }
+        },
+        onCancel: abort,
+        onEnd() {
+            handlers.abort();
+            target.abortSignal?.removeEventListener("abort", abort);
+        },
+    });
+}

package/dist/generation.d.ts

@@ -1,5 +1,11 @@
-import type { ChatInput, ChatResult, CompletionInput, CompletionResult, HttpConfig, ObjectInput, ObjectResult, TerminalStreamResult } from "./types.ts";
+import type { ChatInput, ChatResult, CompletionInput, CompletionResult, HttpConfig, ObjectInput, ObjectResult, ResumeChatInput, TerminalStreamResult } from "./types.ts";
 export declare function chat(config: HttpConfig, input: ChatInput): Promise<ChatResult>;
+export declare function resumeChat(config: HttpConfig, input: ResumeChatInput): Promise<ChatResult>;
+/**
+ * Keeps status and headers while filtering the SSE body. Missing or locked
+ * bodies pass through so the stream result reports them as `stream_error`.
+ */
+export declare function withFilteredBody(response: Response, filter: (body: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>): Response;
 export declare function buildTerminalStreamResult(response: Response, resourceName: string): TerminalStreamResult;
 export declare function completion(config: HttpConfig, input: CompletionInput): Promise<CompletionResult>;
 export declare function objectGeneration(config: HttpConfig, input: ObjectInput): Promise<ObjectResult>;

package/dist/generation.js

@@ -1,9 +1,14 @@
 import { createTextStreamResponse, parsePartialJson } from "ai";
+import { toolApprovalsResponseSchema } from "./contracts/entities/sessions.js";
 import { sessionIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
-import { requestStream } from "./http.js";
+import { dispatchChatFunctions, toChatFunctionDefinitions, } from "./functions.js";
+import { requestJson, requestStream } from "./http.js";
 export async function chat(config, input) {
     const body = buildChatBody(input);
+    if (input.functions && Object.keys(input.functions).length > 0) {
+        body.functions = toChatFunctionDefinitions(input.functions);
+    }
     /**
      * URL presence is the mode: no `sessionId` → create
      * (`POST /v1/agents/:agentId/sessions`, server mints the `ss_` id,
@@ -19,7 +24,50 @@ export async function chat(config, input) {
         clientRequestId: input.clientRequestId,
         ...(input.abortSignal ? { signal: input.abortSignal } : {}),
     });
-    return buildChatResult(response, input.sessionId);
+    return buildChatResult(config, response, input.sessionId, {
+        agentId: input.agentId,
+        functions: input.functions,
+        abortSignal: input.abortSignal,
+    });
+}
+export async function resumeChat(config, input) {
+    const sessionPath = `/v1/agents/${input.agentId}/sessions/${input.sessionId}`;
+    const continuationId = input.continuationId ?? (await activeContinuationId(config, input));
+    const response = await requestStream(config, `${sessionPath}/tool-approval-continuations/${continuationId}/resume`, {
+        json: {},
+        method: "POST",
+        clientRequestId: input.clientRequestId,
+        ...(input.abortSignal ? { signal: input.abortSignal } : {}),
+    });
+    return buildChatResult(config, response, input.sessionId, {
+        agentId: input.agentId,
+        functions: input.functions,
+        abortSignal: input.abortSignal,
+    });
+}
+async function activeContinuationId(config, { agentId, sessionId, abortSignal }) {
+    const { continuation } = await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approvals`, { signal: abortSignal }, toolApprovalsResponseSchema);
+    if (continuation?.state !== "queued" && continuation?.state !== "running") {
+        throw new BlazingAgentsError({
+            code: "not_found",
+            message: "The Session has no tool approval continuation to resume.",
+        });
+    }
+    return continuation.id;
+}
+/**
+ * Keeps status and headers while filtering the SSE body. Missing or locked
+ * bodies pass through so the stream result reports them as `stream_error`.
+ */
+export function withFilteredBody(response, filter) {
+    if (!response.body || response.body.locked) {
+        return response;
+    }
+    return new Response(filter(response.body), {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
 }
 function buildChatBody(input) {
     const base = {};
@@ -83,32 +131,36 @@ function sessionIdFromLocation(response, requestId) {
     }
     return parsed.data;
 }
-function buildChatResult(response, resumeSessionId) {
-    const terminalResult = buildTerminalStreamResult(response, "chat");
+function buildChatResult(config, response, resumeSessionId, dispatch) {
     /**
      * `sessionId` resolves from the `Location` header on create, or to the
      * passed id on resume. Read eagerly (the header is available before the
      * body streams) so awaiting `result.sessionId` does not depend on
      * draining the stream.
      */
-    let sessionIdPromise;
-    if (resumeSessionId === undefined) {
+    let sessionId = resumeSessionId;
+    let sessionIdError;
+    if (sessionId === undefined) {
         try {
-            sessionIdPromise = Promise.resolve(sessionIdFromLocation(response, terminalResult.requestId));
+            sessionId = sessionIdFromLocation(response, response.headers.get("x-request-id") ?? undefined);
         }
         catch (error) {
-            sessionIdPromise = Promise.reject(error);
+            sessionIdError = error;
         }
     }
-    else {
-        sessionIdPromise = Promise.resolve(resumeSessionId);
-    }
+    const sessionIdPromise = sessionId === undefined
+        ? Promise.reject(sessionIdError)
+        : Promise.resolve(sessionId);
     sessionIdPromise.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,
-        ...terminalResult,
+        ...buildTerminalStreamResult(streamResponse, "chat"),
     };
 }
 export function buildTerminalStreamResult(response, resourceName) {

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) {