nolo-cli 0.1.30 → 0.1.31

package/ai/agent/publicAgentCatalog.ts

@@ -0,0 +1,359 @@
+import type { Agent } from "../../app/types";
+import { getModelPricing } from "../llm/getPricing";
+import { getModelConfig } from "../llm/providers";
+import { supportsImageGeneration } from "../agent/utils/imageOutput";
+import { buildSortMeta, sortAgents, toTimeMs, type MAgent } from "../agent/utils/sortUtils";
+import {
+  getPublicAgentId,
+  getPublicAgentIdentifiers,
+} from "../agent/publicAgentIdentity";
+import { getRecordTimestamp } from "../../database/tombstones";
+import {
+  normalizeBuiltinPublicAgentRecord,
+  shouldHideBuiltinAgentFromPublicPlaza,
+} from "../../core/builtinAgents";
+
+export type PublicAgentSortBy =
+  | "recommended"
+  | "newest"
+  | "popular"
+  | "rating"
+  | "outputPriceAsc"
+  | "outputPriceDesc"
+  | "favorite";
+
+export interface PublicAgentFilterOptions {
+  searchName?: string;
+  userId?: string;
+  imageOutputOnly?: boolean;
+  toolName?: string;
+}
+
+export interface PublicAgentListOptions {
+  limit?: number;
+  sortBy?: PublicAgentSortBy;
+}
+
+export type PublicAgentQueryOptions = PublicAgentFilterOptions & PublicAgentListOptions;
+
+type PublicAgentRecord = Partial<Agent> & Record<string, any>;
+
+const GPT_IMAGE_TOOL_NAMES = new Set([
+  "openAIGptImage",
+  "openAIGptImageGenerate",
+  "openAIGptImageEdit",
+]);
+
+const shouldUsePlatformPricing = (agent: PublicAgentRecord): boolean => {
+  const provider = typeof agent.provider === "string" ? agent.provider.trim() : "";
+  if (!provider) return false;
+  if (provider === "custom") return false;
+  const customProviderUrl =
+    typeof agent.customProviderUrl === "string" ? agent.customProviderUrl.trim() : "";
+  if (customProviderUrl) return false;
+  const apiSource = typeof agent.apiSource === "string" ? agent.apiSource.trim() : "";
+  return !apiSource || apiSource === "platform";
+};
+
+const shouldApplyPlatformPriceFloor = (agent: PublicAgentRecord): boolean => {
+  const provider = typeof agent.provider === "string" ? agent.provider.trim() : "";
+  if (!provider || provider === "custom") return false;
+  const apiSource = typeof agent.apiSource === "string" ? agent.apiSource.trim() : "";
+  const customProviderUrl =
+    typeof agent.customProviderUrl === "string" ? agent.customProviderUrl.trim() : "";
+  return apiSource === "custom" || !!customProviderUrl;
+};
+
+const maxNumber = (value: unknown, floor: number) =>
+  typeof value === "number" && Number.isFinite(value) ? Math.max(value, floor) : floor;
+
+export function normalizePublicAgentPlatformPricing<T extends PublicAgentRecord>(
+  agent: T
+): T {
+  const provider = typeof agent.provider === "string" ? agent.provider.trim() : "";
+  const model = typeof agent.model === "string" ? agent.model.trim() : "";
+  if (!provider || !model) return agent;
+
+  const usePlatformPricing = shouldUsePlatformPricing(agent);
+  const applyPlatformPriceFloor = shouldApplyPlatformPriceFloor(agent);
+  if (!usePlatformPricing && !applyPlatformPriceFloor) return agent;
+
+  let next: PublicAgentRecord = agent;
+  try {
+    const pricing = getModelPricing(provider, model);
+    const modelConfig = getModelConfig(provider as any, model);
+    if (pricing && usePlatformPricing) {
+      next = {
+        ...next,
+        inputPrice: pricing.inputPrice,
+        outputPrice: pricing.outputPrice,
+        hasVision: agent.hasVision ?? !!modelConfig.hasVision,
+      };
+    } else if (pricing && applyPlatformPriceFloor) {
+      next = {
+        ...next,
+        inputPrice: maxNumber(agent.inputPrice, pricing.inputPrice),
+        outputPrice: maxNumber(agent.outputPrice, pricing.outputPrice),
+      };
+    }
+  } catch {
+    // Keep the persisted record when the provider/model is not in the platform registry.
+  }
+
+  const tools = Array.isArray(agent.tools) ? agent.tools : [];
+  const usesOpenAIImageTool = tools.some(
+    (tool) => typeof tool === "string" && GPT_IMAGE_TOOL_NAMES.has(tool)
+  );
+  const imageModel =
+    typeof agent.imageModel === "string" && agent.imageModel.trim()
+      ? agent.imageModel.trim()
+      : usesOpenAIImageTool
+        ? "gpt-image-2"
+        : "";
+
+  if (usePlatformPricing && provider === "openai" && imageModel === "gpt-image-2") {
+    next = {
+      ...next,
+      imageModel,
+      imageConfig: {
+        ...((agent.imageConfig && typeof agent.imageConfig === "object"
+          ? agent.imageConfig
+          : {}) as Record<string, unknown>),
+        enabled: true,
+      },
+      hasImageOutput: agent.hasImageOutput ?? true,
+    };
+  }
+
+  return next as T;
+}
+
+export function preparePublicAgentCatalogRecords(agents: Agent[]): Agent[] {
+  return agents
+    .map((agent) => normalizeBuiltinPublicAgentRecord(agent))
+    .map((agent) => normalizePublicAgentPlatformPricing(agent))
+    .filter((agent) => !shouldHideBuiltinAgentFromPublicPlaza(agent));
+}
+
+export function shouldPruneStalePublicAgentCache({
+  searchName,
+}: {
+  searchName?: string;
+}) {
+  return !searchName;
+}
+
+export function dedupeRemotePublicAgents(remoteAgents: Agent[]): Agent[] {
+  const remoteMap = new Map<string, Agent>();
+  for (const agent of remoteAgents) {
+    const logicalId = getPublicAgentId(agent) ?? String(agent.id ?? "");
+    if (!logicalId) continue;
+    const existing = remoteMap.get(logicalId);
+    if (!existing || getRecordTimestamp(agent) > getRecordTimestamp(existing)) {
+      remoteMap.set(logicalId, agent);
+    }
+  }
+  return Array.from(remoteMap.values());
+}
+
+export function maskRemoteAgentsByLocalTombstones(
+  remoteAgents: Agent[],
+  tombstones: Array<Record<string, any>>
+): Agent[] {
+  const tombstoneMap = new Map<string, Record<string, any>>();
+  for (const tombstone of tombstones) {
+    for (const identifier of getPublicAgentIdentifiers(tombstone)) {
+      const existing = tombstoneMap.get(identifier);
+      if (!existing || getRecordTimestamp(tombstone) > getRecordTimestamp(existing)) {
+        tombstoneMap.set(identifier, tombstone);
+      }
+    }
+  }
+
+  return remoteAgents.filter((agent) => {
+    const matchingTombstones = getPublicAgentIdentifiers(agent)
+      .map((identifier) => tombstoneMap.get(identifier))
+      .filter(Boolean) as Array<Record<string, any>>;
+    if (matchingTombstones.length === 0) return true;
+    const newestLocalTombstone = matchingTombstones.reduce((latest, current) =>
+      getRecordTimestamp(current) > getRecordTimestamp(latest) ? current : latest
+    );
+    return getRecordTimestamp(agent) > getRecordTimestamp(newestLocalTombstone);
+  });
+}
+
+export function mergePublicAgentSources(localData: Agent[], remoteData: Agent[]) {
+  const remoteById = new Map<string, Agent>();
+  for (const remote of remoteData) {
+    const logicalId = getPublicAgentId(remote);
+    if (logicalId) {
+      remoteById.set(logicalId, remote);
+    }
+  }
+
+  const merged: MAgent[] = [];
+  const toDeleteIds: string[] = [];
+
+  for (const local of localData) {
+    const logicalId = getPublicAgentId(local) ?? String(local.id ?? "");
+    if (!logicalId) continue;
+    const remote = remoteById.get(logicalId);
+
+    if (remote) {
+      const localTimestamp = getRecordTimestamp(local);
+      const remoteTimestamp = getRecordTimestamp(remote);
+      const newest =
+        remoteTimestamp >= localTimestamp
+          ? { ...(local as any), ...(remote as any) }
+          : { ...(remote as any), ...(local as any) };
+      merged.push({
+        ...newest,
+        __sort: buildSortMeta(local, remote),
+      });
+      continue;
+    }
+
+    toDeleteIds.push(logicalId);
+    merged.push({
+      ...(local as any),
+      __sort: buildSortMeta(local, undefined),
+    });
+  }
+
+  for (const remote of remoteData) {
+    const logicalId = getPublicAgentId(remote);
+    if (!logicalId) continue;
+    const exists = merged.some((agent) => getPublicAgentId(agent) === logicalId);
+    if (!exists) {
+      merged.push({ ...(remote as any), __sort: buildSortMeta(undefined, remote) });
+    }
+  }
+
+  return { merged, toDeleteIds };
+}
+
+export function planStalePublicAgentPrunes({
+  localAgents,
+  toDeleteIds,
+  currentUserId,
+  nowMs = Date.now(),
+}: {
+  localAgents: Agent[];
+  toDeleteIds: string[];
+  currentUserId?: string | null;
+  nowMs?: number;
+}) {
+  return toDeleteIds.filter((id) => {
+    const localItem = localAgents.find((agent) => getPublicAgentId(agent) === id) as
+      | PublicAgentRecord
+      | undefined;
+
+    if (currentUserId && localItem?.userId === currentUserId) return false;
+
+    const isRecentlyCreated = nowMs - toTimeMs(localItem?.createdAt) < 5 * 60 * 1000;
+    if (isRecentlyCreated) return false;
+
+    return localItem?.meta?.origin !== "local";
+  });
+}
+
+export function planPublicAgentCatalogView({
+  localAgents,
+  remoteAgents,
+  hasAuthoritativeRemoteResult,
+  currentUserId,
+  options = {},
+}: {
+  localAgents: Agent[];
+  remoteAgents: Agent[];
+  hasAuthoritativeRemoteResult: boolean;
+  currentUserId?: string | null;
+  options?: PublicAgentQueryOptions;
+}) {
+  const localFallbackAgents = buildPublicAgentCatalogList({
+    ...options,
+    agents: localAgents,
+  });
+  const { merged, toDeleteIds } = mergePublicAgentSources(localAgents, remoteAgents);
+  const staleIdsToHide = hasAuthoritativeRemoteResult ? toDeleteIds : [];
+  const staleIdsToHideSet = new Set(staleIdsToHide);
+  const visibleAgents = buildPublicAgentCatalogList({
+    ...options,
+    agents: (merged as Agent[]).filter(
+      (agent) => !staleIdsToHideSet.has(getPublicAgentId(agent) ?? "")
+    ),
+  });
+  const pruneIds = planStalePublicAgentPrunes({
+    localAgents,
+    toDeleteIds,
+    currentUserId,
+  });
+
+  return {
+    visibleAgents,
+    localFallbackAgents,
+    staleIdsToHide,
+    pruneIds,
+  };
+}
+
+export function filterPublicAgentRecords(
+  agents: Agent[],
+  {
+    searchName,
+    userId,
+    imageOutputOnly = false,
+    toolName,
+  }: PublicAgentFilterOptions = {}
+): Agent[] {
+  let results = [...agents];
+
+  if (searchName) {
+    const kw = searchName.toLowerCase();
+    results = results.filter((agent) => {
+      const nameMatch = agent.name?.toLowerCase().includes(kw);
+      const introMatch = agent.introduction?.toLowerCase().includes(kw);
+      const tagMatch = agent.tags?.some((tag) => tag.toLowerCase().includes(kw));
+      return nameMatch || introMatch || tagMatch;
+    });
+  }
+
+  if (userId) {
+    results = results.filter((agent) => agent.userId === userId);
+  }
+
+  if (imageOutputOnly) {
+    results = results.filter((agent) => supportsImageGeneration(agent));
+  }
+
+  if (toolName) {
+    const kw = toolName.toLowerCase();
+    results = results.filter((agent) =>
+      agent.tools?.some((tool) => tool.toLowerCase().includes(kw))
+    );
+  }
+
+  return results;
+}
+
+export function buildPublicAgentCatalogList({
+  agents,
+  sortBy = "recommended",
+  limit,
+  searchName,
+  userId,
+  imageOutputOnly = false,
+  toolName,
+}: {
+  agents: Agent[];
+} & PublicAgentFilterOptions &
+  PublicAgentListOptions) {
+  const filtered = filterPublicAgentRecords(preparePublicAgentCatalogRecords(agents), {
+    searchName,
+    userId,
+    imageOutputOnly,
+    toolName,
+  });
+  const sorted = sortAgents(filtered, sortBy);
+  return typeof limit === "number" ? sorted.slice(0, limit) : sorted;
+}

