zidane 5.10.2 → 5.10.4

package/dist/{messages-DdfOKKx_.js → messages-_E1RxSxV.js}

@@ -240,6 +240,40 @@ const EXTRA_COST_RATES = {
 	"arcee:trinity-mini": {
 		input: .045,
 		output: .15
+	},
+	"baseten:zai-org/GLM-5": {
+		input: .95,
+		output: 3.15,
+		cacheRead: .2
+	},
+	"baseten:zai-org/GLM-4.7": {
+		input: .6,
+		output: 2.2,
+		cacheRead: .12
+	},
+	"baseten:moonshotai/Kimi-K2.6": {
+		input: 1,
+		output: 3.9,
+		cacheRead: .2
+	},
+	"baseten:moonshotai/Kimi-K2.5": {
+		input: .6,
+		output: 3,
+		cacheRead: .12
+	},
+	"baseten:deepseek-ai/DeepSeek-V4-Pro": {
+		input: 1.74,
+		output: 3.48,
+		cacheRead: .145
+	},
+	"baseten:nvidia/Nemotron-120B-A12B": {
+		input: .3,
+		output: .75,
+		cacheRead: .06
+	},
+	"baseten:openai/gpt-oss-120b": {
+		input: .1,
+		output: .5
 	}
 };
 /**
@@ -649,6 +683,7 @@ async function consumeSSE(response, callbacks, signal) {
 		output: 0
 	};
 	const tcMap = /* @__PURE__ */ new Map();
