@blazingagents/sdk 0.18.0 → 0.20.0

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

@@ -216,14 +216,14 @@ export declare const sessionMessagesQuerySchema: z.ZodObject<{
     cursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     after: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
-/** Decision-only input for one server-owned Tool approval. */
-export declare const decideToolApprovalBodySchema: z.ZodObject<{
+/** One decision in the current Tool approval round. */
+export declare const toolApprovalDecisionSchema: z.ZodObject<{
+    approvalId: z.ZodString;
     approved: z.ZodBoolean;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const toolApprovalContinuationStateSchema: z.ZodEnum<{
     failed: "failed";
-    queued: "queued";
     running: "running";
     succeeded: "succeeded";
     waiting: "waiting";
@@ -273,7 +273,6 @@ export declare const toolApprovalContinuationSchema: z.ZodObject<{
     id: z.ZodString;
     state: z.ZodEnum<{
         failed: "failed";
-        queued: "queued";
         running: "running";
         succeeded: "succeeded";
         waiting: "waiting";
@@ -325,23 +324,23 @@ export declare const toolApprovalsResponseSchema: z.ZodObject<{
         id: z.ZodString;
         state: z.ZodEnum<{
             failed: "failed";
-            queued: "queued";
             running: "running";
             succeeded: "succeeded";
             waiting: "waiting";
         }>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export declare const toolApprovalDecisionResponseSchema: z.ZodObject<{
-    continuationId: z.ZodString;
-    state: z.ZodEnum<{
-        failed: "failed";
-        queued: "queued";
-        running: "running";
-        succeeded: "succeeded";
-        waiting: "waiting";
-    }>;
-}, z.core.$strip>;
+export declare const continueToolApprovalsBodySchema: z.ZodObject<{
+    decisions: z.ZodArray<z.ZodObject<{
+        approvalId: z.ZodString;
+        approved: z.ZodBoolean;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    functions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        inputSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 export type SessionListItem = z.infer<typeof sessionListItemSchema>;
 export type SessionResponse = z.infer<typeof sessionResponseSchema>;
 export type SessionsListResponse = z.infer<typeof sessionsListResponseSchema>;
@@ -350,8 +349,8 @@ export type LatestSessionsListResponse = z.infer<typeof latestSessionsListRespon
 export type SessionMessage = z.infer<typeof sessionMessageSchema>;
 export type SessionMessagesResponse = z.infer<typeof sessionMessagesResponseSchema>;
 export type SessionMessagesQuery = z.infer<typeof sessionMessagesQuerySchema>;
-export type DecideToolApprovalBody = z.infer<typeof decideToolApprovalBodySchema>;
+export type ToolApprovalDecision = z.infer<typeof toolApprovalDecisionSchema>;
+export type ContinueToolApprovalsBody = z.infer<typeof continueToolApprovalsBodySchema>;
 export type ToolApprovalContinuationState = z.infer<typeof toolApprovalContinuationStateSchema>;
 export type ToolApprovalState = z.infer<typeof toolApprovalStateSchema>;
 export type ToolApprovalsResponse = z.infer<typeof toolApprovalsResponseSchema>;
-export type ToolApprovalDecisionResponse = z.infer<typeof toolApprovalDecisionResponseSchema>;

package/dist/contracts/entities/sessions.js

@@ -5,6 +5,7 @@ import { DEFAULT_SESSION_MESSAGES_LIMIT, MAX_SESSION_MESSAGES_LIMIT, } from "../
 import { toolExecutionReferenceSchema } from "./agent-approval.js";
 import { agentConfigSchema, agentSchema } from "./agents.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
+import { chatFunctionDefinitionsSchema } from "./chat.js";
 /**
  * `GET /v1/agents/{agentId}/sessions` list item. `agentId`/`tenantId` never
  * leak to the wire; `userId`/`metadata` come from the first successful Turn.
@@ -90,16 +91,16 @@ export const sessionMessagesQuerySchema = z
     message: "cursor and after are mutually exclusive.",
     path: ["after"],
 });
-/** Decision-only input for one server-owned Tool approval. */
-export const decideToolApprovalBodySchema = z
+/** One decision in the current Tool approval round. */
+export const toolApprovalDecisionSchema = z
     .object({
+    approvalId: z.string().min(1),
     approved: z.boolean(),
     reason: z.string().trim().min(1).max(1000).optional(),
 })
     .strict();
 export const toolApprovalContinuationStateSchema = z.enum([
     "waiting",
-    "queued",
     "running",
     "succeeded",
     "failed",
@@ -130,9 +131,13 @@ export const toolApprovalsResponseSchema = z
     continuation: toolApprovalContinuationSchema.nullable(),
 })
     .strip();
-export const toolApprovalDecisionResponseSchema = z
+export const continueToolApprovalsBodySchema = z
     .object({
-    continuationId: z.string().min(1),
-    state: toolApprovalContinuationStateSchema,
+    decisions: z
+        .array(toolApprovalDecisionSchema)
+        .min(1)
+        .refine((decisions) => new Set(decisions.map((decision) => decision.approvalId)).size ===
+        decisions.length, { message: "Approval IDs must be distinct." }),
+    functions: chatFunctionDefinitionsSchema.optional(),
 })
-    .strip();
+    .strict();

package/dist/contracts/index.d.ts

@@ -7,17 +7,17 @@ export { agentConfigSchema, agentResponseSchema, agentSchema, agentStatusSchema,
 export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.ts";
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.ts";
 export type { ChatFunctionCallEvent, ChatFunctionDefinition, ChatFunctionDefinitions, ChatFunctionOutcome, ClaimChatFunctionBody, PromptVariables, ResolveChatFunctionBody, UsageSummary, } from "./entities/chat.ts";
-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.ts";
+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, usageSummarySchema, } from "./entities/chat.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, parsePromptVariables, promptResponseSchema, promptSchema, promptsListQuerySchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.ts";
 export { createProviderBodySchema, providerListItemSchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.ts";
-export type { ResumeSessionInputsResponse, RunSessionInputsBody, SessionActivity, SessionInput, SessionInputMode, SessionInputResponse, SessionInputState, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody, } from "./entities/session-inputs.ts";
-export { resumeSessionInputsResponseSchema, runSessionInputsBodySchema, sessionActivitySchema, sessionInputModeSchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputSchema, sessionInputStateSchema, sessionInputsQuerySchema, sessionInputsResponseSchema, stopSessionBodySchema, stopSessionResponseSchema, submitSessionInputBodySchema, } from "./entities/session-inputs.ts";
-export type { ToolApprovalDecisionResponse, ToolApprovalsResponse, } from "./entities/sessions.ts";
-export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.ts";
+export type { ChatSteerConsumedEvent, SessionActivity, SessionInput, SessionInputResponse, SessionInputState, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody, } from "./entities/session-inputs.ts";
+export { chatSteerConsumedEventSchema, sessionActivitySchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputSchema, sessionInputStateSchema, sessionInputsQuerySchema, sessionInputsResponseSchema, stopSessionBodySchema, stopSessionResponseSchema, submitSessionInputBodySchema, } from "./entities/session-inputs.ts";
+export type { ContinueToolApprovalsBody, ToolApprovalContinuationState, ToolApprovalDecision, ToolApprovalsResponse, } from "./entities/sessions.ts";
+export { continueToolApprovalsBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.ts";
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";
 export { createTaskBodySchema, createTaskResponseSchema, createTaskRunBodySchema, createTaskRunResponseSchema, taskCronConfigSchema, taskIntervalConfigSchema, taskListItemSchema, taskOnceConfigSchema, taskResponseSchema, taskRunMessagesResponseSchema, taskRunResponseSchema, taskRunSchema, taskRunStatusSchema, taskRunsListResponseSchema, taskScheduleInputSchema, taskScheduleKindSchema, taskSchema, tasksListResponseSchema, updateTaskBodySchema, } from "./entities/tasks.ts";
 export { quotaSchema, subscriptionStatusSchema, tenantDeletionSchema, tenantResponseSchema, tenantSchema, tenantSettingsResponseSchema, updateTenantSettingsBodySchema, } from "./entities/tenants.ts";

package/dist/contracts/index.js

@@ -6,15 +6,15 @@ export { chatFunctionNameSchema } from "./entities/agent-tools.js";
 export { agentConfigSchema, agentResponseSchema, agentSchema, agentStatusSchema, agentsListQuerySchema, agentsResponseSchema, createAgentBodySchema, updateAgentBodySchema, } from "./entities/agents.js";
 export { artifactDownloadUrlResponseSchema, artifactListItemSchema, artifactsListResponseSchema, } from "./entities/artifacts.js";
 export { attributionCreateInputSchema, metadataSchema, } from "./entities/attribution.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 { 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, 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, promptsListQuerySchema, promptsResponseSchema, promptTemplateSchema, renderPromptTemplate, updatePromptBodySchema, } from "./entities/prompts.js";
 export { createProviderBodySchema, providerListItemSchema, providerModelsResponseSchema, providerResponseSchema, providersResponseSchema, providerTypeSchema, thinkingLevelsResponseSchema, updateProviderBodySchema, } from "./entities/providers.js";
-export { resumeSessionInputsResponseSchema, runSessionInputsBodySchema, sessionActivitySchema, sessionInputModeSchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputSchema, sessionInputStateSchema, sessionInputsQuerySchema, sessionInputsResponseSchema, stopSessionBodySchema, stopSessionResponseSchema, submitSessionInputBodySchema, } from "./entities/session-inputs.js";
-export { decideToolApprovalBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionResponseSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.js";
+export { chatSteerConsumedEventSchema, sessionActivitySchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputSchema, sessionInputStateSchema, sessionInputsQuerySchema, sessionInputsResponseSchema, stopSessionBodySchema, stopSessionResponseSchema, submitSessionInputBodySchema, } from "./entities/session-inputs.js";
+export { continueToolApprovalsBodySchema, latestSessionListItemSchema, latestSessionsListResponseSchema, sessionListItemSchema, sessionMessageSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalContinuationStateSchema, toolApprovalDecisionSchema, toolApprovalStateSchema, toolApprovalsResponseSchema, } from "./entities/sessions.js";
 export { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.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";

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

@@ -22,13 +22,10 @@ export type BlazingAgentsDirectChatTransportOptions = {
 export declare class BlazingAgentsDirectChatTransport<UI_MESSAGE extends UIMessage = UIMessage> extends DefaultChatTransport<UI_MESSAGE> {
     #private;
     constructor(options: BlazingAgentsDirectChatTransportOptions);
-    joinInputTurn(input: {
-        turnId: string;
-        abortSignal?: AbortSignal;
-    }): Promise<ReadableStream<import("ai").UIMessageChunk<unknown, import("ai").UIDataTypes>>>;
-    runInputs(input?: {
+    sendUserMessages(input: {
+        messages: UI_MESSAGE[];
         abortSignal?: AbortSignal;
     }): Promise<ReadableStream<import("ai").UIMessageChunk<unknown, import("ai").UIDataTypes>>>;
     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<ReadableStream<import("ai").UIMessageChunk<unknown, import("ai").UIDataTypes>> | null>;
+    reconnectToStream(_input: Parameters<ChatTransport<UI_MESSAGE>["reconnectToStream"]>[0]): Promise<null>;
 }

package/dist/direct-chat-transport.js

@@ -1,5 +1,5 @@
 import { DefaultChatTransport, lastAssistantMessageIsCompleteWithApprovalResponses, } from "ai";
-import { decideApprovalResponses } from "./approvals.js";
+import { extractApprovalDecisions } 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 {
@@ -13,31 +13,17 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
                 ? undefined
                 : sessionIdSchema.parse(options.sessionId);
     }
-    async joinInputTurn(input) {
-        if (this.#sessionId === undefined) {
-            throw new Error("Input Turn attachment requires an existing Session.");
-        }
+    async sendUserMessages(input) {
         const client = await this.#options.getClient();
-        const result = await client.sessions.joinInputTurn({
+        const result = await client.chat({
             ...input,
             agentId: this.#options.agentId,
             sessionId: this.#sessionId,
             functions: this.#options.functions,
+            userId: this.#options.userId,
+            metadata: this.#options.metadata,
         });
-        return this.processResponseStream(result.toStream());
-    }
-    async runInputs(input = {}) {
-        if (this.#sessionId === undefined) {
-            throw new Error("Input batch admission requires an existing Session.");
-        }
-        const client = await this.#options.getClient();
-        const result = await client.sessions.runInputs({
-            ...input,
-            agentId: this.#options.agentId,
-            sessionId: this.#sessionId,
-            functions: this.#options.functions,
-        });
-        return this.processResponseStream(result.toStream());
+        return this.#processChatResult(result);
     }
     async sendMessages(input) {
         if (input.trigger === "regenerate-message" && !this.#sessionId) {
@@ -92,6 +78,9 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
                 trigger: input.trigger,
             });
         }
+        return this.#processChatResult(result);
+    }
+    async #processChatResult(result) {
         const stream = result.toStream();
         try {
             const sessionId = await result.sessionId;
@@ -106,25 +95,8 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
         }
         return this.processResponseStream(stream);
     }
-    async reconnectToStream(_input) {
-        if (this.#sessionId === undefined) {
-            return null;
-        }
-        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 client.resumeChat({
-            agentId: this.#options.agentId,
-            sessionId: this.#sessionId,
-            continuationId: continuation.id,
-            functions: this.#options.functions ?? {},
-        });
-        return this.processResponseStream(result.toStream());
+    reconnectToStream(_input) {
+        return Promise.resolve(null);
     }
     async #sendApprovalContinuation(input, last) {
         if (this.#sessionId === undefined) {
@@ -136,16 +108,10 @@ export class BlazingAgentsDirectChatTransport extends DefaultChatTransport {
             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 client.resumeChat({
+        const decisions = extractApprovalDecisions(last);
+        const continuation = await client.continueChat({
             ...target,
-            continuationId,
+            decisions,
             functions: this.#options.functions ?? {},
         });
         return this.processResponseStream(continuation.toStream());

package/dist/generation.d.ts

@@ -1,6 +1,6 @@
-import type { ChatInput, ChatResult, CompletionInput, CompletionResult, HttpConfig, ObjectInput, ObjectResult, ResumeChatInput, TerminalStreamResult } from "./types.ts";
+import type { ChatInput, ChatResult, CompletionInput, CompletionResult, ContinueChatInput, HttpConfig, ObjectInput, ObjectResult, TerminalStreamResult } from "./types.ts";
 export declare function chat(config: HttpConfig, input: ChatInput): Promise<ChatResult>;
-export declare function resumeChat(config: HttpConfig, input: ResumeChatInput): Promise<ChatResult>;
+export declare function continueChat(config: HttpConfig, input: ContinueChatInput): 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`.

package/dist/generation.js

@@ -1,9 +1,8 @@
 import { createTextStreamResponse, parsePartialJson } from "ai";
-import { toolApprovalsResponseSchema } from "./contracts/entities/sessions.js";
 import { sessionIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
 import { dispatchChatFunctions, toChatFunctionDefinitions, } from "./functions.js";
-import { requestJson, requestStream } from "./http.js";
+import { requestStream } from "./http.js";
 export async function chat(config, input) {
     const body = buildChatBody(input);
     if (input.functions && Object.keys(input.functions).length > 0) {
@@ -30,14 +29,17 @@ export async function chat(config, input) {
         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: {},
+export async function continueChat(config, input) {
+    const response = await requestStream(config, `/v1/agents/${input.agentId}/sessions/${input.sessionId}/tool-approvals/continue`, {
+        json: {
+            decisions: input.decisions,
+            ...(input.functions === undefined
+                ? {}
+                : { functions: toChatFunctionDefinitions(input.functions) }),
+        },
         method: "POST",
         clientRequestId: input.clientRequestId,
-        ...(input.abortSignal ? { signal: input.abortSignal } : {}),
+        signal: input.abortSignal,
     });
     return buildChatResult(config, response, input.sessionId, {
         agentId: input.agentId,
@@ -45,16 +47,6 @@ export async function resumeChat(config, input) {
         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`.
@@ -80,7 +72,10 @@ function buildChatBody(input) {
         base.messageId = input.messageId;
     }
     if ("message" in input) {
-        base.message = input.message;
+        base.messages = [input.message];
+    }
+    else if ("messages" in input) {
+        base.messages = input.messages;
     }
     else {
         base.promptId = input.promptId;

package/dist/index.d.ts

@@ -15,8 +15,8 @@ export type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResp
 export type { CreateMerchantConnectionBody, MerchantBindingResponse, MerchantBindingsResponse, MerchantConnection, MerchantConnectionResponse, MerchantCustomerBinding, MerchantGuard, MerchantProviderKind, MerchantUsageEvent, MerchantUsageEventResponse, MerchantUsageEventStatus, MerchantUsageEventsResponse, MerchantUsageSummary, MerchantUsageSummaryResponse, UpdateMerchantConnectionBody, UpsertMerchantBindingBody, } from "./contracts/entities/merchant.ts";
 export type { CreatePromptBody, PromptResponse, PromptsListQuery, PromptsResponse, UpdatePromptBody, } from "./contracts/entities/prompts.ts";
 export type { CreateProviderBody, ProviderListItem, ProviderModel, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ProviderType, ThinkingLevelsResponse, UpdateProviderBody, } from "./contracts/entities/providers.ts";
-export type { ResumeSessionInputsResponse, RunSessionInputsBody, SessionActivity, SessionInput, SessionInputMode, SessionInputResponse, SessionInputState, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody, } from "./contracts/entities/session-inputs.ts";
-export type { SessionResponse, ToolApprovalDecisionResponse, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.ts";
+export type { ChatSteerConsumedEvent, SessionActivity, SessionInput, SessionInputResponse, SessionInputState, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody, } from "./contracts/entities/session-inputs.ts";
+export type { ContinueToolApprovalsBody, SessionResponse, ToolApprovalDecision, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.ts";
 export { sessionResponseSchema } from "./contracts/entities/sessions.ts";
 export type { CreateSkillBody, Skill, SkillArchiveType, SkillCopyResult, SkillCopyResults, SkillDetail, SkillFile, SkillsListResponse, } from "./contracts/entities/skills.ts";
 export type { SessionUsageQuery, SessionUsageResponse, UsageBucket, UsageOverviewQuery, UsageOverviewResponse, UsageTotals, } from "./contracts/entities/usage.ts";
@@ -25,4 +25,4 @@ export { BlazingAgentsDirectChatTransport, type BlazingAgentsDirectChatTransport
 export { BlazingAgentsError } from "./errors.ts";
 export { type ChatFunction, type ChatFunctionContext, type ChatFunctions, defineFunction, } from "./functions.ts";
 export { createChatRelay, createCompletionRelay, type RelayContext, type SessionOwnershipStore, } from "./relay.ts";
-export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, 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, ResumeChatInput, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, UserClient, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";
+export type { AgentClient, AgentSkillsResource, AgentsListOptions, AgentsResource, ArtifactsResource, AttributionInput, BlazingAgentsErrorCode, BlazingAgentsOptions, BlazingAgentsRequestOptions, BlazingAgentsUIMessage, BlazingAgentsUIMessageChunk, ChatConnectionsResource, ChatDeliveriesListOptions, ChatDeliveriesResource, ChatInput, ChatMessageInput, ChatMessagesInput, ChatPromptInput, ChatResult, ChatTrigger, CompletionInput, CompletionPromptIdInput, CompletionPromptInput, CompletionResult, ContinueChatInput, KnownBlazingAgentsErrorCode, LatestSessionsListOptions, McpConnectionsResource, MemoriesListOptions, MemoriesResource, MerchantBindingsListOptions, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsListOptions, MerchantUsageEventsResource, ObjectInput, ObjectPromptIdInput, ObjectPromptInput, ObjectResult, PromptsResource, ProvidersResource, ResourceRequestOptions, ResponseObservation, SessionsResource, SkillsListOptions, TasksResource, TenantResource, TerminalStreamResult, UsageResource, UserClient, WorkspacesListOptions, WorkspacesResource, } from "./types.ts";

package/dist/relay.d.ts

@@ -2,7 +2,7 @@ import type { BlazingAgents } from "./client.ts";
 import type { ChatFunctions } from "./functions.ts";
 export interface RelayContext {
     agentId: string;
-    /** Handlers for this authenticated request; they also resume approved continuations. */
+    /** Handlers for this authenticated request and its approved continuation. */
     functions?: ChatFunctions;
     metadata?: Record<string, unknown>;
     userId: string;
@@ -17,9 +17,9 @@ interface RelayOptions<Method extends keyof BlazingAgents> {
 }
 /**
  * Relays useChat submissions. An assistant message carrying approval
- * responses records each decision and then streams the continuation.
+ * responses submits the complete round and streams the continuation.
  */
-export declare function createChatRelay(options: RelayOptions<"chat" | "resumeChat" | "sessions"> & {
+export declare function createChatRelay(options: RelayOptions<"chat" | "continueChat"> & {
     sessions: SessionOwnershipStore;
 }): (request: Request) => Promise<Response>;
 export declare function createCompletionRelay(options: RelayOptions<"completion">): (request: Request) => Promise<Response>;

package/dist/relay.js

@@ -1,6 +1,6 @@
 import { safeValidateUIMessages } from "ai";
 import { z } from "zod";
-import { decideApprovalResponses } from "./approvals.js";
+import { extractApprovalDecisions } from "./approvals.js";
 import { sessionIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
 const chatBodySchema = z.object({
@@ -14,7 +14,7 @@ const chatBodySchema = z.object({
 const completionBodySchema = z.object({ prompt: z.string().trim().min(1) });
 /**
  * Relays useChat submissions. An assistant message carrying approval
- * responses records each decision and then streams the continuation.
+ * responses submits the complete round and streams the continuation.
  */
 export function createChatRelay(options) {
     return async (request) => {
@@ -44,6 +44,9 @@ export function createChatRelay(options) {
                     sessionId: body.sessionId,
                 });
             }
+            if (message.role !== "user") {
+                return errorResponse(400, "invalid_request", "Chat submission requires a user message.");
+            }
             const chatInput = {
                 agentId: context.agentId,
                 functions: context.functions,
@@ -92,17 +95,13 @@ async function relayApprovalResponses(client, { functions, message, request, ...
         sessionId: input.sessionId,
         abortSignal: request.signal,
     };
-    const continuationId = await decideApprovalResponses(client, {
-        ...target,
-        message,
-    });
-    if (continuationId === undefined) {
+    const decisions = extractApprovalDecisions(message);
+    if (decisions.length === 0) {
         return errorResponse(400, "invalid_request", "The message has no tool approval responses.");
     }
-    /** An absent registry still resumes, so missing handlers become tool errors instead of a stalled observer. */
-    const continuation = await client.resumeChat({
+    const continuation = await client.continueChat({
         ...target,
-        continuationId,
+        decisions,
         functions: functions ?? {},
     });
     return continuation.toResponse();

package/dist/resources/sessions.js

@@ -1,9 +1,7 @@
-import { resumeSessionInputsResponseSchema, sessionInputRequestIdSchema, sessionInputResponseSchema, sessionInputsResponseSchema, stopSessionResponseSchema, } from "../contracts/entities/session-inputs.js";
-import { latestSessionsListResponseSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalDecisionResponseSchema, toolApprovalsResponseSchema, } from "../contracts/entities/sessions.js";
+import { sessionInputResponseSchema, sessionInputsResponseSchema, stopSessionResponseSchema, } from "../contracts/entities/session-inputs.js";
+import { latestSessionsListResponseSchema, sessionMessagesResponseSchema, sessionResponseSchema, sessionsListResponseSchema, toolApprovalsResponseSchema, } from "../contracts/entities/sessions.js";
 import { agentIdSchema, sessionIdSchema, turnIdSchema, } from "../contracts/ids.js";
-import { dispatchChatFunctions, stripFunctionEvents, toChatFunctionDefinitions, } from "../functions.js";
-import { buildTerminalStreamResult, withFilteredBody } from "../generation.js";
-import { requestJson, requestStream } from "../http.js";
+import { requestJson } from "../http.js";
 /**
  * `client.sessions` reads, paginates, and deletes Sessions under
  * `/v1/agents/:agentId/sessions`. Pagination is manual: the SDK returns
@@ -12,38 +10,12 @@ import { requestJson, requestStream } from "../http.js";
  */
 export function createSessionsResource(config) {
     return {
-        async joinInputTurn({ agentId, sessionId, turnId, functions, abortSignal, }) {
-            const response = await requestStream(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/input-turns/${turnIdSchema.parse(turnId)}`, { signal: abortSignal });
-            return buildTerminalStreamResult(response, "input Turn", (body) => functions
-                ? dispatchChatFunctions(config, { agentId, sessionId, functions, abortSignal }, body)
-                : stripFunctionEvents(body));
-        },
-        async runInputs({ agentId, sessionId, functions, abortSignal }) {
-            const response = await requestStream(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/inputs/run`, {
-                method: "POST",
-                json: functions === undefined
-                    ? {}
-                    : { functions: toChatFunctionDefinitions(functions) },
-                signal: abortSignal,
-            });
-            return buildTerminalStreamResult(response, "input Turn", (body) => functions
-                ? dispatchChatFunctions(config, { agentId, sessionId, functions, abortSignal }, body)
-                : stripFunctionEvents(body));
-        },
         async submitInput({ agentId, sessionId, abortSignal, ...body }) {
             return await requestJson(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/inputs`, { method: "POST", json: body, signal: abortSignal }, sessionInputResponseSchema);
         },
         async inputs({ agentId, sessionId, abortSignal, ...query }) {
             return await requestJson(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/inputs`, { query, signal: abortSignal }, sessionInputsResponseSchema);
         },
-        async promoteInput({ agentId, sessionId, requestId, abortSignal }) {
-            const inputId = sessionInputRequestIdSchema.parse(requestId);
-            return await requestJson(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/inputs/${encodeURIComponent(inputId)}/promote`, { method: "POST", signal: abortSignal }, sessionInputResponseSchema);
-        },
-        async deleteInput({ agentId, sessionId, requestId, abortSignal }) {
-            const inputId = sessionInputRequestIdSchema.parse(requestId);
-            return await requestJson(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/inputs/${encodeURIComponent(inputId)}`, { method: "DELETE", signal: abortSignal }, sessionInputResponseSchema);
-        },
         async stop({ agentId, sessionId, turnId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/stop`, {
                 method: "POST",
@@ -51,19 +23,9 @@ export function createSessionsResource(config) {
                 signal: abortSignal,
             }, stopSessionResponseSchema);
         },
-        async resumeInputs({ agentId, sessionId, abortSignal }) {
-            return await requestJson(config, `/v1/agents/${agentIdSchema.parse(agentId)}/sessions/${sessionIdSchema.parse(sessionId)}/inputs/resume`, { method: "POST", signal: abortSignal }, resumeSessionInputsResponseSchema);
-        },
         async get({ agentId, sessionId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}`, { signal: abortSignal }, sessionResponseSchema);
         },
-        async decideToolApproval({ agentId, sessionId, approvalId, abortSignal, ...decision }) {
-            return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approvals/${approvalId}`, {
-                json: decision,
-                method: "POST",
-                signal: abortSignal,
-            }, toolApprovalDecisionResponseSchema);
-        },
         async list({ agentId, ...options }) {
             return await requestJson(config, `/v1/agents/${agentId}/sessions`, {
                 signal: options.abortSignal,
@@ -99,11 +61,6 @@ export function createSessionsResource(config) {
                 },
             }, sessionMessagesResponseSchema);
         },
-        async joinToolApprovalContinuation({ agentId, sessionId, continuationId, abortSignal, }) {
-            const response = await requestStream(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approval-continuations/${continuationId}`, { signal: abortSignal });
-            /** Observers never execute calls; private events are removed unclaimed. */
-            return buildTerminalStreamResult(withFilteredBody(response, stripFunctionEvents), "continuation");
-        },
         async toolApprovals({ agentId, sessionId, abortSignal }) {
             return await requestJson(config, `/v1/agents/${agentId}/sessions/${sessionId}/tool-approvals`, { signal: abortSignal }, toolApprovalsResponseSchema);
         },