@blazingagents/sdk 0.15.0 → 0.17.0

package/dist/functions.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { type ChatFunctionCallEvent, type ChatFunctionDefinitions } from "./contracts/entities/chat.ts";
+import type { HttpConfig } from "./types.ts";
+export interface ChatFunctionContext {
+    /** The function call ID; a new user resend produces a new key. */
+    idempotencyKey: string;
+    /** Aborts at the call deadline or when the chat stream ends. */
+    signal: AbortSignal;
+}
+export interface ChatFunction<Schema extends z.ZodType = z.ZodType, Output = unknown> {
+    description: string;
+    execute(input: z.output<Schema>, context: ChatFunctionContext): Output | Promise<Output>;
+    inputSchema: Schema;
+}
+export type ChatFunctions = Record<string, ChatFunction>;
+/** Declares a caller-local function whose handler input is inferred from its Zod schema. */
+export declare function defineFunction<Schema extends z.ZodType, Output>(definition: ChatFunction<Schema, Output>): ChatFunction<Schema, Output>;
+export declare function toChatFunctionDefinitions(functions: ChatFunctions): ChatFunctionDefinitions;
+export interface FunctionDispatchTarget {
+    abortSignal?: AbortSignal;
+    agentId: string;
+    functions: ChatFunctions;
+    sessionId: string;
+}
+interface FunctionEventHandlers {
+    onCall?(call: ChatFunctionCallEvent["data"], fail: (error: unknown) => void): void;
+    onCancel?(): void;
+    onEnd?(): void;
+}
+/**
+ * Reads native SSE eagerly and returns it without private function events,
+ * so slow consumers never delay a call. A recognized but malformed event
+ * fails the stream.
+ */
+export declare function stripFunctionEvents(body: ReadableStream<Uint8Array>, { onCall, onCancel, onEnd }?: FunctionEventHandlers): ReadableStream<Uint8Array>;
+/** Strips private function events and executes claimed calls without blocking the read loop. */
+export declare function dispatchChatFunctions(config: HttpConfig, target: FunctionDispatchTarget, body: ReadableStream<Uint8Array>): ReadableStream<Uint8Array>;
+export {};

package/dist/functions.js

