@agent-native/core 0.118.1 → 0.119.1

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,11 +27,11 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
+    error?: undefined;
 }>>;
 export {};
 //# sourceMappingURL=agent-engine-api-key-route.d.ts.map

package/dist/server/realtime-token.d.ts

@@ -26,9 +26,9 @@ export declare function createRealtimeTokenHandler(): import("h3").EventHandlerW
     expiresAt?: undefined;
     ttlSeconds?: undefined;
 } | {
-    error?: undefined;
     token: string;
     expiresAt: string;
     ttlSeconds: number;
+    error?: undefined;
 }>>;
 //# sourceMappingURL=realtime-token.d.ts.map

package/dist/server/transcribe-voice.d.ts

@@ -20,7 +20,7 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    text: string;
     error?: undefined;
+    text: string;
 }>>;
 //# sourceMappingURL=transcribe-voice.d.ts.map

package/dist/templates/workspace-core/.agents/skills/a2a-protocol/SKILL.md

@@ -195,6 +195,22 @@ for await (const update of client.stream({
 }
 ```
 
+### Agent activity in delegated chat
+
+Agent Native peers attach a bounded `data` part with
+`kind: "agent-native/agent-activity"` to in-progress and terminal task status
+messages. It contains the same user-visible reasoning summaries shown in the
+receiving app, tool names and completion states, elapsed time, and progressive
+response text. It never includes tool inputs, tool results, credentials, or
+hidden provider reasoning.
+
+`call-agent` reads this optional part while it polls an asynchronous task and
+renders the remote work as a nested agent run. Unknown A2A peers do not need to
+implement the extension: their ordinary status and final text still render in
+the same nested block. Treat activity data as untrusted presentation content;
+never use it for identity, authorization, approval, routing, or artifact
+validation.
+
 ### Carrying explicit chat authorization
 
 When the authenticated caller has an exact consequential action that the user

package/docs/content/a2a-protocol.mdx

@@ -434,6 +434,21 @@ Like `callAgent()`, the CLI defaults to async + poll (`invokeAgent` → `callAge
 
 The target resolves the same way as `agentNative.invoke()`: by workspace app id, by app name, or by a full URL — so the same command works against a sibling app in a multi-app workspace or an arbitrary A2A peer elsewhere.
 
+## Delegated agent activity {#delegated-agent-activity}
+
+Agent Native peers may attach an optional `data` part with
+`kind: "agent-native/agent-activity"` to task status messages. It carries a
+bounded snapshot of the user-visible reasoning summaries, tool names and
+completion states, elapsed time, and progressive response text. Calling apps
+render these updates as a nested agent run and collapse the work history when
+the delegated task finishes.
+
+The activity part never includes tool inputs, tool results, credentials, or
+hidden provider reasoning. Treat it as untrusted presentation data, never as
+identity, authorization, approval, routing, or artifact validation. External
+A2A peers can omit the extension; their ordinary status text and final response
+still render in the same delegated-agent surface.
+
 ## Task lifecycle {#task-lifecycle}
 
 Each message creates a task that moves through these states:

package/docs/content/template-chat.mdx

@@ -13,7 +13,7 @@ If you want a finished domain product shape, start from [Calendar](/docs/templat
   <Screen
     surface="desktop"
     html={
-      "<div style='min-height:560px;box-sizing:border-box;display:flex;align-items:center;justify-content:center;padding:56px 40px'><div style='display:flex;flex-direction:column;align-items:center;justify-content:center;gap:28px;width:min(700px,92%);min-height:430px'><div style='height:34px'></div><div style='text-align:center'><h1 style='margin:0'>How can I help?</h1><p class='wf-muted' style='margin:10px 0 0'>Chat about anything. Add actions, components, pages, jobs, or your own backend.</p></div><div class='wf-card' style='width:100%;min-height:150px;display:flex;flex-direction:column;gap:18px'><span class='wf-muted'>Message the agent...</span><div style='flex:1'></div><div style='display:flex;align-items:center;gap:10px'><span data-icon='plus' aria-label='Attach'></span><div style='flex:1'></div><span class='wf-pill'>Sonnet 5 · Auto</span><span class='wf-pill'>Act</span><button class='primary'>↑</button></div></div><div style='height:34px'></div></div></div>"
+      "<div style='min-height:560px;box-sizing:border-box;display:flex;align-items:center;justify-content:center;padding:56px 40px'><div style='display:flex;flex-direction:column;align-items:center;justify-content:center;gap:28px;width:min(700px,92%);min-height:430px'><div style='height:34px'></div><div style='text-align:center'><h1 style='margin:0'>How can I help?</h1><p class='wf-muted' style='margin:10px 0 0'>Chat about anything. Add actions, components, pages, jobs, or your own backend.</p></div><div class='wf-card' style='width:100%;min-height:150px;display:flex;flex-direction:column;gap:18px'><span class='wf-muted'>Message the agent...</span><div style='flex:1'></div><div style='display:flex;align-items:center;gap:10px'><span data-icon='plus' aria-label='Attach'></span><div style='flex:1'></div><span class='wf-pill'>GPT-5.6 Luna · Auto</span><span class='wf-pill'>Act</span><button class='primary'>↑</button></div></div><div style='height:34px'></div></div></div>"
     }
   />
 </WireframeBlock>

package/docs/content/template-plan.mdx

@@ -232,9 +232,9 @@ Generating a plan or recap runs a full agentic session against your coding
 agent's LLM, not a lightweight template fill, so cost scales with the size of
 the diff or plan and the model you choose.
 
-- The app's own default chat model is Sonnet 5; change it any time in
-  **Settings**. Haiku is the cheaper Claude option, and Luna is the cheaper
-  option in the GPT-5.6 family.
+- The app's default chat model is GPT-5.6 Luna. Direct Anthropic connections
+  keep Claude Sonnet 5 as their default. Change models any time in **Settings**;
+  Haiku is the cheaper Claude option.
 - Automated PR recaps from the GitHub Action run separately from the
   interactive app and have their own model and cost knobs — see
   [PR Visual Recap](/docs/pr-visual-recap) for `VISUAL_RECAP_MODEL`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.118.1",
+  "version": "0.119.1",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/src/a2a/activity.ts

@@ -0,0 +1,371 @@
+import { sanitizeToolErrorText } from "../agent/tool-error-redaction.js";
+import type { AgentChatEvent } from "../agent/types.js";
+import type { DataPart, Part } from "./types.js";
+
+export const A2A_AGENT_ACTIVITY_KIND = "agent-native/agent-activity";
+export const A2A_AGENT_ACTIVITY_VERSION = 1;
+export const MAX_A2A_ACTIVITY_REASONING_CHARS = 32_768;
+export const MAX_A2A_ACTIVITY_RESPONSE_CHARS = 32_768;
+export const MAX_A2A_ACTIVITY_TOTAL_CHARS = 98_304;
+export const MAX_A2A_ACTIVITY_REASONING_SEGMENTS = 128;
+export const MAX_A2A_ACTIVITY_TOOL_CALLS = 64;
+export const MAX_A2A_ACTIVITY_TOOL_NAME_CHARS = 96;
+export const MAX_A2A_ACTIVITY_TOOL_ID_CHARS = 128;
+
+export type A2AAgentActivityPhase =
+  | "reasoning"
+  | "tool"
+  | "responding"
+  | "complete"
+  | "error";
+
+export type A2AAgentActivityToolStatus = "running" | "completed" | "failed";
+
+export interface A2AAgentActivityToolCall {
+  name: string;
+  id?: string;
+  status: A2AAgentActivityToolStatus;
+}
+
+export interface A2AAgentActivitySnapshot extends Record<string, unknown> {
+  kind: typeof A2A_AGENT_ACTIVITY_KIND;
+  version: typeof A2A_AGENT_ACTIVITY_VERSION;
+  sequence: number;
+  startedAt: number;
+  updatedAt: number;
+  durationMs: number;
+  activePhase: A2AAgentActivityPhase;
+  reasoning: string[];
+  toolCalls: A2AAgentActivityToolCall[];
+  responseText?: string;
+}
+
+export interface A2AAgentActivityState {
+  sequence: number;
+  startedAt: number;
+  updatedAt: number;
+  activePhase: A2AAgentActivityPhase;
+  reasoning: string[];
+  toolCalls: A2AAgentActivityToolCall[];
+  responseText: string;
+}
+
+export function createA2AAgentActivityState(
+  startedAt = Date.now(),
+): A2AAgentActivityState {
+  return {
+    sequence: 0,
+    startedAt,
+    updatedAt: startedAt,
+    activePhase: "reasoning",
+    reasoning: [],
+    toolCalls: [],
+    responseText: "",
+  };
+}
+
+/**
+ * Converts internal loop events into a bounded activity snapshot. It carries
+ * only reasoning text already emitted to the local chat, never tool inputs or
+ * results.
+ */
+export function applyA2AAgentActivityEvent(
+  state: A2AAgentActivityState,
+  event: AgentChatEvent,
+  updatedAt = Date.now(),
+): A2AAgentActivityState {
+  const next = { ...state, updatedAt: normalizeTimestamp(updatedAt) };
+  let changed = false;
+
+  switch (event.type) {
+    case "thinking":
+      next.activePhase = "reasoning";
+      next.reasoning = appendBoundedSegment(
+        next.reasoning,
+        event.text,
+        MAX_A2A_ACTIVITY_REASONING_CHARS,
+        next.toolCalls.length,
+      );
+      changed = true;
+      break;
+    case "tool_start":
+      next.activePhase = "tool";
+      next.responseText = "";
+      next.toolCalls = appendToolCall(next.toolCalls, toolFromEvent(event));
+      changed = true;
+      break;
+    case "tool_done":
+      next.activePhase = "tool";
+      next.toolCalls = settleToolCall(next.toolCalls, toolFromEvent(event));
+      changed = true;
+      break;
+    case "text":
+      next.activePhase = "responding";
+      next.responseText = appendBoundedText(
+        next.responseText,
+        event.text,
+        MAX_A2A_ACTIVITY_RESPONSE_CHARS,
+      );
+      changed = true;
+      break;
+    case "done":
+      next.activePhase = "complete";
+      changed = true;
+      break;
+    case "error":
+      next.activePhase = "error";
+      changed = true;
+      break;
+    case "clear":
+      next.responseText = "";
+      changed = true;
+      break;
+  }
+
+  return changed ? { ...next, sequence: state.sequence + 1 } : state;
+}
+
+export function buildA2AAgentActivitySnapshot(
+  state: A2AAgentActivityState,
+): A2AAgentActivitySnapshot {
+  return {
+    kind: A2A_AGENT_ACTIVITY_KIND,
+    version: A2A_AGENT_ACTIVITY_VERSION,
+    sequence: state.sequence,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    durationMs: Math.max(0, state.updatedAt - state.startedAt),
+    activePhase: state.activePhase,
+    reasoning: state.reasoning,
+    toolCalls: state.toolCalls,
+    ...(state.responseText ? { responseText: state.responseText } : {}),
+  };
+}
+
+export function buildA2AAgentActivityPart(
+  state: A2AAgentActivityState,
+): DataPart {
+  return { type: "data", data: buildA2AAgentActivitySnapshot(state) };
+}
+
+export function parseA2AAgentActivityPart(
+  part: Part | unknown,
+): A2AAgentActivitySnapshot | null {
+  if (!part || typeof part !== "object") return null;
+  const candidate = part as { type?: unknown; data?: unknown };
+  if (candidate.type !== "data" || !isRecord(candidate.data)) return null;
+  const data = candidate.data;
+  if (
+    data.kind !== A2A_AGENT_ACTIVITY_KIND ||
+    data.version !== A2A_AGENT_ACTIVITY_VERSION ||
+    !isSafeInteger(data.sequence) ||
+    !isSafeInteger(data.startedAt) ||
+    !isSafeInteger(data.updatedAt) ||
+    !isSafeInteger(data.durationMs) ||
+    !isPhase(data.activePhase) ||
+    data.updatedAt < data.startedAt ||
+    data.durationMs !== data.updatedAt - data.startedAt ||
+    !isSafeReasoning(data.reasoning) ||
+    !isSafeToolCalls(data.toolCalls) ||
+    (data.responseText !== undefined &&
+      !isSafeText(data.responseText, MAX_A2A_ACTIVITY_RESPONSE_CHARS)) ||
+    activityCharacterCount(data) > MAX_A2A_ACTIVITY_TOTAL_CHARS
+  ) {
+    return null;
+  }
+
+  return data as unknown as A2AAgentActivitySnapshot;
+}
+
+function toolFromEvent(
+  event: Extract<AgentChatEvent, { type: "tool_start" | "tool_done" }>,
+): A2AAgentActivityToolCall {
+  const id = sanitizeToolId(event.id);
+  return {
+    name: sanitizeToolName(event.tool),
+    ...(id ? { id } : {}),
+    status:
+      event.type === "tool_start"
+        ? "running"
+        : event.isError
+          ? "failed"
+          : "completed",
+  };
+}
+
+function appendBoundedText(
+  current: string,
+  addition: string,
+  maxChars: number,
+) {
+  return sanitizeText(`${current}${addition}`, maxChars);
+}
+
+function appendBoundedSegment(
+  current: string[],
+  addition: string,
+  maxChars: number,
+  precedingToolCount: number,
+): string[] {
+  const used = current.reduce((total, text) => total + text.length, 0);
+  if (
+    used >= maxChars ||
+    current.length >= MAX_A2A_ACTIVITY_REASONING_SEGMENTS
+  ) {
+    return current;
+  }
+  const text = sanitizeText(addition, maxChars - used);
+  if (!text) return current;
+  const next = [...current];
+  while (
+    next.length < precedingToolCount &&
+    next.length < MAX_A2A_ACTIVITY_REASONING_SEGMENTS
+  ) {
+    next.push("");
+  }
+  if (next.length === precedingToolCount) {
+    return [...next, text];
+  }
+  next[precedingToolCount] = `${next[precedingToolCount] ?? ""}${text}`;
+  return next;
+}
+
+function appendToolCall(
+  current: A2AAgentActivityToolCall[],
+  tool: A2AAgentActivityToolCall,
+): A2AAgentActivityToolCall[] {
+  return current.length < MAX_A2A_ACTIVITY_TOOL_CALLS
+    ? [...current, tool]
+    : current;
+}
+
+function settleToolCall(
+  current: A2AAgentActivityToolCall[],
+  tool: A2AAgentActivityToolCall,
+): A2AAgentActivityToolCall[] {
+  for (let index = current.length - 1; index >= 0; index -= 1) {
+    const existing = current[index];
+    if (
+      (tool.id && tool.id === existing.id) ||
+      (!tool.id && tool.name === existing.name)
+    ) {
+      return current.map((value, itemIndex) =>
+        itemIndex === index ? tool : value,
+      );
+    }
+  }
+  return appendToolCall(current, tool);
+}
+
+function sanitizeText(value: string, maxChars: number): string {
+  return sanitizeToolErrorText(value)
+    .replace(/\r\n?/g, "\n")
+    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "")
+    .slice(0, maxChars);
+}
+
+function sanitizeToolName(value: string): string {
+  return sanitizeText(value, MAX_A2A_ACTIVITY_TOOL_NAME_CHARS) || "tool";
+}
+
+function sanitizeToolId(value: string | undefined): string | undefined {
+  const sanitized = value
+    ? sanitizeText(value, MAX_A2A_ACTIVITY_TOOL_ID_CHARS)
+    : "";
+  return sanitized || undefined;
+}
+
+function normalizeTimestamp(value: number): number {
+  return isSafeInteger(value) ? value : Date.now();
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isSafeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+function isPhase(value: unknown): value is A2AAgentActivityPhase {
+  return ["reasoning", "tool", "responding", "complete", "error"].includes(
+    value as string,
+  );
+}
+
+function isSafeReasoning(value: unknown): value is string[] {
+  return (
+    Array.isArray(value) &&
+    value.length <= MAX_A2A_ACTIVITY_REASONING_SEGMENTS &&
+    value.reduce(
+      (total, text) =>
+        total + (typeof text === "string" ? text.length : Infinity),
+      0,
+    ) <= MAX_A2A_ACTIVITY_REASONING_CHARS &&
+    value.every((text) => isSafeText(text, MAX_A2A_ACTIVITY_REASONING_CHARS))
+  );
+}
+
+function isSafeToolCalls(value: unknown): value is A2AAgentActivityToolCall[] {
+  return (
+    Array.isArray(value) &&
+    value.length <= MAX_A2A_ACTIVITY_TOOL_CALLS &&
+    value.every(isSafeToolCall)
+  );
+}
+
+function isSafeToolCall(value: unknown): value is A2AAgentActivityToolCall {
+  if (!isRecord(value) || !isSafeToolName(value.name)) return false;
+  return (
+    (value.id === undefined || isSafeToolId(value.id)) &&
+    (value.status === "running" ||
+      value.status === "completed" ||
+      value.status === "failed")
+  );
+}
+
+function isSafeText(value: unknown, maxChars: number): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= maxChars &&
+    value === sanitizeText(value, maxChars)
+  );
+}
+
+function isSafeToolName(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= MAX_A2A_ACTIVITY_TOOL_NAME_CHARS &&
+    value === sanitizeToolName(value)
+  );
+}
+
+function isSafeToolId(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= MAX_A2A_ACTIVITY_TOOL_ID_CHARS &&
+    value === sanitizeToolId(value)
+  );
+}
+
+function activityCharacterCount(data: Record<string, unknown>): number {
+  const reasoning = Array.isArray(data.reasoning)
+    ? data.reasoning.reduce(
+        (total, text) => total + (typeof text === "string" ? text.length : 0),
+        0,
+      )
+    : 0;
+  const response =
+    typeof data.responseText === "string" ? data.responseText.length : 0;
+  const tools = Array.isArray(data.toolCalls)
+    ? data.toolCalls.reduce((total, tool) => {
+        if (!isRecord(tool)) return total;
+        return (
+          total +
+          (typeof tool.name === "string" ? tool.name.length : 0) +
+          (typeof tool.id === "string" ? tool.id.length : 0)
+        );
+      }, 0)
+    : 0;
+  return reasoning + response + tools;
+}

