@to11ai/sdk 0.6.0 → 0.8.1

package/dist/prompts/resource.cjs

@@ -53,7 +53,9 @@ var zResolvedPromptLegacy = import_zod2.zResolvedPrompt.pick({
   version: true,
   labels: true,
   contentHash: true,
-  rendered: true
+  rendered: true,
+  tools: true,
+  toolChoice: true
 });
 var zResolvedPromptEnvelope = import_zod2.zResolvedPrompt.partial({ releaseId: true }).extend({ strategy: import_zod.z.enum(["single", "weighted"]).optional() });
 function unwrap(envelope) {
@@ -84,6 +86,12 @@ function normalizeResolvedEnvelope(raw) {
     labels: raw.labels,
     rendered: raw.rendered
   };
+  if (raw.tools != null && raw.tools.length > 0) {
+    result.tools = raw.tools;
+  }
+  if (raw.toolChoice != null) {
+    result.toolChoice = raw.toolChoice;
+  }
   if (typeof provenance.variantName === "string" && provenance.variantName.length > 0) {
     result.variantName = provenance.variantName;
   }
@@ -215,9 +223,10 @@ class PromptResource {
       subject,
       variables,
       cache: useCache = true,
-      fallback
+      fallback,
+      developerRole
     } = options;
-    const cacheKey = import_cache.buildFetchCacheKey(this.projectId, slug, env, context, subject, variables);
+    const cacheKey = import_cache.buildFetchCacheKey(this.projectId, slug, env, context, subject, variables, developerRole);
     if (useCache) {
       const cached = this.cache.get(cacheKey);
       if (cached && "messages" in cached)
@@ -230,6 +239,8 @@ class PromptResource {
       body.subject = subject;
     if (variables !== undefined)
       body.variables = variables;
+    if (developerRole !== undefined)
+      body.developerRole = developerRole;
     try {
       const envelope = await this.transport.request("POST", `${getProjectPromptsPath(this.projectId)}:resolve`, {
         body,

package/dist/prompts/resource.d.ts

@@ -2,7 +2,7 @@ import type { Transport } from "../transport";
 import type { CacheConfig } from "./cache";
 import type { ArchivePromptInput, ArchivePromptResult, CreateProjectPromptLabelInput, CreateProjectPromptLabelResult, CreatePromptInput, CreatePromptResult, CreatePromptVersionInput, CreatePromptVersionResult, DeleteProjectPromptLabelInput, DeleteProjectPromptLabelResult, FetchedPrompt, FetchPromptOptions, GetProjectPromptLabelInput, GetProjectPromptLabelResult, GetPromptInput, GetPromptResult, GetPromptVersionInput, GetPromptVersionResult, ListLabelEventsInput, ListLabelEventsResult, ListProjectPromptLabelsInput, ListProjectPromptLabelsResult, ListProjectPromptLabelUsagesInput, ListProjectPromptLabelUsagesResult, ListPromptLabelsInput, ListPromptLabelsResult, ListPromptsInput, ListPromptsResult, ListPromptVersionsInput, ListPromptVersionsResult, MovePromptLabelInput, MovePromptLabelResult, PaginatedResult, ResolvePromptInput, ResolvePromptResult, UpdateProjectPromptLabelInput, UpdateProjectPromptLabelResult, UpdatePromptInput, UpdatePromptResult } from "./types";
 export type { CacheConfig } from "./cache";
-export type { ArchivePromptInput, ArchivePromptResult, BlockRenderRecord, ChatMessage, CreateProjectPromptLabelInput, CreateProjectPromptLabelResult, CreatePromptInput, CreatePromptResult, CreatePromptVersionInput, CreatePromptVersionResult, DeleteProjectPromptLabelInput, DeleteProjectPromptLabelResult, FetchedPrompt, FetchPromptOptions, GetProjectPromptLabelInput, GetProjectPromptLabelResult, GetPromptInput, GetPromptResult, GetPromptVersionInput, GetPromptVersionResult, ListLabelEventsInput, ListLabelEventsResult, ListProjectPromptLabelsInput, ListProjectPromptLabelsResult, ListProjectPromptLabelUsagesInput, ListProjectPromptLabelUsagesResult, ListPromptLabelsInput, ListPromptLabelsResult, ListPromptsInput, ListPromptsResult, ListPromptVersionsInput, ListPromptVersionsResult, MovePromptLabelInput, MovePromptLabelResult, PaginatedResult, PaginationInfo, PaletteToken, ProjectPromptLabel, ProjectPromptLabelUsage, Prompt, PromptContext, PromptFormat, PromptLabelEvent, PromptLabelPointer, PromptStatus, PromptVersion, RenderedChatMessage, RenderedPrompt, ResolvedPrompt, ResolvedPromptEnvelope, ResolvePromptInput, ResolvePromptResult, RowError, TextChatMessage, TextChatRole, ToolChatMessage, UpdateProjectPromptLabelInput, UpdateProjectPromptLabelResult, UpdatePromptInput, UpdatePromptResult, } from "./types";
+export type { ArchivePromptInput, ArchivePromptResult, BlockRenderRecord, ChatMessage, CreateProjectPromptLabelInput, CreateProjectPromptLabelResult, CreatePromptInput, CreatePromptResult, CreatePromptVersionInput, CreatePromptVersionResult, DeleteProjectPromptLabelInput, DeleteProjectPromptLabelResult, FetchedPrompt, FetchPromptOptions, GetProjectPromptLabelInput, GetProjectPromptLabelResult, GetPromptInput, GetPromptResult, GetPromptVersionInput, GetPromptVersionResult, ListLabelEventsInput, ListLabelEventsResult, ListProjectPromptLabelsInput, ListProjectPromptLabelsResult, ListProjectPromptLabelUsagesInput, ListProjectPromptLabelUsagesResult, ListPromptLabelsInput, ListPromptLabelsResult, ListPromptsInput, ListPromptsResult, ListPromptVersionsInput, ListPromptVersionsResult, MovePromptLabelInput, MovePromptLabelResult, PaginatedResult, PaginationInfo, PaletteToken, ProjectPromptLabel, ProjectPromptLabelUsage, Prompt, PromptContext, PromptFormat, PromptLabelEvent, PromptLabelPointer, PromptStatus, PromptVersion, RenderedChatMessage, RenderedPrompt, ResolvedPrompt, ResolvedPromptEnvelope, ResolvedToolCall, ResolvedToolDefinition, ResolvePromptInput, ResolvePromptResult, RowError, TextChatMessage, TextChatRole, UpdateProjectPromptLabelInput, UpdateProjectPromptLabelResult, UpdatePromptInput, UpdatePromptResult, } from "./types";
 /**
  * Init-time config for the env-aware `fetch()` surface (TO11-980 / S9).
  *

package/dist/prompts/resource.js

@@ -10,7 +10,9 @@ var zResolvedPromptLegacy = zResolvedPrompt.pick({
   version: true,
   labels: true,
   contentHash: true,
-  rendered: true
+  rendered: true,
+  tools: true,
+  toolChoice: true
 });
 var zResolvedPromptEnvelope = zResolvedPrompt.partial({ releaseId: true }).extend({ strategy: z.enum(["single", "weighted"]).optional() });
 function unwrap(envelope) {
@@ -41,6 +43,12 @@ function normalizeResolvedEnvelope(raw) {
     labels: raw.labels,
     rendered: raw.rendered
   };
+  if (raw.tools != null && raw.tools.length > 0) {
+    result.tools = raw.tools;
+  }
+  if (raw.toolChoice != null) {
+    result.toolChoice = raw.toolChoice;
+  }
   if (typeof provenance.variantName === "string" && provenance.variantName.length > 0) {
     result.variantName = provenance.variantName;
   }
@@ -172,9 +180,10 @@ class PromptResource {
       subject,
       variables,
       cache: useCache = true,
-      fallback
+      fallback,
+      developerRole
     } = options;
-    const cacheKey = buildFetchCacheKey(this.projectId, slug, env, context, subject, variables);
+    const cacheKey = buildFetchCacheKey(this.projectId, slug, env, context, subject, variables, developerRole);
     if (useCache) {
       const cached = this.cache.get(cacheKey);
       if (cached && "messages" in cached)
@@ -187,6 +196,8 @@ class PromptResource {
       body.subject = subject;
     if (variables !== undefined)
       body.variables = variables;
+    if (developerRole !== undefined)
+      body.developerRole = developerRole;
     try {
       const envelope = await this.transport.request("POST", `${getProjectPromptsPath(this.projectId)}:resolve`, {
         body,

package/dist/prompts/types.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectPromptLabel as GenProjectPromptLabel, ProjectPromptLabelUsage as GenProjectPromptLabelUsage, Prompt as GenPrompt, PromptLabelEvent as GenPromptLabelEvent, PromptLabelPointer as GenPromptLabelPointer, PromptVersion as GenPromptVersion, RenderedChatPrompt as GenRenderedChatPrompt, RenderedPrompt as GenRenderedPrompt, ResolvedPrompt as GenResolvedPrompt } from "../generated/types.gen";
+import type { ProjectPromptLabel as GenProjectPromptLabel, ProjectPromptLabelUsage as GenProjectPromptLabelUsage, Prompt as GenPrompt, PromptLabelEvent as GenPromptLabelEvent, PromptLabelPointer as GenPromptLabelPointer, PromptVersion as GenPromptVersion, RenderedChatPrompt as GenRenderedChatPrompt, RenderedPrompt as GenRenderedPrompt, ResolvedPrompt as GenResolvedPrompt, ResolvedToolCall as GenResolvedToolCall, ResolvedToolDefinition as GenResolvedToolDefinition } from "../generated/types.gen";
 export interface RowError {
     path: ReadonlyArray<string | number>;
     code: string;
@@ -15,17 +15,21 @@ export interface TextChatMessage {
     content: string;
     disabled?: boolean;
 }
-export interface ToolChatMessage {
-    role: "tool";
-    name: string;
-    description?: string;
-    parameters: unknown;
-    disabled?: boolean;
-}
-export type ChatMessage = TextChatMessage | ToolChatMessage;
+export type ChatMessage = TextChatMessage;
 export type RenderedChatMessage = GenRenderedChatPrompt["messages"][number];
 export type RenderedPrompt = GenRenderedPrompt;
-export type ResolvedPrompt = Pick<GenResolvedPrompt, "promptId" | "versionId" | "version" | "labels" | "contentHash" | "rendered">;
+/**
+ * A provider-neutral tool definition (`{ name, description?, parameters }`),
+ * sourced from authored tool-definition blocks. Surfaced on the resolved
+ * contract and shaped for a provider via `toOpenAITools` / `toAnthropicTools`.
+ */
+export type ResolvedToolDefinition = GenResolvedToolDefinition;
+/**
+ * A structured assistant tool call (`{ id, name, arguments }`) carried inline
+ * on a rendered `assistant` turn (few-shot multi-tool history).
+ */
+export type ResolvedToolCall = GenResolvedToolCall;
+export type ResolvedPrompt = Pick<GenResolvedPrompt, "promptId" | "versionId" | "version" | "labels" | "contentHash" | "rendered" | "tools" | "toolChoice">;
 export interface PaginationInfo {
     page: number;
     limit: number;
@@ -77,6 +81,7 @@ export interface CreatePromptVersionInput {
     format: PromptFormat;
     templateJson: unknown;
     variablesSchema: unknown;
+    contextSchema?: unknown;
     modelConfig?: unknown;
     changelog?: string;
 }
@@ -130,11 +135,34 @@ export interface FetchedPrompt {
     contentHash: string;
     labels: string[];
     rendered: RenderedPrompt;
+    /**
+     * Provider-neutral tool definitions lifted from authored tool-definition
+     * blocks. Absent (rather than `[]`) when the resolved version declares no
+     * tools. Shape for a provider with `toOpenAITools` / `toAnthropicTools`.
+     */
+    tools?: ResolvedToolDefinition[];
+    /**
+     * Provider-neutral tool-choice directive lifted from the resolved version.
+     * Absent (rather than `null`) when the version declares none. Feed straight
+     * into `toOpenAIToolChoice` / `toAnthropicToolChoice`.
+     *
+     * `NonNullable` because `normalizeResolvedEnvelope` maps wire-`null` to absent,
+     * so a present `FetchedPrompt.toolChoice` is never `null` — callers get the
+     * key or nothing, and never have to branch on `null`.
+     */
+    toolChoice?: NonNullable<ResolvedPrompt["toolChoice"]>;
 }
 export type ResolvedPromptEnvelope = GenResolvedPrompt & {
     /** Active release strategy. Used to decide weighted-no-subject cache bypass (D8). */
     strategy?: "single" | "weighted";
 };
+/**
+ * How an authored `developer` block is rendered. The caller controls this
+ * per-call because it knows the upstream it targets. Omitted ⇒ `"user"`
+ * (back-compatible; safe for any upstream). `"developer"` preserves the role
+ * (OpenAI); `"system"` folds it into a system message.
+ */
+export type DeveloperRole = "user" | "developer" | "system";
 export interface FetchPromptOptions {
     env?: string;
     context?: PromptContext;
@@ -142,6 +170,12 @@ export interface FetchPromptOptions {
     variables?: Record<string, unknown>;
     cache?: boolean;
     fallback?: ResolvedPrompt | FetchedPrompt;
+    /**
+     * How authored `developer` blocks render. Default `"user"`. Forwarded on the
+     * resolve request and folded into the cache key so two calls differing only
+     * by `developerRole` never share a cached result.
+     */
+    developerRole?: DeveloperRole;
 }
 export type PaletteToken = ProjectPromptLabel["displayColor"];
 export type ProjectPromptLabel = GenProjectPromptLabel;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@to11ai/sdk",
-	"version": "0.6.0",
+	"version": "0.8.1",
 	"license": "MPL-2.0",
 	"repository": {
 		"type": "git",

package/src/client.ts

@@ -66,6 +66,7 @@ export { PromptResource } from "./prompts/resource";
 // TO11-980 (S9): env-aware fetch() surface types at the package entrypoint (AC9).
 export type {
 	BlockRenderRecord,
+	DeveloperRole,
 	FetchedPrompt,
 	FetchPromptOptions,
 	PromptContext,

package/src/gateway.ts

@@ -1,7 +1,9 @@
 import {
 	ENV_SLUG_REGEX,
 	type FetchedPrompt,
+	type RenderedChatMessage,
 	type ResolvedPrompt,
+	type ResolvedToolDefinition,
 } from "./prompts/types";
 
 export interface GatewayAuthOptions {
@@ -117,3 +119,298 @@ export function gatewayPromptHeaders(
 	}
 	return headers;
 }
+
+// ─── Provider-shape converters (TO11-2592) ───────────────────────────────────
+//
+// The to11 SDK is HEADER-ONLY: it never builds an LLM request body. The
+// customer's own provider client sends the messages + tools. These converters
+// reshape the provider-neutral resolved data (`tools`, rendered `messages`)
+// into the shapes the OpenAI / Anthropic clients expect, so callers don't
+// hand-roll the translation. They are pure and side-effect free.
+
+/** OpenAI Chat Completions `tools[]` entry (`function` tool). */
+export interface OpenAITool {
+	type: "function";
+	function: {
+		name: string;
+		description?: string;
+		parameters: Record<string, unknown>;
+	};
+}
+
+/** OpenAI `tool_choice` value for a Chat Completions request. */
+export type OpenAIToolChoice =
+	| "auto"
+	| "none"
+	| "required"
+	| { type: "function"; function: { name: string } };
+
+/** OpenAI Chat Completions assistant `tool_calls[]` entry. */
+export interface OpenAIToolCall {
+	id: string;
+	type: "function";
+	function: { name: string; arguments: string };
+}
+
+/** OpenAI Chat Completions `messages[]` entry. */
+export interface OpenAIChatMessage {
+	role: "system" | "developer" | "user" | "assistant" | "tool";
+	content?: string | null;
+	tool_calls?: OpenAIToolCall[];
+	tool_call_id?: string;
+}
+
+/** Anthropic Messages `tools[]` entry. */
+export interface AnthropicTool {
+	name: string;
+	description?: string;
+	input_schema: Record<string, unknown>;
+}
+
+/** Anthropic Messages content block (the subset the converters emit). */
+export type AnthropicContentBlock =
+	| { type: "text"; text: string }
+	| {
+			type: "tool_use";
+			id: string;
+			name: string;
+			input: Record<string, unknown>;
+	  }
+	| { type: "tool_result"; tool_use_id: string; content: string };
+
+/** Anthropic Messages `messages[]` entry. */
+export interface AnthropicMessage {
+	role: "user" | "assistant";
+	content: string | AnthropicContentBlock[];
+}
+
+/** Anthropic Messages `tool_choice` value. */
+export type AnthropicToolChoice =
+	| { type: "auto" }
+	| { type: "any" }
+	| { type: "none" }
+	| { type: "tool"; name: string };
+
+/**
+ * Shape resolved tool definitions for the OpenAI Chat Completions `tools`
+ * field: `{ type: "function", function: { name, description?, parameters } }`.
+ *
+ * Accepts the optional `prompt.tools` directly (nullish ⇒ `[]`). `description`
+ * is emitted only when present (OpenAI rejects a `null` description).
+ *
+ * @example
+ * const tools = toOpenAITools(prompt.tools);
+ * const tool_choice = toOpenAIToolChoice(prompt.toolChoice);
+ * await openai.chat.completions.create({ model, messages, tools, tool_choice });
+ */
+export function toOpenAITools(
+	tools: ReadonlyArray<ResolvedToolDefinition> | null | undefined,
+): OpenAITool[] {
+	if (tools == null) return [];
+	return tools.map((tool) => {
+		const fn: OpenAITool["function"] = {
+			name: tool.name,
+			parameters: tool.parameters,
+		};
+		if (typeof tool.description === "string") {
+			fn.description = tool.description;
+		}
+		return { type: "function", function: fn };
+	});
+}
+
+/**
+ * Map a resolved prompt's provider-neutral `toolChoice` to the OpenAI
+ * Chat Completions `tool_choice` field.
+ *
+ * - `null` / `undefined` → `undefined` (omit the field)
+ * - `"auto"` → `"auto"`, `"none"` → `"none"`, `"required"` → `"required"`
+ * - `{ name }` → `{ type: "function", function: { name } }`
+ *
+ * @example
+ * const tools = toOpenAITools(prompt.tools);
+ * const tool_choice = toOpenAIToolChoice(prompt.toolChoice);
+ * await openai.chat.completions.create({ model, messages, tools, tool_choice });
+ */
+export function toOpenAIToolChoice(
+	toolChoice: ResolvedPrompt["toolChoice"],
+): OpenAIToolChoice | undefined {
+	if (toolChoice == null) return undefined;
+	if (typeof toolChoice === "string") return toolChoice;
+	return { type: "function", function: { name: toolChoice.name } };
+}
+
+/**
+ * Shape resolved tool definitions for the Anthropic Messages `tools` field:
+ * `{ name, description?, input_schema }` (Anthropic names the JSON Schema field
+ * `input_schema`, mapping from the provider-neutral `parameters`).
+ *
+ * @example
+ * const tools = toAnthropicTools(prompt.tools);
+ * const tool_choice = toAnthropicToolChoice(prompt.toolChoice);
+ * await anthropic.messages.create({ model, system, messages, tools, tool_choice });
+ */
+export function toAnthropicTools(
+	tools: ReadonlyArray<ResolvedToolDefinition> | null | undefined,
+): AnthropicTool[] {
+	if (tools == null) return [];
+	return tools.map((tool) => {
+		const out: AnthropicTool = {
+			name: tool.name,
+			input_schema: tool.parameters,
+		};
+		if (typeof tool.description === "string") {
+			out.description = tool.description;
+		}
+		return out;
+	});
+}
+
+/**
+ * Map a resolved prompt's provider-neutral `toolChoice` to the Anthropic
+ * Messages `tool_choice` field.
+ *
+ * - `null` / `undefined` → `undefined` (omit the field)
+ * - `"auto"` → `{ type: "auto" }`
+ * - `"none"` → `{ type: "none" }` (the Anthropic API supports this natively)
+ * - `"required"` → `{ type: "any" }` (Anthropic's name for "must invoke a tool")
+ * - `{ name }` → `{ type: "tool", name }`
+ *
+ * @example
+ * const tools = toAnthropicTools(prompt.tools);
+ * const tool_choice = toAnthropicToolChoice(prompt.toolChoice);
+ * await anthropic.messages.create({ model, system, messages, tools, tool_choice });
+ */
+export function toAnthropicToolChoice(
+	toolChoice: ResolvedPrompt["toolChoice"],
+): AnthropicToolChoice | undefined {
+	if (toolChoice == null) return undefined;
+	if (toolChoice === "auto") return { type: "auto" };
+	if (toolChoice === "none") return { type: "none" };
+	if (toolChoice === "required") return { type: "any" };
+	return { type: "tool", name: toolChoice.name };
+}
+
+/**
+ * Guard a tool-call linkage id before it is serialized into a provider payload.
+ * A missing/empty id means malformed tool history (an assistant tool call or a
+ * tool result authored without its `id`/`toolCallId`); emitting an empty string
+ * would produce a request the provider rejects with an opaque error, so fail
+ * fast with a clear message instead.
+ */
+function requireToolCallId(id: string | undefined | null): string {
+	if (typeof id !== "string" || id.length === 0) {
+		throw new Error(
+			"to11 SDK: malformed tool history — a tool call/result is missing its id (toolCallId). Author a non-empty id before converting messages.",
+		);
+	}
+	return id;
+}
+
+/**
+ * Shape rendered turns for the OpenAI Chat Completions `messages` field.
+ *
+ * - `system` / `developer` / `user` → `{ role, content }` (OpenAI carries
+ *   `developer` natively).
+ * - `assistant` → `{ role, content, tool_calls? }`; structured `toolCalls`
+ *   become `tool_calls[]` with JSON-stringified `arguments` (the OpenAI wire
+ *   shape). A pure tool-call turn keeps `content: null`.
+ * - `tool` (result) → `{ role: "tool", tool_call_id, content }`.
+ *
+ * @example
+ * const messages = toOpenAIMessages(prompt.messages);
+ */
+export function toOpenAIMessages(
+	messages: ReadonlyArray<RenderedChatMessage>,
+): OpenAIChatMessage[] {
+	return messages.map((message) => {
+		if (message.role === "tool") {
+			return {
+				role: "tool",
+				tool_call_id: requireToolCallId(message.toolCallId),
+				content: message.content ?? "",
+			};
+		}
+		if (message.role === "assistant") {
+			const out: OpenAIChatMessage = {
+				role: "assistant",
+				content: message.content ?? null,
+			};
+			if (message.toolCalls != null && message.toolCalls.length > 0) {
+				out.tool_calls = message.toolCalls.map((call) => ({
+					id: requireToolCallId(call.id),
+					type: "function",
+					function: {
+						name: call.name,
+						arguments: JSON.stringify(call.arguments),
+					},
+				}));
+			}
+			return out;
+		}
+		return { role: message.role, content: message.content ?? "" };
+	});
+}
+
+/**
+ * Shape rendered turns for the Anthropic Messages `messages` field.
+ *
+ * - `system` / `developer` turns are OMITTED — Anthropic carries instruction
+ *   content in the top-level `system` parameter, not the `messages` array
+ *   (mirrors the gateway's `developer`→`system` fold). Pass them to `system`
+ *   yourself.
+ * - `user` → `{ role: "user", content }`.
+ * - `assistant` with `toolCalls` → `{ role: "assistant", content: [text?,
+ *   ...tool_use] }`; without calls → `{ role: "assistant", content }`.
+ * - `tool` (result) → `{ role: "user", content: [{ type: "tool_result",
+ *   tool_use_id, content }] }`.
+ *
+ * @example
+ * const messages = toAnthropicMessages(prompt.messages);
+ */
+export function toAnthropicMessages(
+	messages: ReadonlyArray<RenderedChatMessage>,
+): AnthropicMessage[] {
+	const out: AnthropicMessage[] = [];
+	for (const message of messages) {
+		if (message.role === "system" || message.role === "developer") {
+			continue;
+		}
+		if (message.role === "tool") {
+			out.push({
+				role: "user",
+				content: [
+					{
+						type: "tool_result",
+						tool_use_id: requireToolCallId(message.toolCallId),
+						content: message.content ?? "",
+					},
+				],
+			});
+			continue;
+		}
+		if (message.role === "assistant") {
+			if (message.toolCalls != null && message.toolCalls.length > 0) {
+				const blocks: AnthropicContentBlock[] = [];
+				if (typeof message.content === "string" && message.content.length > 0) {
+					blocks.push({ type: "text", text: message.content });
+				}
+				for (const call of message.toolCalls) {
+					blocks.push({
+						type: "tool_use",
+						id: requireToolCallId(call.id),
+						name: call.name,
+						input: call.arguments,
+					});
+				}
+				out.push({ role: "assistant", content: blocks });
+			} else {
+				out.push({ role: "assistant", content: message.content ?? "" });
+			}
+			continue;
+		}
+		// `user`
+		out.push({ role: "user", content: message.content ?? "" });
+	}
+	return out;
+}