@blazingagents/sdk 0.17.0 → 0.18.0

package/dist/contracts/api.d.ts

@@ -31,6 +31,8 @@ export declare const apiErrorCodeSchema: z.ZodEnum<{
     forbidden: "forbidden";
     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";
@@ -109,6 +111,8 @@ export declare const apiErrorSchema: z.ZodObject<{
         forbidden: "forbidden";
         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";
@@ -192,6 +196,8 @@ export declare const apiErrorResponseSchema: z.ZodObject<{
             forbidden: "forbidden";
             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";

package/dist/contracts/api.js

@@ -19,6 +19,8 @@ export const apiErrorIssueSchema = z
 export const apiErrorCodeSchema = z.enum([
     "invalid_request",
     "idempotency_conflict",
+    "input_idempotency_conflict",
+    "input_not_pending",
     "validation_failed",
     "unauthorized",
     "forbidden",

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

@@ -0,0 +1,235 @@
+import { z } from "zod";
+export declare const sessionInputStateSchema: z.ZodEnum<{
+    accepted: "accepted";
+    cancelled: "cancelled";
+    committed: "committed";
+    consumed: "consumed";
+    delivered: "delivered";
+    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;
+    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>;
+    mode: z.ZodEnum<{
+        queue: "queue";
+        steer: "steer";
+    }>;
+    state: z.ZodEnum<{
+        accepted: "accepted";
+        cancelled: "cancelled";
+        committed: "committed";
+        consumed: "consumed";
+        delivered: "delivered";
+        uncertain: "uncertain";
+    }>;
+    turnId: z.ZodNullable<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";
+    }>>;
+}, 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<{
+        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>;
+        mode: z.ZodEnum<{
+            queue: "queue";
+            steer: "steer";
+        }>;
+        state: z.ZodEnum<{
+            accepted: "accepted";
+            cancelled: "cancelled";
+            committed: "committed";
+            consumed: "consumed";
+            delivered: "delivered";
+            uncertain: "uncertain";
+        }>;
+        turnId: z.ZodNullable<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";
+        }>>;
+    }, 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<{
+    data: z.ZodArray<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>;
+        mode: z.ZodEnum<{
+            queue: "queue";
+            steer: "steer";
+        }>;
+        state: z.ZodEnum<{
+            accepted: "accepted";
+            cancelled: "cancelled";
+            committed: "committed";
+            consumed: "consumed";
+            delivered: "delivered";
+            uncertain: "uncertain";
+        }>;
+        turnId: z.ZodNullable<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";
+        }>>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    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 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>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const stopSessionBodySchema: z.ZodObject<{
+    turnId: z.ZodString;
+}, z.core.$strict>;
+export declare const stopSessionResponseSchema: z.ZodObject<{
+    stoppedTurnId: z.ZodString;
+    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 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>;
+export type SessionInputsResponse = z.infer<typeof sessionInputsResponseSchema>;
+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>;

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

@@ -0,0 +1,80 @@
+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",
+    "uncertain",
+]);
+export const sessionInputModeSchema = z.enum(["queue", "steer"]);
+export const sessionInputRequestIdSchema = z
+    .string()
+    .min(1)
+    .max(128)
+    .refine((requestId) => requestId !== "." && requestId !== "..", {
+    message: "requestId must not be a URL dot segment.",
+});
+export const sessionInputSchema = z
+    .object({
+    requestId: sessionInputRequestIdSchema,
+    sequence: z.number().int().positive(),
+    message: sessionMessageSchema.extend({ role: z.literal("user") }),
+    mode: sessionInputModeSchema,
+    state: sessionInputStateSchema,
+    turnId: turnIdSchema.nullable(),
+    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(),
+})
+    .strip();
+export const sessionActivitySchema = z
+    .object({
+    state: z.enum(["idle", "running", "stopping", "approval", "paused"]),
+    turnId: turnIdSchema.nullable(),
+    reason: z
+        .enum(["failed", "owner_lost", "function_executor_required"])
+        .nullable(),
+})
+    .strip();
+export const sessionInputResponseSchema = z
+    .object({ data: sessionInputSchema, activity: sessionActivitySchema })
+    .strip();
+export const sessionInputsResponseSchema = z
+    .object({
+    data: z.array(sessionInputSchema),
+    nextCursor: z.string().nullable(),
+    activity: sessionActivitySchema,
+})
+    .strip();
+export const submitSessionInputBodySchema = z
+    .object({
+    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
+    .object({
+    includeCompleted: z.boolean().default(false),
+    limit: z.number().int().min(1).max(200).default(100),
+    cursor: z.string().min(1).optional(),
+})
+    .strict();
+export const stopSessionBodySchema = z
+    .object({ turnId: turnIdSchema })
+    .strict();
+export const stopSessionResponseSchema = z
+    .object({ stoppedTurnId: turnIdSchema, activity: sessionActivitySchema })
+    .strip();
+export const resumeSessionInputsResponseSchema = z
+    .object({ activity: sessionActivitySchema })
+    .strip();
+export const runSessionInputsBodySchema = z
+    .object({ functions: chatFunctionDefinitionsSchema.optional() })
+    .strict();

package/dist/contracts/index.d.ts

@@ -14,6 +14,8 @@ export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchem
 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 { copySkillBodySchema, createSkillBodySchema, skillCopyResultsSchema, skillDetailSchema, skillsListResponseSchema, } from "./entities/skills.ts";

package/dist/contracts/index.js

@@ -13,6 +13,7 @@ export { createMemoryBodySchema, memoriesListResponseSchema, memoryResponseSchem
 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 { 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";

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

@@ -22,6 +22,13 @@ 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?: {
+        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>;
 }

package/dist/direct-chat-transport.js

@@ -13,6 +13,32 @@ 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.");
+        }
+        const client = await this.#options.getClient();
+        const result = await client.sessions.joinInputTurn({
+            ...input,
+            agentId: this.#options.agentId,
+            sessionId: this.#sessionId,
+            functions: this.#options.functions,
+        });
+        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());
+    }
     async sendMessages(input) {
         if (input.trigger === "regenerate-message" && !this.#sessionId) {
             throw new Error("Regeneration requires an existing Session.");

package/dist/generation.d.ts

@@ -6,6 +6,6 @@ export declare function resumeChat(config: HttpConfig, input: ResumeChatInput):
  * bodies pass through so the stream result reports them as `stream_error`.
  */
 export declare function withFilteredBody(response: Response, filter: (body: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>): Response;
-export declare function buildTerminalStreamResult(response: Response, resourceName: string): TerminalStreamResult;
+export declare function buildTerminalStreamResult(response: Response, resourceName: string, filter?: (body: ReadableStream<Uint8Array>) => ReadableStream<Uint8Array>): TerminalStreamResult;
 export declare function completion(config: HttpConfig, input: CompletionInput): Promise<CompletionResult>;
 export declare function objectGeneration(config: HttpConfig, input: ObjectInput): Promise<ObjectResult>;

package/dist/generation.js

@@ -159,7 +159,7 @@ function buildChatResult(config, response, resumeSessionId, dispatch) {
         ...buildTerminalStreamResult(streamResponse, "chat"),
     };
 }
-export function buildTerminalStreamResult(response, resourceName) {
+export function buildTerminalStreamResult(response, resourceName, filter) {
     const requestId = response.headers.get("x-request-id") ?? undefined;
     const location = response.headers.get("location");
     let bodyClaimed = false;
@@ -174,7 +174,8 @@ export function buildTerminalStreamResult(response, resourceName) {
             }, { cause });
         }
         bodyClaimed = true;
-        return normalizeStreamErrors(responseBodyStream(response, requestId, resourceName), requestId, `The ${resourceName} response stream failed.`);
+        const body = responseBodyStream(response, requestId, resourceName);
+        return normalizeStreamErrors(filter ? filter(body) : body, requestId, `The ${resourceName} response stream failed.`);
     };
     return {
         requestId,

package/dist/index.d.ts

@@ -15,6 +15,7 @@ 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 { sessionResponseSchema } from "./contracts/entities/sessions.ts";
 export type { CreateSkillBody, Skill, SkillArchiveType, SkillCopyResult, SkillCopyResults, SkillDetail, SkillFile, SkillsListResponse, } from "./contracts/entities/skills.ts";

package/dist/resources/sessions.js

@@ -1,5 +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 { stripFunctionEvents } from "../functions.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";
 /**
@@ -10,6 +12,48 @@ 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",
+                json: { turnId: turnIdSchema.parse(turnId) },
+                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);
         },

package/dist/types.d.ts

@@ -9,6 +9,7 @@ import type { CreateMemoryBody, MemoriesListResponse, MemoryResponse, UpdateMemo
 import type { CreateMerchantConnectionBody, MerchantBindingResponse, MerchantBindingsResponse, MerchantConnectionResponse, MerchantUsageEventResponse, MerchantUsageEventStatus, MerchantUsageEventsResponse, MerchantUsageSummaryResponse, UpdateMerchantConnectionBody, UpsertMerchantBindingBody } from "./contracts/entities/merchant.ts";
 import type { CreatePromptBody, PromptResponse, PromptsResponse, UpdatePromptBody } from "./contracts/entities/prompts.ts";
 import type { CreateProviderBody, DeleteProviderOptions, ProviderModelsResponse, ProviderResponse, ProvidersResponse, ThinkingLevelsResponse, UpdateProviderBody } from "./contracts/entities/providers.ts";
+import type { ResumeSessionInputsResponse, SessionInputResponse, SessionInputsQuery, SessionInputsResponse, StopSessionBody, StopSessionResponse, SubmitSessionInputBody } from "./contracts/entities/session-inputs.ts";
 import type { DecideToolApprovalBody, LatestSessionsListResponse, SessionMessagesResponse, SessionResponse, SessionsListResponse, ToolApprovalDecisionResponse, ToolApprovalsResponse } from "./contracts/entities/sessions.ts";
 import type { CreateSkillBody, SkillArchiveType, SkillCopyResults, SkillDetail, SkillsListResponse } from "./contracts/entities/skills.ts";
 import type { CreateTaskBody, CreateTaskResponse, CreateTaskRunBody, CreateTaskRunResponse, TaskResponse, TaskRunMessagesResponse, TaskRunResponse, TaskRunsListResponse, TasksListResponse, UpdateTaskBody } from "./contracts/entities/tasks.ts";
@@ -404,10 +405,27 @@ export interface SessionsResource {
         sessionId: string;
         deleteArtifacts: boolean;
     } & ResourceRequestOptions): Promise<void>;
+    deleteInput(input: {
+        agentId: string;
+        sessionId: string;
+        requestId: string;
+    } & ResourceRequestOptions): Promise<SessionInputResponse>;
     get(input: {
         agentId: string;
         sessionId: string;
     } & ResourceRequestOptions): Promise<SessionResponse>;
+    /** Poll from the first page for state changes; cursor only paginates receipts. */
+    inputs(input: {
+        agentId: string;
+        sessionId: string;
+    } & SessionInputsQuery & ResourceRequestOptions): Promise<SessionInputsResponse>;
+    /** Replays an admitted input Turn. Supplying functions opts into executor claims. */
+    joinInputTurn(input: {
+        agentId: string;
+        sessionId: string;
+        turnId: string;
+        functions?: ChatFunctions;
+    } & ResourceRequestOptions): Promise<TerminalStreamResult>;
     joinToolApprovalContinuation(input: {
         agentId: string;
         sessionId: string;
@@ -426,6 +444,33 @@ export interface SessionsResource {
         agentId: string;
         sessionId: string;
     } & SessionMessagesOptions): Promise<SessionMessagesResponse>;
+    promoteInput(input: {
+        agentId: string;
+        sessionId: string;
+        requestId: string;
+    } & ResourceRequestOptions): Promise<SessionInputResponse>;
+    /** Resume accepted inputs after a pause. Uncertain inputs are never replayed. */
+    resumeInputs(input: {
+        agentId: string;
+        sessionId: string;
+    } & ResourceRequestOptions): Promise<ResumeSessionInputsResponse>;
+    /** Admits the pending batch without resubmitting its messages. */
+    runInputs(input: {
+        agentId: string;
+        sessionId: string;
+        functions?: ChatFunctions;
+    } & ResourceRequestOptions): Promise<TerminalStreamResult>;
+    /** Wait for settlement of the named Turn. A queued Turn may already be running. */
+    stop(input: {
+        agentId: string;
+        sessionId: string;
+    } & StopSessionBody & ResourceRequestOptions): Promise<StopSessionResponse>;
+    /** Retry an uncertain acknowledgement with the same requestId and payload. */
+    submitInput(input: Omit<SubmitSessionInputBody, "message"> & {
+        agentId: string;
+        sessionId: string;
+        message: UIMessage;
+    } & ResourceRequestOptions): Promise<SessionInputResponse>;
     toolApprovals(input: {
         agentId: string;
         sessionId: string;

package/package.json

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