package/ai/agent/publicAgentIdentity.ts

@@ -0,0 +1,76 @@
+import type { Agent } from "../../app/types";
+
+const PUBLIC_AGENT_PREFIX = "agent-pub-";
+const PUBLIC_CYBOT_PREFIX = "cybot-pub-";
+
+type PublicAgentRecord = Partial<Agent> & Record<string, any>;
+
+const toNonEmptyString = (value: unknown): string | undefined => {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized || undefined;
+};
+
+const parsePublicDbKey = (value: unknown) => {
+  const text = toNonEmptyString(value);
+  if (!text) return null;
+  if (text.startsWith(PUBLIC_AGENT_PREFIX)) {
+    return {
+      dbKey: text,
+      id: text.slice(PUBLIC_AGENT_PREFIX.length),
+      type: "agent",
+    } as const;
+  }
+  if (text.startsWith(PUBLIC_CYBOT_PREFIX)) {
+    return {
+      dbKey: text,
+      id: text.slice(PUBLIC_CYBOT_PREFIX.length),
+      type: "cybot",
+    } as const;
+  }
+  return null;
+};
+
+const buildPublicDbKey = (type: unknown, id: string): string => {
+  if (type === "agent") return `${PUBLIC_AGENT_PREFIX}${id}`;
+  if (type === "cybot") return `${PUBLIC_CYBOT_PREFIX}${id}`;
+  return "";
+};
+
+export function getPublicAgentId(agent?: PublicAgentRecord | null): string | undefined {
+  const directId = toNonEmptyString(agent?.id);
+  if (directId) {
+    return parsePublicDbKey(directId)?.id ?? directId;
+  }
+  return parsePublicDbKey(agent?.dbKey)?.id;
+}
+
+export function getPublicAgentDbKey(agent?: PublicAgentRecord | null): string | undefined {
+  const directDbKey = toNonEmptyString(agent?.dbKey);
+  if (directDbKey) return directDbKey;
+
+  const idAsDbKey = parsePublicDbKey(agent?.id)?.dbKey;
+  if (idAsDbKey) return idAsDbKey;
+
+  const id = getPublicAgentId(agent);
+  if (!id) return undefined;
+  return buildPublicDbKey(agent?.type, id) || undefined;
+}
+
+export function getPublicAgentIdentifiers(agent?: PublicAgentRecord | null): string[] {
+  const identifiers = [getPublicAgentDbKey(agent), getPublicAgentId(agent)].filter(Boolean);
+  return Array.from(new Set(identifiers as string[]));
+}
+
+export function matchesPublicAgentIdentifiers(
+  agent: PublicAgentRecord | null | undefined,
+  identifiers: Set<string>
+): boolean {
+  return getPublicAgentIdentifiers(agent).some((identifier) => identifiers.has(identifier));
+}
+
+export function getPublicAgentPruneDbKey(
+  agent?: PublicAgentRecord | null
+): string | undefined {
+  return getPublicAgentDbKey(agent) ?? getPublicAgentId(agent);
+}

