@blazingagents/sdk 0.19.0 → 0.21.0

package/dist/generation.js

@@ -1,9 +1,14 @@
 import { createTextStreamResponse, parsePartialJson } from "ai";
-import { toolApprovalsResponseSchema } from "./contracts/entities/sessions.js";
 import { sessionIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
 import { dispatchChatFunctions, toChatFunctionDefinitions, } from "./functions.js";
-import { requestJson, requestStream } from "./http.js";
+import { requestStream } from "./http.js";
+/**
+ * Creates or resumes a Session and returns its SSE stream and Session ID.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param input - Agent, message or stored Prompt, and optional existing Session.
+ * @returns The Session ID promise and single-owner SSE accessors.
+ */
 export async function chat(config, input) {
     const body = buildChatBody(input);
     if (input.functions && Object.keys(input.functions).length > 0) {
@@ -30,14 +35,23 @@ 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: {},
+/**
+ * Submits a complete Tool approval round and streams its continuation.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param input - Agent, Session, and decisions for the complete approval round.
+ * @returns The Session ID promise and continuation SSE accessors.
+ */
+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,19 +59,11 @@ 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`.
+ * @param response - Upstream HTTP response.
+ * @param filter - Transforms upstream SSE bytes before exposing them to the caller.
  */
 export function withFilteredBody(response, filter) {
     if (!response.body || response.body.locked) {
@@ -69,6 +75,9 @@ export function withFilteredBody(response, filter) {
         statusText: response.statusText,
     });
 }
+/**
+ * Builds a chat request body from messages or a stored Prompt.
+ */
 function buildChatBody(input) {
     const base = {};
     // Stryker disable next-line ConditionalExpression: JSON serialization omits an undefined trigger.
@@ -80,7 +89,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;
@@ -127,6 +139,9 @@ function sessionIdFromLocation(response, requestId) {
     }
     return parsed.data;
 }
+/**
+ * Combines the Session ID promise with a single-owner SSE result.
+ */
 function buildChatResult(config, response, resumeSessionId, dispatch) {
     /**
      * `sessionId` resolves from the `Location` header on create, or to the
@@ -159,10 +174,20 @@ function buildChatResult(config, response, resumeSessionId, dispatch) {
         ...buildTerminalStreamResult(streamResponse, "chat"),
     };
 }
+/**
+ * Creates single-owner SSE response and byte-stream accessors.
+ * @param response - Upstream HTTP response.
+ * @param resourceName - Resource label used in stream errors.
+ * @param filter - Transforms upstream SSE bytes before exposing them to the caller.
+ */
 export function buildTerminalStreamResult(response, resourceName, filter) {
     const requestId = response.headers.get("x-request-id") ?? undefined;
     const location = response.headers.get("location");
     let bodyClaimed = false;
+    /**
+     * Claims the response body once and normalizes stream failures.
+     * @throws BlazingAgentsError - If the response body has already been claimed.
+     */
     const claimBody = () => {
         if (bodyClaimed) {
             const message = `The ${resourceName} response body has already been claimed.`;
@@ -180,6 +205,7 @@ export function buildTerminalStreamResult(response, resourceName, filter) {
     return {
         requestId,
         toStream: claimBody,
+        /** Claims the response relay once. */
         toResponse: () => {
             const headers = replacementResponseHeaders(requestId, location);
             headers.set("content-type", "text/event-stream");
@@ -200,6 +226,9 @@ export function buildTerminalStreamResult(response, resourceName, filter) {
         },
     };
 }
+/**
+ * Preserves a matching stream error or wraps a failure with request correlation.
+ */
 function toStreamError(cause, requestId, fallbackMessage) {
     if (BlazingAgentsError.isInstance(cause) &&
         cause.code === "stream_error" &&
@@ -222,6 +251,9 @@ function toStreamError(cause, requestId, fallbackMessage) {
         requestId,
     }, { cause });
 }
+/**
+ * Wraps reads and cancellation failures as correlated SDK stream errors.
+ */
 function normalizeStreamErrors(stream, requestId, fallbackMessage) {
     let reader;
     try {
@@ -231,6 +263,9 @@ function normalizeStreamErrors(stream, requestId, fallbackMessage) {
         throw toStreamError(cause, requestId, fallbackMessage);
     }
     return new ReadableStream({
+        /**
+         * Reads one upstream chunk and normalizes stream failures.
+         */
         async pull(controller) {
             try {
                 const { done, value } = await reader.read();
@@ -244,6 +279,9 @@ function normalizeStreamErrors(stream, requestId, fallbackMessage) {
                 controller.error(toStreamError(cause, requestId, fallbackMessage));
             }
         },
+        /**
+         * Cancels the upstream reader with the consumer reason.
+         */
         async cancel(reason) {
             try {
                 await reader.cancel(reason);
@@ -254,6 +292,9 @@ function normalizeStreamErrors(stream, requestId, fallbackMessage) {
         },
     });
 }
+/**
+ * Returns the response body or a stream that fails when the body is missing.
+ */
 function responseBodyStream(response, requestId, resourceName) {
     if (response.body) {
         return response.body;
@@ -266,11 +307,17 @@ function responseBodyStream(response, requestId, resourceName) {
         requestId,
     }, { cause });
     return new ReadableStream({
+        /**
+         * Initializes the stream controller.
+         */
         start(controller) {
             controller.error(error);
         },
     });
 }
+/**
+ * Copies request correlation and Session location into relay response headers.
+ */
 function replacementResponseHeaders(requestId, location) {
     const headers = new Headers();
     if (requestId !== undefined) {
@@ -281,6 +328,9 @@ function replacementResponseHeaders(requestId, location) {
     }
     return headers;
 }
+/**
+ * Builds a stateless prompt request with the selected output format.
+ */
 function buildStatelessGenerationBody(input, output) {
     const body = { output };
     if ("prompt" in input) {
@@ -303,6 +353,12 @@ function buildStatelessGenerationBody(input, output) {
     }
     return body;
 }
+/**
+ * Starts stateless text generation with independent final, incremental, and response outputs.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param input - Agent and literal prompt or stored Prompt reference.
+ * @returns Independent text stream, final text promise, and response relay.
+ */
 export async function completion(config, input) {
     const body = buildStatelessGenerationBody(input, { type: "text" });
     const path = `/v1/agents/${input.agentId}/generation`;
@@ -314,6 +370,9 @@ export async function completion(config, input) {
     });
     return buildCompletionResult(response);
 }
+/**
+ * Splits text output into a final promise, incremental stream, and response relay.
+ */
 function buildCompletionResult(response) {
     const { finalStream, outputStream, requestId, toResponse } = buildStatelessGenerationStreams(response, "completion");
     const textPromise = (async () => {
@@ -333,6 +392,12 @@ function buildCompletionResult(response) {
         toResponse,
     };
 }
+/**
+ * Starts stateless JSON generation with partial objects and a final parsed value.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param input - Agent, prompt source, and JSON output schema.
+ * @returns Partial JSON objects, a final JSON promise, and a text response relay.
+ */
 export async function objectGeneration(config, input) {
     const body = buildStatelessGenerationBody(input, {
         type: "object",
@@ -347,10 +412,16 @@ export async function objectGeneration(config, input) {
     });
     return buildObjectResult(response);
 }
+/**
+ * Parses partial and final JSON from independent text-stream branches.
+ */
 function buildObjectResult(response) {
     const { finalStream, outputStream, requestId, toResponse } = buildStatelessGenerationStreams(response, "object");
     let accumulatedText = "";
     const partialObjectStream = outputStream.pipeThrough(new TransformStream({
+        /**
+         * Accumulates generated text and emits each available partial JSON value.
+         */
         async transform(chunk, controller) {
             accumulatedText += chunk;
             const { value } = await parsePartialJson(accumulatedText);
@@ -358,6 +429,9 @@ function buildObjectResult(response) {
                 controller.enqueue(value);
             }
         },
+        /**
+         * Rejects malformed final JSON when the text stream ends.
+         */
         flush() {
             try {
                 JSON.parse(accumulatedText);
@@ -397,6 +471,9 @@ function buildObjectResult(response) {
         toResponse,
     };
 }
+/**
+ * Splits decoded text into final, public, and response-relay branches.
+ */
 function buildStatelessGenerationStreams(response, resourceName) {
     const requestId = response.headers.get("x-request-id") ?? undefined;
     const location = response.headers.get("location");
@@ -413,6 +490,7 @@ function buildStatelessGenerationStreams(response, resourceName) {
         finalStream,
         outputStream,
         requestId,
+        /** Claims the response relay once. */
         toResponse: () => {
             if (responseBodyClaimed) {
                 const message = `The ${resourceName} response body has already been claimed.`;

package/dist/http.d.ts

@@ -4,20 +4,46 @@ import type { HttpConfig, RequestOptions } from "./types.ts";
  * Performs a request and returns the parsed JSON body for success (status
  * 2xx). API errors preserve the tolerant wire envelope; malformed responses
  * become `invalid_response`.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param path - Endpoint path relative to the base URL.
+ * @param options - Configuration for this operation.
+ * @param schema - Schema used to validate the value.
  */
 export declare function requestJson<T>(config: HttpConfig, path: string, options?: RequestOptions, schema?: {
+    /**
+     * Validates the decoded response value.
+     * @param value - Value to inspect.
+     */
     parse(value: unknown): T;
 }): Promise<T>;
 /**
  * Performs a request and returns the raw `Response` for streaming paths.
  * Non-2xx bodies are decoded before a caller can observe a streaming body.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param path - Endpoint path relative to the base URL.
+ * @param options - Configuration for this operation.
  */
 export declare function requestStream(config: HttpConfig, path: string, options?: RequestOptions): Promise<Response>;
+/**
+ * Checks whether the signal aborted or the cause names an AbortError.
+ * @param cause - Original failure to retain.
+ * @param signal - Signal that cancels the operation.
+ * @returns Whether the request signal or cause indicates cancellation.
+ */
 export declare function isRequestAborted(cause: unknown, signal?: AbortSignal): boolean;
+/**
+ * Wraps an abort cause as a request_aborted SDK error.
+ * @param cause - Original failure to retain.
+ * @returns A request_aborted error retaining the cause.
+ */
 export declare function requestAbortedError(cause: unknown): BlazingAgentsError;
 /**
  * Decodes a response body with the tolerant consumer schema. Unknown future
  * codes and fields remain valid; malformed responses never infer a domain
  * code from HTTP status.
+ * @param bodyText - Response body as text.
+ * @param status - HTTP response status.
+ * @param headers - Response headers to preserve or inspect.
+ * @returns The server error, or invalid_response when the envelope is malformed.
  */
 export declare function parseErrorEnvelope(bodyText: string, status: number, headers?: Headers): BlazingAgentsError;

package/dist/http.js

@@ -4,6 +4,9 @@ const DIAGNOSTIC_BODY_LIMIT_BYTES = 64 * 1024;
 const INVALID_RESPONSE_MESSAGE = "The server returned an invalid response.";
 const NETWORK_ERROR_MESSAGE = "Network request failed (fetch threw before any HTTP exchange).";
 const REQUEST_ABORTED_MESSAGE = "The request was aborted before any HTTP response.";
+/**
+ * Appends query values while omitting null and undefined entries.
+ */
 function buildUrl(baseUrl, path, query) {
     const url = `${baseUrl}${path}`;
     if (!query) {
@@ -23,6 +26,10 @@ function buildUrl(baseUrl, path, query) {
  * Performs a request and returns the parsed JSON body for success (status
  * 2xx). API errors preserve the tolerant wire envelope; malformed responses
  * become `invalid_response`.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param path - Endpoint path relative to the base URL.
+ * @param options - Configuration for this operation.
+ * @param schema - Schema used to validate the value.
  */
 export async function requestJson(config, path, options = {}, schema) {
     const response = await rawRequest(config, path, options);
@@ -56,6 +63,9 @@ export async function requestJson(config, path, options = {}, schema) {
 /**
  * Performs a request and returns the raw `Response` for streaming paths.
  * Non-2xx bodies are decoded before a caller can observe a streaming body.
+ * @param config - Authentication, base URL, and transport configuration.
+ * @param path - Endpoint path relative to the base URL.
+ * @param options - Configuration for this operation.
  */
 export async function requestStream(config, path, options = {}) {
     const response = await rawRequest(config, path, options);
@@ -64,6 +74,9 @@ export async function requestStream(config, path, options = {}) {
     }
     throw await errorFromResponse(response, options.signal);
 }
+/**
+ * Sends an authenticated request and reports response metadata to the observer.
+ */
 async function rawRequest(config, path, options) {
     const fetchImpl = config.fetch ?? globalThis.fetch;
     const url = buildUrl(config.baseUrl, path, options.query);
@@ -122,6 +135,9 @@ async function rawRequest(config, path, options) {
         }, { cause });
     }
 }
+/**
+ * Reads bounded diagnostics and decodes a failed HTTP response.
+ */
 async function errorFromResponse(response, signal) {
     const read = await readResponseBody(response, true);
     if (read.readFailed && isRequestAborted(read.cause, signal)) {
@@ -133,6 +149,12 @@ async function errorFromResponse(response, signal) {
     }
     return parseErrorEnvelope(read.diagnosticBody, response.status, headers);
 }
+/**
+ * Checks whether the signal aborted or the cause names an AbortError.
+ * @param cause - Original failure to retain.
+ * @param signal - Signal that cancels the operation.
+ * @returns Whether the request signal or cause indicates cancellation.
+ */
 export function isRequestAborted(cause, signal) {
     return (signal?.aborted === true ||
         (cause !== null &&
@@ -140,6 +162,11 @@ export function isRequestAborted(cause, signal) {
             "name" in cause &&
             cause.name === "AbortError"));
 }
+/**
+ * Wraps an abort cause as a request_aborted SDK error.
+ * @param cause - Original failure to retain.
+ * @returns A request_aborted error retaining the cause.
+ */
 export function requestAbortedError(cause) {
     return new BlazingAgentsError({
         code: "request_aborted",
@@ -215,6 +242,9 @@ async function readResponseBody(response, stopAtDiagnosticLimit) {
         byteLength += chunk.byteLength;
     }
 }
+/**
+ * Cancels an oversized error body and retains its bounded diagnostic prefix.
+ */
 async function cancelTruncatedBody(reader, chunks, byteLength) {
     const diagnosticBody = decodeDiagnosticChunks(chunks, byteLength, true).body;
     try {
@@ -236,6 +266,9 @@ async function cancelTruncatedBody(reader, chunks, byteLength) {
         };
     }
 }
+/**
+ * Decodes diagnostics without exceeding the UTF-8 byte limit.
+ */
 function decodeDiagnosticChunks(chunks, byteLength, sourceTruncated) {
     const body = decodeChunks(chunks, byteLength, sourceTruncated);
     const encoded = new TextEncoder().encode(body);
@@ -247,6 +280,9 @@ function decodeDiagnosticChunks(chunks, byteLength, sourceTruncated) {
         truncated: true,
     };
 }
+/**
+ * Joins retained bytes and omits an incomplete trailing character when truncated.
+ */
 function decodeChunks(chunks, byteLength, truncated) {
     const bytes = new Uint8Array(byteLength);
     let offset = 0;
@@ -264,6 +300,10 @@ function decodeChunks(chunks, byteLength, truncated) {
  * Decodes a response body with the tolerant consumer schema. Unknown future
  * codes and fields remain valid; malformed responses never infer a domain
  * code from HTTP status.
+ * @param bodyText - Response body as text.
+ * @param status - HTTP response status.
+ * @param headers - Response headers to preserve or inspect.
+ * @returns The server error, or invalid_response when the envelope is malformed.
  */
 export function parseErrorEnvelope(bodyText, status, headers = new Headers()) {
     let parsed;
@@ -292,6 +332,9 @@ export function parseErrorEnvelope(bodyText, status, headers = new Headers()) {
     }
     return invalidResponseError(headers, status, bodyText, false);
 }
+/**
+ * Builds an invalid_response error with bounded diagnostics and request correlation.
+ */
 function invalidResponseError(headers, status, responseBody, responseBodyTruncated, cause) {
     return new BlazingAgentsError({
         code: "invalid_response",

package/dist/index.d.ts

@@ -15,14 +15,14 @@ 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, SessionForkedFrom, 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";
-export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, } from "./contracts/entities/workspaces.ts";
+export type { CreateWorkspaceBody, UpdateWorkspaceBody, Workspace, WorkspaceNetworkPolicy, WorkspacesListResponse, WorkspaceTier, } from "./contracts/entities/workspaces.ts";
 export { BlazingAgentsDirectChatTransport, type BlazingAgentsDirectChatTransportOptions, } from "./direct-chat-transport.ts";
 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,25 +2,48 @@ 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;
 }
 export interface SessionOwnershipStore {
+    /**
+     * Looks up the end user who owns the Session.
+     * @param sessionId - Session to look up or record.
+     * @returns The owner ID, or undefined when no owner is recorded.
+     */
     ownerOf(sessionId: string): Promise<string | undefined>;
+    /**
+     * Records ownership of a newly created Session.
+     * @param sessionId - Session to look up or record.
+     * @param userId - End-user ID for request scope.
+     * @returns Resolves after ownership is stored.
+     */
     recordOwner(sessionId: string, userId: string): Promise<void>;
 }
 interface RelayOptions<Method extends keyof BlazingAgents> {
     client: Pick<BlazingAgents, Method>;
+    /**
+     * Resolves authenticated Agent and end-user context, or null for an unauthenticated request.
+     * @param request - Incoming HTTP request.
+     * @returns Authenticated context, or null when authentication fails.
+     */
     resolveContext(request: Request): Promise<RelayContext | null>;
 }
 /**
  * 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.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that checks Session ownership before resuming.
  */
-export declare function createChatRelay(options: RelayOptions<"chat" | "resumeChat" | "sessions"> & {
+export declare function createChatRelay(options: RelayOptions<"chat" | "continueChat"> & {
     sessions: SessionOwnershipStore;
 }): (request: Request) => Promise<Response>;
+/**
+ * Creates an authenticated HTTP handler that validates prompts and relays text generation.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that validates prompts and relays text generation.
+ */
 export declare function createCompletionRelay(options: RelayOptions<"completion">): (request: Request) => Promise<Response>;
 export {};

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,9 @@ 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.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that checks Session ownership before resuming.
  */
 export function createChatRelay(options) {
     return async (request) => {
@@ -44,6 +46,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,
@@ -83,6 +88,9 @@ export function createChatRelay(options) {
         }
     };
 }
+/**
+ * Validates the Session and forwards the last assistant approval round.
+ */
 async function relayApprovalResponses(client, { functions, message, request, ...input }) {
     if (input.sessionId === undefined) {
         return errorResponse(400, "invalid_request", "Tool approval requires an existing Session.");
@@ -92,21 +100,22 @@ 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();
 }
+/**
+ * Creates an authenticated HTTP handler that validates prompts and relays text generation.
+ * @param options - Configuration for this operation.
+ * @returns An HTTP handler that validates prompts and relays text generation.
+ */
 export function createCompletionRelay(options) {
     return async (request) => {
         try {
@@ -129,6 +138,9 @@ export function createCompletionRelay(options) {
         }
     };
 }
+/**
+ * Maps validation and SDK failures to safe public error responses.
+ */
 function safeErrorResponse(error) {
     if (error instanceof z.ZodError || error instanceof SyntaxError) {
         return errorResponse(400, "invalid_request", "Invalid request body.");
@@ -144,6 +156,9 @@ function safeErrorResponse(error) {
     }
     return errorResponse(500, "internal_error", "Request failed.");
 }
+/**
+ * Builds a JSON error envelope with the selected HTTP status.
+ */
 function errorResponse(status, code, message, headers) {
     const responseHeaders = new Headers(headers);
     responseHeaders.set("content-type", "application/json");

package/dist/resources/agents.d.ts

@@ -1,2 +1,7 @@
 import type { AgentsResource, HttpConfig } from "../types.ts";
+/**
+ * Builds the Agents operations using the shared HTTP configuration.
+ * @param config - Shared authentication and transport configuration.
+ * @returns The configured resource client.
+ */
 export declare function createAgentsResource(config: HttpConfig): AgentsResource;