@blazingagents/sdk 0.19.0 → 0.21.0

package/dist/contracts/entities/agent-tools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-/** Tool groups an Agent can attach. File operations use its durable Workspace. */
+/** Tool groups an Agent can attach. File operations use its Workspace. */
 export const agentToolGroupIds = [
     "workspace",
     "write_todos",
@@ -9,7 +9,7 @@ export const AGENT_TOOL_CATALOG = [
     {
         id: "workspace",
         name: "File operations",
-        description: "Read, write, edit, search, and run shell commands in the attached durable Workspace.",
+        description: "Read, write, edit, search, and run shell commands in the attached Workspace.",
         tools: [
             "read",
             "write",
@@ -39,6 +39,9 @@ export const AGENT_TOOL_CATALOG = [
         ],
     },
 ];
+/**
+ * Expands tool group names into their individual tool names.
+ */
 export function expandToolGroups(ids) {
     const result = new Set();
     for (const id of ids) {

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

@@ -518,6 +518,10 @@ export declare const createAgentBodySchema: z.ZodObject<{
     thinkingLevel: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     providerId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     workspaceId: z.ZodOptional<z.ZodString>;
+    workspaceTier: z.ZodOptional<z.ZodEnum<{
+        core: "core";
+        plus: "plus";
+    }>>;
     autoCompaction: z.ZodDefault<z.ZodBoolean>;
     compactionReserveTokens: z.ZodDefault<z.ZodNumber>;
     memoryInjectionEnabled: z.ZodDefault<z.ZodBoolean>;

package/dist/contracts/entities/agents.js

@@ -6,6 +6,7 @@ import { atLeastOneFieldMessage, hasObjectKeys, hasUniqueValues, } from "../util
 import { approvalPolicySchema } from "./agent-approval.js";
 import { agentToolGroupIds } from "./agent-tools.js";
 import { metadataSchema, userIdSchema } from "./attribution.js";
+import { workspaceTierSchema } from "./workspaces.js";
 const approvalFields = {
     approvalInChat: approvalPolicySchema.default({
         default: "full",
@@ -35,6 +36,9 @@ export const agentMcpConnectionIdsSchema = z
 });
 export const agentStatusSchema = z.enum(["active", "disabled"]);
 const providerModelPairMessage = "Provider and model must either both be set or both be null.";
+/**
+ * Checks that provider and model selections are both present or both absent.
+ */
 function hasProviderModelPair(input) {
     return (input.model === null) === (input.providerId === null);
 }
@@ -114,6 +118,7 @@ export const createAgentBodySchema = z
     thinkingLevel: z.string().min(1).nullable().default(null),
     providerId: providerIdSchema.nullable().default(null),
     workspaceId: workspaceIdSchema.optional(),
+    workspaceTier: workspaceTierSchema.optional(),
     autoCompaction: z.boolean().default(true),
     compactionReserveTokens: agentSchema.shape.compactionReserveTokens.default(16_384),
     memoryInjectionEnabled: z.boolean().default(false),
@@ -124,6 +129,10 @@ export const createAgentBodySchema = z
     mcpConnectionIds: agentMcpConnectionIdsSchema.default([]),
 })
     .strict()
+    .refine((input) => input.workspaceId === undefined || input.workspaceTier === undefined, {
+    message: "workspaceId and workspaceTier are mutually exclusive.",
+    path: ["workspaceTier"],
+})
     .refine(hasProviderModelPair, {
     message: providerModelPairMessage,
     path: ["providerId"],

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

@@ -110,6 +110,9 @@ export declare const jsonSchemaShapeSchema: z.ZodCustom<z.core.JSONSchema.JSONSc
 export declare const MAX_CHAT_FUNCTIONS = 32;
 export declare const MAX_CHAT_FUNCTION_DEFINITIONS_BYTES: number;
 export declare const MAX_CHAT_FUNCTION_PAYLOAD_BYTES: number;
+/**
+ * Measures the UTF-8 byte length of a JSON-serialized value.
+ */
 export declare const jsonByteLength: (value: unknown) => number;
 /** One caller-local function as sent to Blazing Agents: description and JSON Schema only. */
 export declare const chatFunctionDefinitionSchema: z.ZodObject<{
@@ -162,18 +165,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 +189,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 +201,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 +215,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 +227,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

@@ -61,6 +61,9 @@ export const blazingAgentsChatMessageMetadataSchema = z
  */
 export const promptVariablesSchema = z.record(z.string(), z.string());
 const JSON_SCHEMA_COMPOSITION_KEYS = ["allOf", "anyOf", "oneOf"];
+/**
+ * Checks whether the JSON Schema root contains a meaningful schema keyword.
+ */
 function hasMeaningfulSchemaRoot(value, definitions, seenReferences) {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return false;
@@ -120,6 +123,9 @@ export const jsonSchemaShapeSchema = z.custom((value) => {
 export const MAX_CHAT_FUNCTIONS = 32;
 export const MAX_CHAT_FUNCTION_DEFINITIONS_BYTES = 64 * 1024;
 export const MAX_CHAT_FUNCTION_PAYLOAD_BYTES = 256 * 1024;
+/**
+ * Measures the UTF-8 byte length of a JSON-serialized value.
+ */
 export const jsonByteLength = (value) => new TextEncoder().encode(JSON.stringify(value)).byteLength;
 /** One caller-local function as sent to Blazing Agents: description and JSON Schema only. */
 export const chatFunctionDefinitionSchema = z
@@ -181,13 +187,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 +202,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 +217,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/mcp-connections.d.ts

@@ -16,7 +16,9 @@ export declare const mcpConnectionTestErrorCodeSchema: z.ZodEnum<{
     MCP_CONNECTION_INVALID: "MCP_CONNECTION_INVALID";
     MCP_CONNECTION_UNREACHABLE: "MCP_CONNECTION_UNREACHABLE";
 }>;
-/** Mirrors the MCP SDK's SEP-2352 issuer-identity comparison. */
+/**
+ * Mirrors the MCP SDK's SEP-2352 issuer-identity comparison.
+ */
 export declare function mcpOauthIssuersMatch(a: string, b: string): boolean;
 export declare const mcpOauthClientCredentialsBundleSchema: z.ZodObject<{
     clientInformation: z.ZodObject<{

package/dist/contracts/entities/mcp-connections.js

@@ -75,7 +75,9 @@ const oauthIssuerSchema = z
 })
     .transform((value) => new URL(value).toString());
 const credentialFragmentSchema = z.string().min(1).max(4).nullable();
-/** Mirrors the MCP SDK's SEP-2352 issuer-identity comparison. */
+/**
+ * Mirrors the MCP SDK's SEP-2352 issuer-identity comparison.
+ */
 export function mcpOauthIssuersMatch(a, b) {
     return (a === b ||
         (a.endsWith("/") && a.slice(0, -1) === b) ||

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

@@ -5,6 +5,11 @@ export interface PromptVariableParseResult {
 }
 export declare const promptVariableTokenPattern: RegExp;
 export declare const promptVariableNamePattern: RegExp;
+/**
+ * Lists unique valid Prompt variables in appearance order and reports invalid names.
+ * @param template - Prompt template containing double-brace variable tokens.
+ * @returns Unique valid variables and all invalid variable names.
+ */
 export declare function parsePromptVariables(template: string): PromptVariableParseResult;
 export declare const promptTemplateSchema: z.ZodString;
 export declare const promptSchema: z.ZodObject<{
@@ -65,6 +70,14 @@ export declare const updatePromptBodySchema: z.ZodObject<{
     template: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strict>;
+/**
+ * Validates the Prompt template and replaces variables with their supplied string values.
+ * @param template - Prompt template containing double-brace variable tokens.
+ * @param values - Values to inspect or substitute.
+ * @returns The validated template with every variable replaced.
+ * @throws ZodError - If the template is invalid.
+ * @throws Error - If a variable has no string value.
+ */
 export declare function renderPromptTemplate(template: string, values: Record<string, string>): string;
 export type Prompt = z.infer<typeof promptSchema>;
 export type PromptsResponse = z.infer<typeof promptsResponseSchema>;

package/dist/contracts/entities/prompts.js

@@ -7,6 +7,11 @@ import { metadataSchema, userIdSchema } from "./attribution.js";
 export const promptVariableTokenPattern = /{{([\s\S]*?)}}/g;
 export const promptVariableNamePattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const promptNameSchema = z.string().trim().min(1).max(MAX_PROMPT_NAME_LENGTH);
+/**
+ * Lists unique valid Prompt variables in appearance order and reports invalid names.
+ * @param template - Prompt template containing double-brace variable tokens.
+ * @returns Unique valid variables and all invalid variable names.
+ */
 export function parsePromptVariables(template) {
     const invalidVariableNames = [];
     const seenVariables = new Set();
@@ -95,6 +100,14 @@ export const updatePromptBodySchema = z
     .refine(hasObjectKeys, {
     message: atLeastOneFieldMessage,
 });
+/**
+ * Validates the Prompt template and replaces variables with their supplied string values.
+ * @param template - Prompt template containing double-brace variable tokens.
+ * @param values - Values to inspect or substitute.
+ * @returns The validated template with every variable replaced.
+ * @throws ZodError - If the template is invalid.
+ * @throws Error - If a variable has no string value.
+ */
 export function renderPromptTemplate(template, values) {
     return promptTemplateSchema
         .parse(template)

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)
@@ -22,23 +19,22 @@ export const sessionInputSchema = z
     .object({
     requestId: sessionInputRequestIdSchema,
     sequence: z.number().int().positive(),
-    message: sessionMessageSchema.extend({ role: z.literal("user") }),
-    mode: sessionInputModeSchema,
+    message: sessionMessageSchema
+        .omit({ branchable: true })
+        .extend({ role: z.literal("user") }),
     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 +52,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 +67,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();