@@ -0,0 +1,299 @@
+import { z } from "zod";
+import { chatFunctionCallEventSchema, chatFunctionDefinitionsSchema, chatFunctionOutcomeSchema, claimChatFunctionResponseSchema, resolveChatFunctionResponseSchema, } from "./contracts/entities/chat.js";
+import { BlazingAgentsError } from "./errors.js";
+import { requestJson } from "./http.js";
+/** Declares a caller-local function whose handler input is inferred from its Zod schema. */
+export function defineFunction(definition) {
+    return definition;
+}
+export function toChatFunctionDefinitions(functions) {
+    try {
+        return chatFunctionDefinitionsSchema.parse(Object.fromEntries(Object.entries(functions).map(([name, fn]) => {
+            const { $schema: _, ...inputSchema } = z.toJSONSchema(fn.inputSchema, { io: "input" });
+            return [name, { description: fn.description, inputSchema }];
+        })));
+    }
+    catch (cause) {
+        throw new BlazingAgentsError({
+            code: "invalid_request",
+            message: `Invalid chat functions: ${cause instanceof z.ZodError ? z.prettifyError(cause) : String(cause)}`,
+        }, { cause });
+    }
+}
+const EVENT_BOUNDARY = /\r\n\r\n|\n\n/;
+const LINE_BREAK = /\r?\n/;
+const DELAY_SECONDS = /^\d+$/;
+const FUNCTION_CALL_TYPE = "data-ba-function-call";
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2000;
+/** Results may retry past the deadline to recover an already accepted receipt. */
+const RESULT_RETRY_GRACE_MS = 30_000;
+/**
+ * `undefined` forwards the SSE block unchanged; `null` marks a recognized
+ * but malformed function event.
+ */
+function functionCallFrom(block) {
+    const data = block
+        .split(LINE_BREAK)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice(line.startsWith("data: ") ? 6 : 5))
+        .join("\n");
+    if (!data.includes(FUNCTION_CALL_TYPE)) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
+    }
+    catch {
+        /** Unparseable frames naming the private event never reach the browser. */
+        return null;
+    }
+    if (parsed?.type !== FUNCTION_CALL_TYPE) {
+        return;
+    }
+    return chatFunctionCallEventSchema.safeParse(parsed).data ?? null;
+}
+function retryAfterMs(headers) {
+    const value = headers?.get("retry-after");
+    if (!value) {
+        return;
+    }
+    const ms = DELAY_SECONDS.test(value)
+        ? Number(value) * 1000
+        : Date.parse(value) - Date.now();
+    return Number.isNaN(ms) ? undefined : Math.max(0, ms);
+}
+function retryDelayMs({ code, headers, status }, attempt) {
+    const retryable = status === undefined
+        ? code === "network_error"
+        : status === 408 || status === 429 || status >= 500;
+    if (!retryable) {
+        return;
+    }
+    return (retryAfterMs(headers) ??
+        Math.min(RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_MAX_MS));
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener("abort", () => {
+            clearTimeout(timer);
+            resolve();
+        }, { once: true });
+    });
+}
+/**
+ * POSTs one protocol request, retrying transient failures with the same
+ * body until `until` or abort. A 409 is a lost or stale race; other
+ * permanent failures throw.
+ */
+async function postWithRetry(config, path, json, schema, until, signal) {
+    for (let attempt = 1;; attempt += 1) {
+        const remaining = until - Date.now();
+        if (signal.aborted || remaining <= 0) {
+            return "expired";
+        }
+        try {
+            await requestJson(config, path, {
+                json,
+                method: "POST",
+                signal: AbortSignal.any([signal, AbortSignal.timeout(remaining)]),
+            }, schema);
+            return "accepted";
+        }
+        catch (caught) {
+            const next = afterFailure(caught, attempt, until, signal);
+            if (typeof next === "string") {
+                return next;
+            }
+            await sleep(next, signal);
+        }
+    }
+}
+/** Classifies a failed attempt as a lost race, an exhausted budget, or the delay before retrying; permanent failures rethrow. */
+function afterFailure(caught, attempt, until, signal) {
+    const error = BlazingAgentsError.isInstance(caught) ? caught : undefined;
+    if (error?.status === 409) {
+        return "conflict";
+    }
+    if (signal.aborted || Date.now() >= until) {
+        return "expired";
+    }
+    const delay = error && retryDelayMs(error, attempt);
+    if (delay === undefined) {
+        throw caught;
+    }
+    return Date.now() + delay >= until ? "expired" : delay;
+}
+const invalidResult = {
+    kind: "error",
+    message: "Function returned an invalid result.",
+};
+/** Resolves `undefined` when the call became late or aborted before customer code could start. */
+async function execute(functions, { id, name, input }, deadline, signal) {
+    const fn = Object.hasOwn(functions, name) ? functions[name] : undefined;
+    if (fn === undefined) {
+        return { kind: "error", message: `Function ${name} is not available.` };
+    }
+    /** Refinements and transforms are customer code too. */
+    if (signal.aborted || Date.now() >= deadline) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = await fn.inputSchema.safeParseAsync(input);
+    }
+    catch {
+        /** Zod rethrows errors thrown inside refinements and transforms. */
+        return { kind: "error", message: "Invalid function input." };
+    }
+    if (!parsed.success) {
+        return { kind: "error", message: "Invalid function input." };
+    }
+    if (signal.aborted || Date.now() >= deadline) {
+        return;
+    }
+    let value;
+    try {
+        value = await fn.execute(parsed.data, { idempotencyKey: id, signal });
+    }
+    catch {
+        return { kind: "error", message: "Function execution failed." };
+    }
+    try {
+        /** Only plain JSON is accepted; undefined, NaN, Dates and class instances are invalid. */
+        return (chatFunctionOutcomeSchema.safeParse({ kind: "output", value }).data ??
+            invalidResult);
+    }
+    catch {
+        /** Cyclic values fail serialization in the size check. */
+        return invalidResult;
+    }
+}
+/**
+ * Reads native SSE eagerly and returns it without private function events,
+ * so slow consumers never delay a call. A recognized but malformed event
+ * fails the stream.
+ */
+export function stripFunctionEvents(body, { onCall, onCancel, onEnd } = {}) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let output;
+    let finished = false;
+    const fail = (error) => {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        output.error(error);
+        reader.cancel(error).catch(() => undefined);
+    };
+    const handleBlock = (block, raw) => {
+        const call = functionCallFrom(block);
+        if (call === undefined) {
+            if (raw && !finished) {
+                output.enqueue(encoder.encode(raw));
+            }
+        }
+        else if (call === null) {
+            fail(new BlazingAgentsError({
+                code: "stream_error",
+                message: "The server sent a malformed function call event.",
+            }));
+        }
+        else {
+            onCall?.(call.data, fail);
+        }
+    };
+    const pump = async () => {
+        let buffer = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                for (let match = EVENT_BOUNDARY.exec(buffer); match; match = EVENT_BOUNDARY.exec(buffer)) {
+                    const end = match.index + match[0].length;
+                    handleBlock(buffer.slice(0, match.index), buffer.slice(0, end));
+                    buffer = buffer.slice(end);
+                }
+            }
+            handleBlock("", buffer + decoder.decode());
+            if (!finished) {
+                finished = true;
+                output.close();
+            }
+        }
+        catch (error) {
+            fail(error);
+        }
+        finally {
+            onEnd?.();
+        }
+    };
+    return new ReadableStream({
+        start(controller) {
+            output = controller;
+            pump();
+        },
+        async cancel(reason) {
+            finished = true;
+            onCancel?.();
+            await reader.cancel(reason);
+        },
+    });
+}
+/** Strips private function events and executes claimed calls without blocking the read loop. */
+export function dispatchChatFunctions(config, target, body) {
+    /** Caller abort or consumer cancellation: stops every retry. */
+    const stop = new AbortController();
+    /** Also aborted when the stream ends: stops claims and handlers. */
+    const handlers = new AbortController();
+    const abort = () => stop.abort();
+    stop.signal.addEventListener("abort", () => handlers.abort(), {
+        once: true,
+    });
+    target.abortSignal?.addEventListener("abort", abort, { once: true });
+    if (target.abortSignal?.aborted) {
+        abort();
+    }
+    const dispatched = new Set();
+    const runCall = async (call) => {
+        const path = `/v1/agents/${target.agentId}/sessions/${target.sessionId}/function-calls/${call.id}`;
+        const claimRequestId = crypto.randomUUID();
+        const deadline = Date.parse(call.deadlineAt);
+        const claim = await postWithRetry(config, `${path}/claim`, { claimRequestId }, claimChatFunctionResponseSchema, deadline, handlers.signal);
+        if (claim !== "accepted") {
+            return;
+        }
+        /**
+         * A grant can arrive just before the deadline and be processed after it,
+         * or after abort; `execute` rechecks immediately before customer code.
+         */
+        const outcome = await execute(target.functions, call, deadline, AbortSignal.any([
+            handlers.signal,
+            AbortSignal.timeout(Math.max(0, deadline - Date.now())),
+        ]));
+        if (outcome === undefined) {
+            return;
+        }
+        await postWithRetry(config, `${path}/result`, { claimRequestId, outcome }, resolveChatFunctionResponseSchema, deadline + RESULT_RETRY_GRACE_MS, stop.signal);
+    };
+    return stripFunctionEvents(body, {
+        onCall(call, fail) {
+            if (!dispatched.has(call.id)) {
+                dispatched.add(call.id);
+                runCall(call).catch(fail);
+            }
+        },
+        onCancel: abort,
+        onEnd() {
+            handlers.abort();
+            target.abortSignal?.removeEventListener("abort", abort);
+        },
+    });
+}