package/ai/agent/server/fetchPublicAgents.ts

@@ -1,25 +1,18 @@
-import serverDb from "../../../database/server/db";
+import { getServerAuthorityStore } from "../../../database/server/db";
 import { pubAgentKeys } from "../../../database/keys";
 import { Agent } from "../../../app/types";
+import {
+  filterPublicAgentRecords,
+  preparePublicAgentCatalogRecords,
+  type PublicAgentFilterOptions,
+  type PublicAgentListOptions,
+} from "../../agent/publicAgentCatalog";
 import { sortAgents } from "../../agent/utils/sortUtils";
-import { supportsImageGeneration } from "../../agent/utils/imageOutput";
 import { isTombstoneRecord } from "../../../database/tombstones";
 
-export interface FetchPublicAgentsOptions {
-  limit?: number;
-  sortBy?:
-  | "recommended"
-  | "newest"
-  | "popular"
-  | "rating"
-  | "outputPriceAsc"
-  | "outputPriceDesc"
-  | "favorite"; // 新增：按收藏排序
-  searchName?: string;
-  userId?: string;
-  imageOutputOnly?: boolean;
-  /** Filter agents that include this tool in their tools array */
-  toolName?: string;
+export interface FetchPublicAgentsOptions
+  extends PublicAgentFilterOptions,
+    PublicAgentListOptions {
   /** Return list-card metadata only. Full agent config is still available by key. */
   summary?: boolean;
 }
@@ -30,15 +23,16 @@ export interface FetchPublicAgentsResult {
   hasMore: boolean;
 }
 
-// 局部 helpers 已移除，使用 shared utils
+const getFetchPublicAgentsStore = () => getServerAuthorityStore();
 
 async function dbList<T>(
+  store: ReturnType<typeof getServerAuthorityStore>,
   gte: string,
   lte: string,
   filter?: (v: T) => boolean
 ): Promise<T[]> {
   const res: T[] = [];
-  for await (const [, value] of serverDb.iterator({ gte, lte })) {
+  for await (const [, value] of store.iterator({ gte, lte })) {
     if (!filter || filter(value as T)) res.push(value as T);
   }
   return res;
@@ -55,6 +49,7 @@ export function invalidatePublicAgentsCache() {
 }
 
 async function getPublicAgents(): Promise<Agent[]> {
+  const store = getFetchPublicAgentsStore();
   const now = Date.now();
   if (cachedPublicAgents && now - cachedPublicAgentsAt < PUBLIC_AGENTS_CACHE_TTL_MS) {
     return cachedPublicAgents;
@@ -65,6 +60,7 @@ async function getPublicAgents(): Promise<Agent[]> {
 
   for (const { start, end } of ranges) {
     const res = await dbList<Agent>(
+      store,
       start,
       end,
       (v) => (v as any).isPublic && !isTombstoneRecord(v)
@@ -145,33 +141,12 @@ export async function fetchPublicAgents(
   // 使用带缓存的获取函数
   const baseList = await getPublicAgents();
 
-  // 注意不要修改缓存引用，后续操作都在拷贝/派生数组上做
-  let list = baseList;
-
-  if (searchName) {
-    const kw = searchName.toLowerCase();
-    list = list.filter((agent) => {
-      const nameMatch = agent.name?.toLowerCase().includes(kw);
-      const introMatch = agent.introduction?.toLowerCase().includes(kw);
-      const tagMatch = agent.tags?.some((tag) => tag.toLowerCase().includes(kw));
-      return nameMatch || introMatch || tagMatch;
-    });
-  }
-
-  if (userId) {
-    list = list.filter((agent) => agent.userId === userId);
-  }
-
-  if (imageOutputOnly) {
-    list = list.filter((agent) => supportsImageGeneration(agent));
-  }
-
-  if (toolName) {
-    const kw = toolName.toLowerCase();
-    list = list.filter((agent) =>
-      agent.tools?.some((t) => t.toLowerCase().includes(kw))
-    );
-  }
+  const list = filterPublicAgentRecords(preparePublicAgentCatalogRecords(baseList), {
+    searchName,
+    userId,
+    imageOutputOnly,
+    toolName,
+  });
 
   // 使用统一的排序逻辑
   const sorted = sortAgents(list, sortBy);

package/ai/agent/serverOrigin.ts

@@ -0,0 +1,7 @@
+export const normalizeServerOrigin = (base: string): string | null => {
+  try {
+    return new URL(base).origin.replace(/\/+$/, "");
+  } catch {
+    return null;
+  }
+};

package/ai/agent/streamAgentChatTurn.ts

@@ -50,6 +50,7 @@ import {
     mergeContexts,
     hasImageInMessages,
     mergeAgentToolsWithRuntime,
+    resolveImageGenerationStreamingState,
     trimMessagesWithSummary,
     validateAccessAndBalance,
 } from "./streamAgentChatTurnUtils";
@@ -65,10 +66,7 @@ import { selectCurrentToken, selectUserId } from "../../auth/authSlice";
 import { persistMessageWithFixedId } from "./persistMessageWithFixedId";
 import { updateTotalUsage } from "../chat/updateTotalUsage";
 import { createSSEParser } from "../chat/parseMultilineSSE";
-import {
-    extractAgentRuntimeServerBase,
-    normalizeServerOrigin,
-} from "./runtimeServerBase";
+import { normalizeServerOrigin } from "./serverOrigin";
 import { getIsDesktopApp } from "../../app/utils/env";
 import { runDesktopAgentRuntimeTurn } from "../../app/utils/desktopAgentRuntimeTurnClient";
 
@@ -148,6 +146,9 @@ const formatMachineAgentRunError = async (response: Response): Promise<string> =
         if (reason === "bound_machine_unavailable") {
             return "绑定的电脑不在线。请确认这台电脑已开机并重新运行连接命令。";
         }
+        if (reason === "bound_machine_owner_mismatch") {
+            return "这台电脑是在线的，但当前账号和 Agent 绑定账号不一致。请重新绑定 Agent，或在绑定账号下重新连接这台电脑。";
+        }
         if (reason === "connector_offline") {
             return "电脑在线，但连接器未连接。请在这台电脑上重新运行连接命令后再试。";
         }
@@ -974,22 +975,17 @@ export const streamAgentChatTurnHandler = async (
                 ? args.serverBase.trim()
                 : null;
         const currentServer = selectCurrentServer(state);
-        const declaredRuntimeServerBase = extractAgentRuntimeServerBase(agentConfig);
-        const requestedServerBase =
-            explicitServerBase ??
-            declaredRuntimeServerBase ??
-            null;
         const normalizedRequestedServerBase =
-            requestedServerBase && normalizeServerOrigin(requestedServerBase);
+            explicitServerBase && normalizeServerOrigin(explicitServerBase);
         const normalizedCurrentServer = normalizeServerOrigin(
             currentServer,
         );
-        const canAutoRouteRemotely =
+        const canProxyToExplicitServerBase =
             !Array.isArray(userInput) &&
             !runtimeOptions?.extraTools?.length &&
             !runtimeOptions?.editingTarget &&
             !runtimeOptions?.imageConfigOverride;
-        if (requestedServerBase && canAutoRouteRemotely) {
+        if (explicitServerBase && canProxyToExplicitServerBase) {
             if (
                 normalizedRequestedServerBase &&
                 normalizedCurrentServer &&
@@ -1048,7 +1044,7 @@ export const streamAgentChatTurnHandler = async (
                     return rejectWithValue(message);
                 };
 
-                const remoteResponse = await fetch(`${requestedServerBase.replace(/\/+$/, "")}/api/agent/run`, {
+                const remoteResponse = await fetch(`${explicitServerBase.replace(/\/+$/, "")}/api/agent/run`, {
                     method: "POST",
                     headers: {
                         "Content-Type": "application/json",
@@ -1245,6 +1241,18 @@ export const streamAgentChatTurnHandler = async (
         const effectiveAgentConfig = dialogMaxTokens
             ? { ...agentConfigForCall, max_tokens: dialogMaxTokens }
             : agentConfigForCall;
+        const initialImageGenerationState = resolveImageGenerationStreamingState(
+            effectiveAgentConfig,
+        );
+        const streamingMessageMetadata = {
+            ...buildParallelMessageMetadata(
+                agentConfigForCall,
+                runtimeOptions,
+            ),
+            ...(initialImageGenerationState
+                ? { imageGenerationState: initialImageGenerationState }
+                : {}),
+        };
 
         const isRespModel = isResponseAPIModel(agentConfigForCall);
 
@@ -1453,10 +1461,7 @@ export const streamAgentChatTurnHandler = async (
                     thunkApi,
                     dialogKey,
                     parentMessageId: currentParentMessageId,
-                    messageMetadata: buildParallelMessageMetadata(
-                        agentConfigForCall,
-                        runtimeOptions,
-                    ),
+                    messageMetadata: streamingMessageMetadata,
                     quickChatPerfStartedAt,
                 });
                 logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-model-request-finished", {
@@ -1752,10 +1757,7 @@ export const streamAgentChatTurnHandler = async (
                 thunkApi,
                 dialogKey,
                 parentMessageId: currentParentMessageId,
-                messageMetadata: buildParallelMessageMetadata(
-                    agentConfigForCall,
-                    runtimeOptions,
-                ),
+                messageMetadata: streamingMessageMetadata,
                 disableToolsForThisRequest,
                 quickChatPerfStartedAt,
             });