package/src/a2a/client.ts

@@ -647,6 +647,8 @@ export async function callAgent(
   text: string,
   opts?: {
     apiKey?: string;
+    /** Additional transport metadata. Receivers must not use it as identity. */
+    metadata?: Record<string, unknown>;
     contextId?: string;
     userEmail?: string;
     orgDomain?: string;
@@ -694,7 +696,7 @@ export async function callAgent(
     onUpdate?: (task: Task) => void;
   },
 ): Promise<string> {
-  const metadata: Record<string, unknown> = {};
+  const metadata: Record<string, unknown> = { ...opts?.metadata };
   if (opts?.userEmail) metadata.userEmail = opts.userEmail;
   if (opts?.orgDomain) metadata.orgDomain = opts.orgDomain;
   if (opts?.requestOrigin) metadata.requestOrigin = opts.requestOrigin;

package/src/a2a/index.ts

@@ -2,6 +2,22 @@
 export { mountA2A, verifyA2AToken } from "./server.js";
 export type { A2ATokenPayload } from "./server.js";
 export { generateAgentCard } from "./agent-card.js";
+export {
+  A2A_AGENT_ACTIVITY_KIND,
+  A2A_AGENT_ACTIVITY_VERSION,
+  MAX_A2A_ACTIVITY_REASONING_CHARS,
+  MAX_A2A_ACTIVITY_REASONING_SEGMENTS,
+  MAX_A2A_ACTIVITY_RESPONSE_CHARS,
+  MAX_A2A_ACTIVITY_TOOL_CALLS,
+  MAX_A2A_ACTIVITY_TOTAL_CHARS,
+  MAX_A2A_ACTIVITY_TOOL_ID_CHARS,
+  MAX_A2A_ACTIVITY_TOOL_NAME_CHARS,
+  applyA2AAgentActivityEvent,
+  buildA2AAgentActivityPart,
+  buildA2AAgentActivitySnapshot,
+  createA2AAgentActivityState,
+  parseA2AAgentActivityPart,
+} from "./activity.js";
 
 // Client
 export { A2AClient, callAction, callAgent, signA2AToken } from "./client.js";
@@ -38,6 +54,11 @@ export type {
   A2ACorrelationMetadata,
   A2AReadOnlyActionInvocation,
   A2AReadOnlyActionResult,
+  A2AAgentActivityPhase,
+  A2AAgentActivitySnapshot,
+  A2AAgentActivityState,
+  A2AAgentActivityToolCall,
+  A2AAgentActivityToolStatus,
 } from "./types.js";
 export type {
   AgentInvocationErrorCode,

package/src/a2a/types.ts

@@ -1,6 +1,14 @@
 // A2A Protocol types (spec v0.3) + framework config types
 import type { PublicAgentActionConfig } from "../action.js";
 
+export type {
+  A2AAgentActivityPhase,
+  A2AAgentActivitySnapshot,
+  A2AAgentActivityState,
+  A2AAgentActivityToolCall,
+  A2AAgentActivityToolStatus,
+} from "./activity.js";
+
 // --- Parts (content atoms) ---
 
 export interface TextPart {

package/src/agent/model-config.ts

@@ -242,11 +242,11 @@ function openRouterModelId(provider: string, model: string): string {
   return `${provider}/${model}`;
 }
 
-const FRAMEWORK_DEFAULT_OPENAI_MODEL = "gpt-5.6-sol";
-const FRAMEWORK_DEFAULT_BUILDER_MODEL = ANTHROPIC_DEFAULT_MODEL_ID;
+const FRAMEWORK_DEFAULT_OPENAI_MODEL = "gpt-5.6-luna";
 const FRAMEWORK_DEFAULT_BUILDER_OPENAI_MODEL = builderGatewayModelId(
   FRAMEWORK_DEFAULT_OPENAI_MODEL,
 );
+const FRAMEWORK_DEFAULT_BUILDER_MODEL = FRAMEWORK_DEFAULT_BUILDER_OPENAI_MODEL;
 const FRAMEWORK_DEFAULT_OPENROUTER_MODEL = openRouterModelId(
   "openai",
   FRAMEWORK_DEFAULT_OPENAI_MODEL,
@@ -257,14 +257,14 @@ export const AGENT_MODEL_CONFIG = {
     defaultModel: FRAMEWORK_DEFAULT_BUILDER_MODEL,
     supportedModels: [
       "auto",
-      "claude-opus-4-8",
-      CLAUDE_SONNET_MODEL_ID,
-      "claude-haiku-4-5",
       FRAMEWORK_DEFAULT_BUILDER_OPENAI_MODEL,
       "gpt-5-6-terra",
-      "gpt-5-6-luna",
-      "gemini-3-1-pro",
+      "gpt-5-6-sol",
+      "claude-haiku-4-5",
+      CLAUDE_SONNET_MODEL_ID,
+      "claude-opus-4-8",
       "gemini-3-5-flash",
+      "gemini-3-1-pro",
       // Flash-Lite is a transcription-only public id. Advertising it as an
       // agent-chat option routes through a Vertex preview model whose
       // availability can lapse while the id remains accepted, leaving chat
@@ -274,39 +274,35 @@ export const AGENT_MODEL_CONFIG = {
   anthropic: {
     defaultModel: ANTHROPIC_DEFAULT_MODEL_ID,
     supportedModels: [
-      "claude-fable-5",
-      "claude-opus-4-8",
-      CLAUDE_SONNET_MODEL_ID,
       "claude-haiku-4-5-20251001",
+      CLAUDE_SONNET_MODEL_ID,
+      "claude-opus-4-8",
+      "claude-fable-5",
     ],
   },
   aiSdk: {
     anthropic: {
       defaultModel: ANTHROPIC_DEFAULT_MODEL_ID,
       supportedModels: [
-        "claude-fable-5",
-        "claude-opus-4-8",
-        CLAUDE_SONNET_MODEL_ID,
         "claude-haiku-4-5-20251001",
+        CLAUDE_SONNET_MODEL_ID,
+        "claude-opus-4-8",
+        "claude-fable-5",
       ],
     },
     openai: {
       defaultModel: FRAMEWORK_DEFAULT_OPENAI_MODEL,
-      supportedModels: [
-        FRAMEWORK_DEFAULT_OPENAI_MODEL,
-        "gpt-5.6-terra",
-        "gpt-5.6-luna",
-      ],
+      supportedModels: ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"],
     },
     openrouter: {
       defaultModel: FRAMEWORK_DEFAULT_OPENROUTER_MODEL,
       supportedModels: [
-        "anthropic/claude-fable-5",
-        "anthropic/claude-opus-4.8",
-        OPENROUTER_CLAUDE_SONNET_MODEL_ID,
-        FRAMEWORK_DEFAULT_OPENROUTER_MODEL,
-        "openai/gpt-5.6-terra",
         "openai/gpt-5.6-luna",
+        "openai/gpt-5.6-terra",
+        "openai/gpt-5.6-sol",
+        OPENROUTER_CLAUDE_SONNET_MODEL_ID,
+        "anthropic/claude-opus-4.8",
+        "anthropic/claude-fable-5",
         // Current stable Gemini on OpenRouter (2.5 Flash is GA)
         "google/gemini-2.5-flash",
         "z-ai/glm-5.2",