package/dist/generation.d.ts

@@ -1,5 +1,11 @@
-import type { ChatInput, ChatResult, CompletionInput, CompletionResult, HttpConfig, ObjectInput, ObjectResult, TerminalStreamResult } from "./types.ts";
+import type { ChatInput, ChatResult, CompletionInput, CompletionResult, HttpConfig, ObjectInput, ObjectResult, ResumeChatInput, TerminalStreamResult } from "./types.ts";
 export declare function chat(config: HttpConfig, input: ChatInput): Promise<ChatResult>;
+export declare function resumeChat(config: HttpConfig, input: ResumeChatInput): Promise<ChatResult>;
+/**
+ * Keeps status and headers while filtering the SSE body. Missing or locked
+ * bodies pass through so the stream result reports them as `stream_error`.
+ */
+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 completion(config: HttpConfig, input: CompletionInput): Promise<CompletionResult>;
 export declare function objectGeneration(config: HttpConfig, input: ObjectInput): Promise<ObjectResult>;

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 { requestStream } from "./http.js";
+import { dispatchChatFunctions, toChatFunctionDefinitions, } from "./functions.js";
+import { requestJson, requestStream } from "./http.js";
 export async function chat(config, input) {
     const body = buildChatBody(input);
+    if (input.functions && Object.keys(input.functions).length > 0) {
+        body.functions = toChatFunctionDefinitions(input.functions);
+    }
     /**
      * URL presence is the mode: no `sessionId` → create
      * (`POST /v1/agents/:agentId/sessions`, server mints the `ss_` id,
@@ -19,7 +24,50 @@ export async function chat(config, input) {
         clientRequestId: input.clientRequestId,
         ...(input.abortSignal ? { signal: input.abortSignal } : {}),
     });
-    return buildChatResult(response, input.sessionId);
+    return buildChatResult(config, response, input.sessionId, {
+        agentId: input.agentId,
+        functions: input.functions,
+        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: {},
+        method: "POST",
+        clientRequestId: input.clientRequestId,
+        ...(input.abortSignal ? { signal: input.abortSignal } : {}),
+    });
+    return buildChatResult(config, response, input.sessionId, {
+        agentId: input.agentId,
+        functions: input.functions,
+        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`.
+ */
+export function withFilteredBody(response, filter) {
+    if (!response.body || response.body.locked) {
+        return response;
+    }
+    return new Response(filter(response.body), {
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+    });
 }
 function buildChatBody(input) {
     const base = {};
@@ -31,10 +79,6 @@ function buildChatBody(input) {
     if (input.messageId !== undefined) {
         base.messageId = input.messageId;
     }
-    // Stryker disable next-line ConditionalExpression: JSON serialization omits an undefined Version Pin.
-    if (input.version !== undefined) {
-        base.version = input.version;
-    }
     if ("message" in input) {
         base.message = input.message;
     }
@@ -83,32 +127,36 @@ function sessionIdFromLocation(response, requestId) {
     }
     return parsed.data;
 }
-function buildChatResult(response, resumeSessionId) {
-    const terminalResult = buildTerminalStreamResult(response, "chat");
+function buildChatResult(config, response, resumeSessionId, dispatch) {
     /**
      * `sessionId` resolves from the `Location` header on create, or to the
      * passed id on resume. Read eagerly (the header is available before the
      * body streams) so awaiting `result.sessionId` does not depend on
      * draining the stream.
      */
-    let sessionIdPromise;
-    if (resumeSessionId === undefined) {
+    let sessionId = resumeSessionId;
+    let sessionIdError;
+    if (sessionId === undefined) {
         try {
-            sessionIdPromise = Promise.resolve(sessionIdFromLocation(response, terminalResult.requestId));
+            sessionId = sessionIdFromLocation(response, response.headers.get("x-request-id") ?? undefined);
         }
         catch (error) {
-            sessionIdPromise = Promise.reject(error);
+            sessionIdError = error;
         }
     }
-    else {
-        sessionIdPromise = Promise.resolve(resumeSessionId);
-    }
+    const sessionIdPromise = sessionId === undefined
+        ? Promise.reject(sessionIdError)
+        : Promise.resolve(sessionId);
     sessionIdPromise.catch(() => {
         /* no-op — prevents unhandled rejection if the caller never awaits */
     });
+    const { functions } = dispatch;
+    const streamResponse = functions && sessionId !== undefined
+        ? withFilteredBody(response, (body) => dispatchChatFunctions(config, { ...dispatch, functions, sessionId }, body))
+        : response;
     return {
         sessionId: sessionIdPromise,
-        ...terminalResult,
+        ...buildTerminalStreamResult(streamResponse, "chat"),
     };
 }
 export function buildTerminalStreamResult(response, resourceName) {
@@ -234,10 +282,6 @@ function replacementResponseHeaders(requestId, location) {
 }
 function buildStatelessGenerationBody(input, output) {
     const body = { output };
-    // Stryker disable next-line ConditionalExpression: JSON serialization omits an undefined Version Pin.
-    if (input.version !== undefined) {
-        body.version = input.version;
-    }
     if ("prompt" in input) {
         body.prompt = input.prompt;
     }

package/dist/index.d.ts

@@ -6,19 +6,22 @@
 export type { UIMessage } from "ai";
 export { BlazingAgentsChatTransport, type BlazingAgentsChatTransportOptions, } from "./chat-transport.ts";
 export { BlazingAgents } from "./client.ts";
-export type { ApprovalDecision, ApprovalPolicy, ToolReference, } from "./contracts/entities/agent-approval.ts";
-export type { Agent, AgentResponse, AgentsListQuery, AgentsResponse, AgentVersion, AgentVersionsListQuery, AgentVersionsResponse, CreateAgentBody, UpdateAgentBody, } from "./contracts/entities/agents.ts";
+export type { ApprovalDecision, ApprovalPolicy, ToolExecutionReference, ToolReference, } from "./contracts/entities/agent-approval.ts";
+export type { Agent, AgentConfig, AgentResponse, AgentsListQuery, AgentsResponse, CreateAgentBody, UpdateAgentBody, } from "./contracts/entities/agents.ts";
+export { agentConfigSchema } from "./contracts/entities/agents.ts";
 export type { ArtifactDownloadUrlResponse, ArtifactListItem, ArtifactsListResponse, } from "./contracts/entities/artifacts.ts";
 export type { ChatConfiguration, ChatConnection, ChatConnectionsResponse, ChatCredentials, ChatDeliveriesResponse, ChatDelivery, ChatDeliveryListStatus, ChatDeliveryStatus, ChatHealth, ChatIdentity, CreateChatConnectionBody, RotateChatConnectionBody, TenantChatDelivery, UpdateChatConnectionBody, } from "./contracts/entities/chat-connections.ts";
 export type { CreateMcpConnectionBody, McpAttachmentResponse, McpAttachmentsResponse, McpConnectionAuthType, McpConnectionOauthConnectResponse, McpConnectionReconnectResult, McpConnectionResponse, McpConnectionStatus, McpConnectionTestResponse, ReconnectMcpConnectionBody, UpdateMcpAttachmentBody, UpdateMcpConnectionBody, } from "./contracts/entities/mcp-connections.ts";
 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 { ToolApprovalDecisionResponse, ToolApprovalState, ToolApprovalsResponse, } from "./contracts/entities/sessions.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";
 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 { 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, AgentVersionsListOptions, 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, 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, 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";

package/dist/index.js

@@ -6,6 +6,9 @@
 // biome-ignore lint/performance/noBarrelFile: package entry point
 export { BlazingAgentsChatTransport, } from "./chat-transport.js";
 export { BlazingAgents } from "./client.js";
+export { agentConfigSchema } from "./contracts/entities/agents.js";
+export { sessionResponseSchema } from "./contracts/entities/sessions.js";
 export { BlazingAgentsDirectChatTransport, } from "./direct-chat-transport.js";
 export { BlazingAgentsError } from "./errors.js";
+export { defineFunction, } from "./functions.js";
 export { createChatRelay, createCompletionRelay, } from "./relay.js";

package/dist/relay.d.ts

@@ -1,20 +1,26 @@
 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. */
+    functions?: ChatFunctions;
     metadata?: Record<string, unknown>;
     userId: string;
-    version?: number;
 }
 export interface SessionOwnershipStore {
     ownerOf(sessionId: string): Promise<string | undefined>;
     recordOwner(sessionId: string, userId: string): Promise<void>;
 }
-interface RelayOptions {
-    client: Pick<BlazingAgents, "chat" | "completion">;
+interface RelayOptions<Method extends keyof BlazingAgents> {
+    client: Pick<BlazingAgents, Method>;
     resolveContext(request: Request): Promise<RelayContext | null>;
 }
-export declare function createChatRelay(options: RelayOptions & {
+/**
+ * Relays useChat submissions. An assistant message carrying approval
+ * responses records each decision and then streams the continuation.
+ */
+export declare function createChatRelay(options: RelayOptions<"chat" | "resumeChat" | "sessions"> & {
     sessions: SessionOwnershipStore;
 }): (request: Request) => Promise<Response>;
-export declare function createCompletionRelay(options: RelayOptions): (request: Request) => Promise<Response>;
+export declare function createCompletionRelay(options: RelayOptions<"completion">): (request: Request) => Promise<Response>;
 export {};

package/dist/relay.js

@@ -1,5 +1,6 @@
 import { safeValidateUIMessages } from "ai";
 import { z } from "zod";
+import { decideApprovalResponses } from "./approvals.js";
 import { sessionIdSchema } from "./contracts/ids.js";
 import { BlazingAgentsError } from "./errors.js";
 const chatBodySchema = z.object({
@@ -11,6 +12,10 @@ const chatBodySchema = z.object({
         .default("submit-message"),
 });
 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.
+ */
 export function createChatRelay(options) {
     return async (request) => {
         try {
@@ -29,9 +34,20 @@ export function createChatRelay(options) {
                 (await options.sessions.ownerOf(body.sessionId)) !== context.userId) {
                 return errorResponse(403, "forbidden", "Session is not available.");
             }
+            const message = validated.data[0];
+            if (message.role === "assistant") {
+                return await relayApprovalResponses(options.client, {
+                    agentId: context.agentId,
+                    functions: context.functions,
+                    message,
+                    request,
+                    sessionId: body.sessionId,
+                });
+            }
             const chatInput = {
                 agentId: context.agentId,
-                message: validated.data[0],
+                functions: context.functions,
+                message,
                 messageId: body.messageId,
                 metadata: context.metadata,
                 abortSignal: request.signal,
@@ -41,7 +57,6 @@ export function createChatRelay(options) {
                 ? {
                     ...chatInput,
                     trigger: "submit-message",
-                    version: context.version,
                 }
                 : {
                     ...chatInput,
@@ -68,6 +83,30 @@ export function createChatRelay(options) {
         }
     };
 }
+async function relayApprovalResponses(client, { functions, message, request, ...input }) {
+    if (input.sessionId === undefined) {
+        return errorResponse(400, "invalid_request", "Tool approval requires an existing Session.");
+    }
+    const target = {
+        agentId: input.agentId,
+        sessionId: input.sessionId,
+        abortSignal: request.signal,
+    };
+    const continuationId = await decideApprovalResponses(client, {
+        ...target,
+        message,
+    });
+    if (continuationId === undefined) {
+        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({
+        ...target,
+        continuationId,
+        functions: functions ?? {},
+    });
+    return continuation.toResponse();
+}
 export function createCompletionRelay(options) {
     return async (request) => {
         try {
@@ -82,7 +121,6 @@ export function createCompletionRelay(options) {
                 prompt: body.prompt,
                 abortSignal: request.signal,
                 userId: context.userId,
-                version: context.version,
             });
             return result.toResponse();
         }