@blazingagents/sdk 0.19.0 → 0.20.0

package/README.md

@@ -17,7 +17,8 @@ requires Node.js 24 or newer.
 
 - Typed clients for Agents, Workspaces, Skills, Providers, Prompts, Tasks,
   Sessions, Artifacts, Slack and Telegram Chat Connections, usage, Tenant settings, and merchant monetization.
-- Stateful chat and stateless text or structured-object generation.
+- Stateful chat with explicit message batches, steer receipts, and one-call Tool approvals.
+- Stateless text or structured-object generation.
 - Public Zod contracts for validating API requests and responses.
 - Cursor pagination and binary transfers.
 - Request correlation and a typed, forward-compatible error model.
@@ -51,6 +52,21 @@ const result = await client.completion({
 console.log(await result.text);
 ```
 
+For stateful chat, pass one user message or an ordered batch.
+
+```ts
+const chat = await client.chat({
+  agentId: "ag_...",
+  messages: [
+    { id: "first", role: "user", parts: [{ type: "text", text: "Compare the plans." }] },
+    { id: "second", role: "user", parts: [{ type: "text", text: "Include annual pricing." }] },
+  ],
+});
+
+const sessionId = await chat.sessionId;
+return chat.toResponse();
+```
+
 Keep API keys on the server. For browser chat applications, relay `chat()`
 through your backend and use `BlazingAgentsChatTransport` with AI SDK
 `useChat`.

package/dist/approvals.d.ts

@@ -1,15 +1,3 @@
 import { type UIMessage } from "ai";
-import type { BlazingAgents } from "./client.ts";
-interface ApprovalTarget {
-    abortSignal?: AbortSignal;
-    agentId: string;
-    sessionId: string;
-}
-/**
- * Records each approval response in the assistant message's last step and
- * returns the continuation they decide, or `undefined` when there are none.
- */
-export declare function decideApprovalResponses(client: Pick<BlazingAgents, "sessions">, { message, ...target }: ApprovalTarget & {
-    message: UIMessage;
-}): Promise<string | undefined>;
-export {};
+import type { ToolApprovalDecision } from "./contracts/entities/sessions.ts";
+export declare function extractApprovalDecisions(message: UIMessage): ToolApprovalDecision[];

package/dist/approvals.js

@@ -1,20 +1,15 @@
 import { isToolUIPart } from "ai";
-/**
- * Records each approval response in the assistant message's last step and
- * returns the continuation they decide, or `undefined` when there are none.
- */
-export async function decideApprovalResponses(client, { message, ...target }) {
+export function extractApprovalDecisions(message) {
     const lastStep = message.parts.findLastIndex((part) => part.type === "step-start");
-    let continuationId;
-    for (const part of message.parts.slice(lastStep + 1)) {
-        if (isToolUIPart(part) && part.state === "approval-responded") {
-            ({ continuationId } = await client.sessions.decideToolApproval({
-                ...target,
+    return message.parts.slice(lastStep + 1).flatMap((part) => isToolUIPart(part) && part.state === "approval-responded"
+        ? [
+            {
                 approvalId: part.approval.id,
                 approved: part.approval.approved,
-                reason: part.approval.reason,
-            }));
-        }
-    }
-    return continuationId;
+                ...(part.approval.reason === undefined
+                    ? {}
+                    : { reason: part.approval.reason }),
+            },
+        ]
+        : []);
 }

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatConnectionsResource, ChatDeliveriesResource, ChatInput, ChatResult, CompletionInput, CompletionResult, McpConnectionsResource, MemoriesResource, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsResource, ObjectInput, ObjectResult, PromptsResource, ProvidersResource, ResumeChatInput, SessionsResource, TasksResource, TenantResource, UsageResource, UserClient, WorkspacesResource } from "./types.ts";
+import type { AgentClient, AgentsResource, ArtifactsResource, BlazingAgentsOptions, BlazingAgentsRequestOptions, ChatConnectionsResource, ChatDeliveriesResource, ChatInput, ChatResult, CompletionInput, CompletionResult, ContinueChatInput, McpConnectionsResource, MemoriesResource, MerchantBindingsResource, MerchantConnectionResource, MerchantUsageEventsResource, ObjectInput, ObjectResult, PromptsResource, ProvidersResource, SessionsResource, TasksResource, TenantResource, UsageResource, UserClient, WorkspacesResource } from "./types.ts";
 export declare class BlazingAgents {
     private readonly config;
     readonly chatConnections: ChatConnectionsResource;
@@ -30,10 +30,10 @@ export declare class BlazingAgents {
      */
     chat(input: ChatInput): Promise<ChatResult>;
     /**
-     * Reattaches function handlers after human tool approval and starts or
-     * joins the Session's continuation. Returns the continuation SSE relay.
+     * Records a complete Tool approval round and streams its continuation.
+     * Caller-local function handlers apply only to this invocation.
      */
-    resumeChat(input: ResumeChatInput): Promise<ChatResult>;
+    continueChat(input: ContinueChatInput): Promise<ChatResult>;
     /**
      * `POST /v1/agents/:agentId/generation` — stateless one-shot text
      * stream. Returns `textStream` + `await result.text` + `toResponse()`.

package/dist/client.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { chat, completion, objectGeneration, resumeChat, } from "./generation.js";
+import { chat, completion, continueChat, objectGeneration, } from "./generation.js";
 import { createAgentsResource } from "./resources/agents.js";
 import { createArtifactsResource } from "./resources/artifacts.js";
 import { createChatConnectionsResource } from "./resources/chat-connections.js";
@@ -40,7 +40,7 @@ function createUserClient(config) {
         chat: (input) => chat(config, input),
         completion: (input) => completion(config, input),
         object: (input) => objectGeneration(config, input),
-        resumeChat: (input) => resumeChat(config, input),
+        continueChat: (input) => continueChat(config, input),
         withOptions: (options) => createUserClient({ ...config, clientRequestId: options.clientRequestId }),
     };
 }
@@ -108,11 +108,11 @@ export class BlazingAgents {
         return chat(this.config, input);
     }
     /**
-     * Reattaches function handlers after human tool approval and starts or
-     * joins the Session's continuation. Returns the continuation SSE relay.
+     * Records a complete Tool approval round and streams its continuation.
+     * Caller-local function handlers apply only to this invocation.
      */
-    resumeChat(input) {
-        return resumeChat(this.config, input);
+    continueChat(input) {
+        return continueChat(this.config, input);
     }
     /**
      * `POST /v1/agents/:agentId/generation` — stateless one-shot text

package/dist/contracts/api.d.ts

@@ -32,7 +32,6 @@ export declare const apiErrorCodeSchema: z.ZodEnum<{
     function_call_conflict: "function_call_conflict";
     idempotency_conflict: "idempotency_conflict";
     input_idempotency_conflict: "input_idempotency_conflict";
-    input_not_pending: "input_not_pending";
     internal: "internal";
     invalid_cursor: "invalid_cursor";
     invalid_request: "invalid_request";
@@ -82,13 +81,14 @@ export declare const apiErrorCodeSchema: z.ZodEnum<{
     skill_not_found: "skill_not_found";
     skill_too_many_files: "skill_too_many_files";
     skill_uncompressed_too_large: "skill_uncompressed_too_large";
+    steer_not_available: "steer_not_available";
     subscription_required: "subscription_required";
     task_active_run_exists: "task_active_run_exists";
     tenant_deleting: "tenant_deleting";
     tenant_deletion_in_progress: "tenant_deletion_in_progress";
     tenant_deletion_not_ready: "tenant_deletion_not_ready";
     tenant_not_deleting: "tenant_not_deleting";
-    tool_approval_continuation_not_found: "tool_approval_continuation_not_found";
+    tool_approval_continuation_settled: "tool_approval_continuation_settled";
     tool_approval_decision_conflict: "tool_approval_decision_conflict";
     unauthorized: "unauthorized";
     usage_credit_required: "usage_credit_required";
@@ -112,7 +112,6 @@ export declare const apiErrorSchema: z.ZodObject<{
         function_call_conflict: "function_call_conflict";
         idempotency_conflict: "idempotency_conflict";
         input_idempotency_conflict: "input_idempotency_conflict";
-        input_not_pending: "input_not_pending";
         internal: "internal";
         invalid_cursor: "invalid_cursor";
         invalid_request: "invalid_request";
@@ -162,13 +161,14 @@ export declare const apiErrorSchema: z.ZodObject<{
         skill_not_found: "skill_not_found";
         skill_too_many_files: "skill_too_many_files";
         skill_uncompressed_too_large: "skill_uncompressed_too_large";
+        steer_not_available: "steer_not_available";
         subscription_required: "subscription_required";
         task_active_run_exists: "task_active_run_exists";
         tenant_deleting: "tenant_deleting";
         tenant_deletion_in_progress: "tenant_deletion_in_progress";
         tenant_deletion_not_ready: "tenant_deletion_not_ready";
         tenant_not_deleting: "tenant_not_deleting";
-        tool_approval_continuation_not_found: "tool_approval_continuation_not_found";
+        tool_approval_continuation_settled: "tool_approval_continuation_settled";
         tool_approval_decision_conflict: "tool_approval_decision_conflict";
         unauthorized: "unauthorized";
         usage_credit_required: "usage_credit_required";
@@ -197,7 +197,6 @@ export declare const apiErrorResponseSchema: z.ZodObject<{
             function_call_conflict: "function_call_conflict";
             idempotency_conflict: "idempotency_conflict";
             input_idempotency_conflict: "input_idempotency_conflict";
-            input_not_pending: "input_not_pending";
             internal: "internal";
             invalid_cursor: "invalid_cursor";
             invalid_request: "invalid_request";
@@ -247,13 +246,14 @@ export declare const apiErrorResponseSchema: z.ZodObject<{
             skill_not_found: "skill_not_found";
             skill_too_many_files: "skill_too_many_files";
             skill_uncompressed_too_large: "skill_uncompressed_too_large";
+            steer_not_available: "steer_not_available";
             subscription_required: "subscription_required";
             task_active_run_exists: "task_active_run_exists";
             tenant_deleting: "tenant_deleting";
             tenant_deletion_in_progress: "tenant_deletion_in_progress";
             tenant_deletion_not_ready: "tenant_deletion_not_ready";
             tenant_not_deleting: "tenant_not_deleting";
-            tool_approval_continuation_not_found: "tool_approval_continuation_not_found";
+            tool_approval_continuation_settled: "tool_approval_continuation_settled";
             tool_approval_decision_conflict: "tool_approval_decision_conflict";
             unauthorized: "unauthorized";
             usage_credit_required: "usage_credit_required";

package/dist/contracts/api.js

@@ -20,7 +20,7 @@ export const apiErrorCodeSchema = z.enum([
     "invalid_request",
     "idempotency_conflict",
     "input_idempotency_conflict",
-    "input_not_pending",
+    "steer_not_available",
     "validation_failed",
     "unauthorized",
     "forbidden",
@@ -64,7 +64,7 @@ export const apiErrorCodeSchema = z.enum([
     "workspace_busy",
     "session_busy",
     "session_version_mismatch",
-    "tool_approval_continuation_not_found",
+    "tool_approval_continuation_settled",
     "tool_approval_decision_conflict",
     "function_call_conflict",
     "skill_invalid_archive",

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

@@ -162,18 +162,16 @@ export declare const resolveChatFunctionBodySchema: z.ZodObject<{
 export declare const resolveChatFunctionResponseSchema: z.ZodObject<{
     accepted: z.ZodLiteral<true>;
 }, z.core.$strip>;
-/** `POST .../tool-approval-continuations/{continuationId}/resume` body. */
-export declare const resumeToolApprovalContinuationBodySchema: z.ZodObject<{}, z.core.$strict>;
 /**
  * `POST /v1/agents/{agentId}/sessions` (create) and
  * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
  * The URL selects the mode; on create the platform mints the `ss_` id and
- * returns it in `Location`. Exactly one of `message` or `promptId` is
+ * returns it in `Location`. Exactly one of `messages` or `promptId` is
  * required, and `variables` requires `promptId`. Regenerate is resume-only,
  * enforced by the route layer rather than this schema.
  */
 export declare const chatRequestBodySchema: z.ZodObject<{
-    message: z.ZodOptional<z.ZodUnknown>;
+    messages: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
     promptId: z.ZodOptional<z.ZodString>;
     variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     trigger: z.ZodDefault<z.ZodEnum<{
@@ -188,7 +186,7 @@ export declare const chatRequestBodySchema: z.ZodObject<{
         inputSchema: z.ZodCustom<z.core.JSONSchema.JSONSchema, z.core.JSONSchema.JSONSchema>;
     }, z.core.$strict>>>;
 }, z.core.$strict> & z.ZodType<{
-    message?: unknown;
+    messages?: unknown[] | undefined;
     promptId?: string | undefined;
     variables?: Record<string, string> | undefined;
     trigger: "regenerate-message" | "submit-message";
@@ -200,9 +198,9 @@ export declare const chatRequestBodySchema: z.ZodObject<{
         inputSchema: z.core.JSONSchema.JSONSchema;
     }> | undefined;
 } & ExclusivePromptInput<{
-    message: null | NonNullable<unknown>;
+    messages: unknown[];
 }>, {
-    message?: unknown;
+    messages?: unknown[] | undefined;
     promptId?: string | undefined;
     variables?: Record<string, string> | undefined;
     trigger?: "regenerate-message" | "submit-message" | undefined;
@@ -214,7 +212,7 @@ export declare const chatRequestBodySchema: z.ZodObject<{
         inputSchema: z.core.JSONSchema.JSONSchema;
     }> | undefined;
 }, z.core.$ZodTypeInternals<{
-    message?: unknown;
+    messages?: unknown[] | undefined;
     promptId?: string | undefined;
     variables?: Record<string, string> | undefined;
     trigger: "regenerate-message" | "submit-message";
@@ -226,9 +224,9 @@ export declare const chatRequestBodySchema: z.ZodObject<{
         inputSchema: z.core.JSONSchema.JSONSchema;
     }> | undefined;
 } & ExclusivePromptInput<{
-    message: null | NonNullable<unknown>;
+    messages: unknown[];
 }>, {
-    message?: unknown;
+    messages?: unknown[] | undefined;
     promptId?: string | undefined;
     variables?: Record<string, string> | undefined;
     trigger?: "regenerate-message" | "submit-message" | undefined;

package/dist/contracts/entities/chat.js

@@ -181,13 +181,11 @@ export const resolveChatFunctionBodySchema = z
 export const resolveChatFunctionResponseSchema = z
     .object({ accepted: z.literal(true) })
     .strip();
-/** `POST .../tool-approval-continuations/{continuationId}/resume` body. */
-export const resumeToolApprovalContinuationBodySchema = z.object({}).strict();
 /**
  * `POST /v1/agents/{agentId}/sessions` (create) and
  * `POST /v1/agents/{agentId}/sessions/{sessionId}` (resume) request body.
  * The URL selects the mode; on create the platform mints the `ss_` id and
- * returns it in `Location`. Exactly one of `message` or `promptId` is
+ * returns it in `Location`. Exactly one of `messages` or `promptId` is
  * required, and `variables` requires `promptId`. Regenerate is resume-only,
  * enforced by the route layer rather than this schema.
  */
@@ -198,7 +196,7 @@ export const chatRequestBodySchema = z
      * unknown; the HTTP boundary validates it with `safeValidateUIMessages`
      * before treating it as a UIMessage.
      */
-    message: z.unknown().optional(),
+    messages: z.array(z.unknown()).min(1).optional(),
     promptId: promptIdSchema.optional(),
     variables: promptVariablesSchema.optional(),
     trigger: chatTriggerSchema.default("submit-message"),
@@ -213,11 +211,11 @@ export const chatRequestBodySchema = z
     functions: chatFunctionDefinitionsSchema.optional(),
 })
     .strict()
-    .refine((body) => body.message === undefined
+    .refine((body) => body.messages === undefined
     ? body.promptId !== undefined
     : body.promptId === undefined && body.variables === undefined, {
-    message: "Provide either `message` or `promptId` (+`variables`); they are mutually exclusive, and `variables` is only allowed with `promptId`.",
-    path: ["message"],
+    message: "Provide either `messages` or `promptId` (+`variables`); they are mutually exclusive, and `variables` is only allowed with `promptId`.",
+    path: ["messages"],
 });
 /**
  * `POST /v1/agents/{agentId}/generation` — the single stateless generation

package/dist/contracts/entities/session-inputs.d.ts

@@ -1,16 +1,11 @@
 import { z } from "zod";
 export declare const sessionInputStateSchema: z.ZodEnum<{
     accepted: "accepted";
-    cancelled: "cancelled";
     committed: "committed";
-    consumed: "consumed";
     delivered: "delivered";
+    not_placed: "not_placed";
     uncertain: "uncertain";
 }>;
-export declare const sessionInputModeSchema: z.ZodEnum<{
-    queue: "queue";
-    steer: "steer";
-}>;
 export declare const sessionInputRequestIdSchema: z.ZodString;
 export declare const sessionInputSchema: z.ZodObject<{
     requestId: z.ZodString;
@@ -23,43 +18,31 @@ export declare const sessionInputSchema: z.ZodObject<{
         metadata: z.ZodOptional<z.ZodUnknown>;
         role: z.ZodLiteral<"user">;
     }, z.core.$loose>;
-    mode: z.ZodEnum<{
-        queue: "queue";
-        steer: "steer";
-    }>;
     state: z.ZodEnum<{
         accepted: "accepted";
-        cancelled: "cancelled";
         committed: "committed";
-        consumed: "consumed";
         delivered: "delivered";
+        not_placed: "not_placed";
         uncertain: "uncertain";
     }>;
-    turnId: z.ZodNullable<z.ZodString>;
+    turnId: z.ZodString;
     createdAt: z.ZodISODateTime;
     updatedAt: z.ZodISODateTime;
-    consumedAt: z.ZodNullable<z.ZodISODateTime>;
     reason: z.ZodNullable<z.ZodEnum<{
-        deleted: "deleted";
         failed: "failed";
         owner_lost: "owner_lost";
         stopped: "stopped";
+        turn_finished: "turn_finished";
     }>>;
 }, z.core.$strip>;
 export declare const sessionActivitySchema: z.ZodObject<{
     state: z.ZodEnum<{
         approval: "approval";
         idle: "idle";
-        paused: "paused";
         running: "running";
         stopping: "stopping";
     }>;
     turnId: z.ZodNullable<z.ZodString>;
-    reason: z.ZodNullable<z.ZodEnum<{
-        failed: "failed";
-        function_executor_required: "function_executor_required";
-        owner_lost: "owner_lost";
-    }>>;
 }, z.core.$strip>;
 export declare const sessionInputResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
@@ -73,43 +56,31 @@ export declare const sessionInputResponseSchema: z.ZodObject<{
             metadata: z.ZodOptional<z.ZodUnknown>;
             role: z.ZodLiteral<"user">;
         }, z.core.$loose>;
-        mode: z.ZodEnum<{
-            queue: "queue";
-            steer: "steer";
-        }>;
         state: z.ZodEnum<{
             accepted: "accepted";
-            cancelled: "cancelled";
             committed: "committed";
-            consumed: "consumed";
             delivered: "delivered";
+            not_placed: "not_placed";
             uncertain: "uncertain";
         }>;
-        turnId: z.ZodNullable<z.ZodString>;
+        turnId: z.ZodString;
         createdAt: z.ZodISODateTime;
         updatedAt: z.ZodISODateTime;
-        consumedAt: z.ZodNullable<z.ZodISODateTime>;
         reason: z.ZodNullable<z.ZodEnum<{
-            deleted: "deleted";
             failed: "failed";
             owner_lost: "owner_lost";
             stopped: "stopped";
+            turn_finished: "turn_finished";
         }>>;
     }, z.core.$strip>;
     activity: z.ZodObject<{
         state: z.ZodEnum<{
             approval: "approval";
             idle: "idle";
-            paused: "paused";
             running: "running";
             stopping: "stopping";
         }>;
         turnId: z.ZodNullable<z.ZodString>;
-        reason: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            function_executor_required: "function_executor_required";
-            owner_lost: "owner_lost";
-        }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const sessionInputsResponseSchema: z.ZodObject<{
@@ -124,27 +95,21 @@ export declare const sessionInputsResponseSchema: z.ZodObject<{
             metadata: z.ZodOptional<z.ZodUnknown>;
             role: z.ZodLiteral<"user">;
         }, z.core.$loose>;
-        mode: z.ZodEnum<{
-            queue: "queue";
-            steer: "steer";
-        }>;
         state: z.ZodEnum<{
             accepted: "accepted";
-            cancelled: "cancelled";
             committed: "committed";
-            consumed: "consumed";
             delivered: "delivered";
+            not_placed: "not_placed";
             uncertain: "uncertain";
         }>;
-        turnId: z.ZodNullable<z.ZodString>;
+        turnId: z.ZodString;
         createdAt: z.ZodISODateTime;
         updatedAt: z.ZodISODateTime;
-        consumedAt: z.ZodNullable<z.ZodISODateTime>;
         reason: z.ZodNullable<z.ZodEnum<{
-            deleted: "deleted";
             failed: "failed";
             owner_lost: "owner_lost";
             stopped: "stopped";
+            turn_finished: "turn_finished";
         }>>;
     }, z.core.$strip>>;
     nextCursor: z.ZodNullable<z.ZodString>;
@@ -152,25 +117,15 @@ export declare const sessionInputsResponseSchema: z.ZodObject<{
         state: z.ZodEnum<{
             approval: "approval";
             idle: "idle";
-            paused: "paused";
             running: "running";
             stopping: "stopping";
         }>;
         turnId: z.ZodNullable<z.ZodString>;
-        reason: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            function_executor_required: "function_executor_required";
-            owner_lost: "owner_lost";
-        }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const submitSessionInputBodySchema: z.ZodObject<{
     requestId: z.ZodString;
     message: z.ZodUnknown & z.ZodType<{} | null, unknown, z.core.$ZodTypeInternals<{} | null, unknown>>;
-    whenBusy: z.ZodDefault<z.ZodEnum<{
-        queue: "queue";
-        steer: "steer";
-    }>>;
 }, z.core.$strict>;
 export declare const sessionInputsQuerySchema: z.ZodObject<{
     includeCompleted: z.ZodDefault<z.ZodBoolean>;
@@ -186,37 +141,13 @@ export declare const stopSessionResponseSchema: z.ZodObject<{
         state: z.ZodEnum<{
             approval: "approval";
             idle: "idle";
-            paused: "paused";
             running: "running";
             stopping: "stopping";
         }>;
         turnId: z.ZodNullable<z.ZodString>;
-        reason: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            function_executor_required: "function_executor_required";
-            owner_lost: "owner_lost";
-        }>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const resumeSessionInputsResponseSchema: z.ZodObject<{
-    activity: z.ZodObject<{
-        state: z.ZodEnum<{
-            approval: "approval";
-            idle: "idle";
-            paused: "paused";
-            running: "running";
-            stopping: "stopping";
-        }>;
-        turnId: z.ZodNullable<z.ZodString>;
-        reason: z.ZodNullable<z.ZodEnum<{
-            failed: "failed";
-            function_executor_required: "function_executor_required";
-            owner_lost: "owner_lost";
-        }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type SessionInputState = z.infer<typeof sessionInputStateSchema>;
-export type SessionInputMode = z.infer<typeof sessionInputModeSchema>;
 export type SessionInput = z.infer<typeof sessionInputSchema>;
 export type SessionActivity = z.infer<typeof sessionActivitySchema>;
 export type SessionInputResponse = z.infer<typeof sessionInputResponseSchema>;
@@ -225,11 +156,22 @@ export type SubmitSessionInputBody = z.input<typeof submitSessionInputBodySchema
 export type SessionInputsQuery = z.input<typeof sessionInputsQuerySchema>;
 export type StopSessionBody = z.infer<typeof stopSessionBodySchema>;
 export type StopSessionResponse = z.infer<typeof stopSessionResponseSchema>;
-export type ResumeSessionInputsResponse = z.infer<typeof resumeSessionInputsResponseSchema>;
-export declare const runSessionInputsBodySchema: z.ZodObject<{
-    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 RunSessionInputsBody = z.infer<typeof runSessionInputsBodySchema>;
+/** Provisional placement observation emitted on the owning Turn stream. */
+export declare const chatSteerConsumedEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-ba-steer-consumed">;
+    transient: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        requestId: z.ZodString;
+        sequence: z.ZodNumber;
+        message: z.ZodObject<{
+            id: z.ZodString;
+            parts: z.ZodArray<z.ZodObject<{
+                type: z.ZodString;
+            }, z.core.$loose>>;
+            metadata: z.ZodOptional<z.ZodUnknown>;
+            role: z.ZodLiteral<"user">;
+        }, z.core.$loose>;
+        turnId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ChatSteerConsumedEvent = z.infer<typeof chatSteerConsumedEventSchema>;

package/dist/contracts/entities/session-inputs.js

@@ -1,16 +1,13 @@
 import { z } from "zod";
 import { turnIdSchema } from "../ids.js";
-import { chatFunctionDefinitionsSchema } from "./chat.js";
 import { sessionMessageSchema } from "./sessions.js";
 export const sessionInputStateSchema = z.enum([
     "accepted",
     "delivered",
-    "consumed",
     "committed",
-    "cancelled",
+    "not_placed",
     "uncertain",
 ]);
-export const sessionInputModeSchema = z.enum(["queue", "steer"]);
 export const sessionInputRequestIdSchema = z
     .string()
     .min(1)
@@ -23,22 +20,19 @@ export const sessionInputSchema = z
     requestId: sessionInputRequestIdSchema,
     sequence: z.number().int().positive(),
     message: sessionMessageSchema.extend({ role: z.literal("user") }),
-    mode: sessionInputModeSchema,
     state: sessionInputStateSchema,
-    turnId: turnIdSchema.nullable(),
+    turnId: turnIdSchema,
     createdAt: z.iso.datetime({ offset: true }),
     updatedAt: z.iso.datetime({ offset: true }),
-    consumedAt: z.iso.datetime({ offset: true }).nullable(),
-    reason: z.enum(["stopped", "failed", "owner_lost", "deleted"]).nullable(),
+    reason: z
+        .enum(["stopped", "failed", "owner_lost", "turn_finished"])
+        .nullable(),
 })
     .strip();
 export const sessionActivitySchema = z
     .object({
-    state: z.enum(["idle", "running", "stopping", "approval", "paused"]),
+    state: z.enum(["idle", "running", "stopping", "approval"]),
     turnId: turnIdSchema.nullable(),
-    reason: z
-        .enum(["failed", "owner_lost", "function_executor_required"])
-        .nullable(),
 })
     .strip();
 export const sessionInputResponseSchema = z
@@ -56,7 +50,6 @@ export const submitSessionInputBodySchema = z
     requestId: sessionInputRequestIdSchema,
     /** The HTTP boundary validates the user message with AI SDK. */
     message: z.unknown().refine((message) => message !== undefined),
-    whenBusy: sessionInputModeSchema.default("queue"),
 })
     .strict();
 export const sessionInputsQuerySchema = z
@@ -72,9 +65,16 @@ export const stopSessionBodySchema = z
 export const stopSessionResponseSchema = z
     .object({ stoppedTurnId: turnIdSchema, activity: sessionActivitySchema })
     .strip();
-export const resumeSessionInputsResponseSchema = z
-    .object({ activity: sessionActivitySchema })
+/** Provisional placement observation emitted on the owning Turn stream. */
+export const chatSteerConsumedEventSchema = z
+    .object({
+    type: z.literal("data-ba-steer-consumed"),
+    transient: z.literal(true),
+    data: sessionInputSchema.pick({
+        requestId: true,
+        turnId: true,
+        sequence: true,
+        message: true,
+    }),
+})
     .strip();
-export const runSessionInputsBodySchema = z
-    .object({ functions: chatFunctionDefinitionsSchema.optional() })
-    .strict();