+	const idNonce = Math.random().toString(36).slice(2, 10);
 	const reasoningMap = /* @__PURE__ */ new Map();
 	let sawReasoningDetails = false;
 	try {
@@ -726,7 +761,7 @@ async function consumeSSE(response, callbacks, signal) {
 						existing.name ||= tc.function?.name ?? "";
 						if (tc.function?.arguments) existing.args += tc.function.arguments;
 					} else tcMap.set(tc.index, {
-						id: tc.id || `call_${tc.index}`,
+						id: tc.id || `call_${tc.index}_${idNonce}`,
 						name: tc.function?.name || "",
 						args: tc.function?.arguments || ""
 					});
@@ -1334,8 +1369,14 @@ function openaiCompat(params) {
 			const shouldCache = cacheBreakpointsEnabled && options.cache !== false;
 			if (shouldCache) applyOAICacheBreakpoints(messages, options.system);
 			const maxTokens = options.thinkingBudget ? options.thinkingBudget + options.maxTokens : options.maxTokens;
+			const reasoningBody = params.planReasoningRequest?.({
+				model: modelId,
+				thinking: options.thinking,
+				thinkingBudget: options.thinkingBudget
+			});
 			const body = {
 				...params.extraBodyParams ?? {},
+				...reasoningBody ?? {},
 				model: modelId,
 				messages,
 				max_tokens: maxTokens,
@@ -1699,6 +1740,10 @@ function fromOpenAI(msg) {
 				output: r.content ?? ""
 			});
 		}
+		if (typeof tagged.text === "string" && tagged.text) content.push({
+			type: "text",
+			text: tagged.text
+		});
 		return {
 			role,
 			content
@@ -1810,16 +1855,20 @@ function toOpenAI(msg) {
 	const textBlocks = msg.content.filter((b) => b.type === "text");
 	const imageBlocks = msg.content.filter((b) => b.type === "image");
 	const documentBlocks = msg.content.filter((b) => b.type === "document");
-	if (toolResults.length > 0) return {
-		role: msg.role,
-		content: {
-			_tag: TOOL_RESULTS_TAG,
-			results: toolResults.map((tr) => ({
-				tool_call_id: tr.callId,
-				content: tr.output
-			}))
-		}
-	};
+	if (toolResults.length > 0) {
+		const siblingText = textBlocks.map((b) => b.text).join("\n");
+		return {
+			role: msg.role,
+			content: {
+				_tag: TOOL_RESULTS_TAG,
+				results: toolResults.map((tr) => ({
+					tool_call_id: tr.callId,
+					content: tr.output
+				})),
+				...siblingText ? { text: siblingText } : {}
+			}
+		};
+	}
 	if (toolCalls.length > 0) {
 		const textContent = textBlocks.length > 0 ? textBlocks[0].text : null;
 		return {
@@ -2130,6 +2179,79 @@ function processUserMessage(args) {
 		content: finalContent
 	});
 }
+/**
+* Re-mint tool-call ids that collide with ids already present in the
+* transcript (or with an earlier sibling in the same turn), BEFORE the turn
+* is persisted and its tools dispatched.
+*
+* Why this exists: some providers/serving stacks emit non-globally-unique
+* tool_use ids (per-turn counters like `call_0`, retry-replay duplicates,
+* Kimi-K2.6 on Fireworks). The wire-time pairing pass
+* ({@link ensureToolResultPairing}) can only STRIP such duplicates — which
+* erases the model's tool calls and results from the wire view, stalls
+* progress, and re-accumulates repairs quadratically because the persisted
+* session keeps the corrupted ids. Re-minting at persist time keeps the
+* pairing intact instead: the call, its execution, and its tool_result all
+* carry the fresh id, so the pairing pass has nothing to strip on any later
+* turn.
+*
+* Fresh ids are `${oldId}_r{n}` with `n` bumped until unique — deterministic
+* shape, Anthropic-wire-safe charset (given a safe input id), and visibly
+* traceable back to the original.
+*
+* Alignment contract: `toolCalls` and the `tool_call` blocks inside
+* `content` are two views of the same emission and MUST be in the same
+* order (true for every provider — both are built from one source array).
+* Occurrences are matched positionally per old id so intra-turn duplicates
+* map to distinct fresh ids on both views.
+*
+* Pure: returns the input references unchanged when no id collides.
+*/
+function remintDuplicateToolCallIds(toolCalls, content, priorIds) {
+	const seen = new Set(priorIds);
+	const reminted = [];
+	const finalIdQueues = /* @__PURE__ */ new Map();
+	let changed = false;
+	const outCalls = toolCalls.map((tc) => {
+		let finalId = tc.id;
+		if (seen.has(tc.id)) {
+			let n = 1;
+			while (seen.has(`${tc.id}_r${n}`)) n++;
+			finalId = `${tc.id}_r${n}`;
+			reminted.push({
+				oldId: tc.id,
+				newId: finalId
+			});
+			changed = true;
+		}
+		seen.add(finalId);
+		const queue = finalIdQueues.get(tc.id);
+		if (queue) queue.push(finalId);
+		else finalIdQueues.set(tc.id, [finalId]);
+		return finalId === tc.id ? tc : {
+			...tc,
+			id: finalId
+		};
+	});
+	if (!changed) return {
+		toolCalls,
+		content,
+		reminted
+	};
+	return {
+		toolCalls: outCalls,
+		content: content.map((block) => {
+			if (block.type !== "tool_call") return block;
+			const finalId = finalIdQueues.get(block.id)?.shift();
+			if (finalId === void 0 || finalId === block.id) return block;
+			return {
+				...block,
+				id: finalId
+			};
+		}),
+		reminted
+	};
+}
 function syntheticResultBlock(callId) {
 	return {
 		type: "tool_result",
@@ -2324,6 +2446,6 @@ function autoDetectAndConvert(msg) {
 	return fromAnthropic(msg);
 }
 //#endregion
-export { replaceDynamicSection as A, fillEstimatedCost as C, hasSystemPromptBoundary as D, appendStaticSection as E, joinSystemPrompt as O, sanitizeToolSpecs as S, appendDynamicSection as T, mapOAIFinishReason as _, detectTurnInterruption as a, userMessage as b, filterUnresolvedToolUses as c, toAnthropic as d, toOpenAI as f, classifyOpenAICompatError as g, assistantMessage as h, autoDetectAndConvert as i, splitSystemPrompt as j, renderSystemForWire as k, fromAnthropic as l, OpenAICompatHttpError as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureEndsWithUserMessage as o, toWireMessages as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureToolResultPairing as s, ORPHANED_TOOL_RESULT_MARKER as t, fromOpenAI as u, openaiCompat as v, SYSTEM_PROMPT_BOUNDARY as w, sanitizeToolSchema as x, toolResultsMessage as y };
+export { renderSystemForWire as A, sanitizeToolSpecs as C, appendStaticSection as D, appendDynamicSection as E, splitSystemPrompt as M, hasSystemPromptBoundary as O, sanitizeToolSchema as S, SYSTEM_PROMPT_BOUNDARY as T, classifyOpenAICompatError as _, detectTurnInterruption as a, toolResultsMessage as b, filterUnresolvedToolUses as c, remintDuplicateToolCallIds as d, toAnthropic as f, assistantMessage as g, OpenAICompatHttpError as h, autoDetectAndConvert as i, replaceDynamicSection as j, joinSystemPrompt as k, fromAnthropic as l, toWireMessages as m, SYNTHETIC_TOOL_RESULT_PLACEHOLDER as n, ensureEndsWithUserMessage as o, toOpenAI as p, TOOL_USE_INTERRUPTED_MARKER as r, ensureToolResultPairing as s, ORPHANED_TOOL_RESULT_MARKER as t, fromOpenAI as u, mapOAIFinishReason as v, fillEstimatedCost as w, userMessage as x, openaiCompat as y };
 
-//# sourceMappingURL=messages-DdfOKKx_.js.map
+//# sourceMappingURL=messages-_E1RxSxV.js.map