Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
Studio: keep legacy function calls and their results on chat import (#17153)
DimitriChrysafis0650065d8bfd
diff --git a/studio/frontend/src/features/chat/utils/chat-import.ts b/studio/frontend/src/features/chat/utils/chat-import.tsindex 105c772619c..5c45a0880ec 100644--- a/studio/frontend/src/features/chat/utils/chat-import.ts+++ b/studio/frontend/src/features/chat/utils/chat-import.ts@@ -105,7 +105,7 @@ export function nativeImportSource(handle: {};}-// role:"tool" results fold into the preceding tool-call part's `result`.+// role:"tool" and role:"function" results fold into a tool-call part's `result`.function oaiContentToParts(raw: unknown): unknown[] {if (!Array.isArray(raw)) {return typeof raw === "string" && raw.trim()@@ -148,32 +148,73 @@ function oaiMessagesToRecords(threadId: string,baseTs: number,): MessageRecord[] {- const toolResults = new Map<string, unknown>();- const pending: Array<{ turn: number; part: { toolCallId: string; result?: unknown } }> = [];+ // Waiting results under id:, name:, bare: (named, no id) and anon keys; cursors keep lookups linear.+ type Stashed = { result: unknown; used?: boolean };+ const buckets = new Map<string, { items: Stashed[]; start: number }>();+ const stash = (result: unknown, id?: string, name?: string) => {+ const entry: Stashed = { result };+ const keys =+ id === undefined && name === undefined+ ? ["anon"]+ : [id !== undefined && `id:${id}`, name !== undefined && `name:${name}`, id === undefined && `bare:${name}`];+ for (const key of keys) {+ if (!key) continue;+ const bucket = buckets.get(key);+ if (bucket) bucket.items.push(entry);+ else buckets.set(key, { items: [entry], start: 0 });+ }+ };+ const take = (key: string) => {+ const bucket = buckets.get(key);+ if (!bucket) return undefined;+ while (bucket.start < bucket.items.length && bucket.items[bucket.start].used) bucket.start++;+ const entry = bucket.items[bucket.start];+ if (entry) entry.used = true;+ return entry?.result;+ };+ const pending: Array<{+ turn: number;+ hasExplicitId: boolean;+ part: { toolCallId: string; toolName: string; result?: unknown };+ }> = [];+ const bindResult = (+ pred: (entry: (typeof pending)[number]) => boolean,+ result: unknown,+ ) => {+ for (let at = pending.length - 1; at >= 0; at--) {+ if (!pred(pending[at])) continue;+ const { turn } = pending[at];+ const first = pending.findIndex((entry) => entry.turn === turn && pred(entry));+ pending[first].part.result = result;+ pending.splice(first, 1);+ return true;+ }+ return false;+ };const records: MessageRecord[] = [];let prevId: string | null = null;let idx = 0;for (const m of oaiMsgs) {- if (typeof m !== "object" || m === null) continue;+ if (m === null || typeof m !== "object") continue;const msg = m as Record<string, unknown>;const role = msg.role as string;- if (role === "tool") {- if (typeof msg.tool_call_id !== "string") continue;+ if (role === "tool" || role === "function") {const result =(msg as { [STRUCTURED_RESULT]?: unknown })[STRUCTURED_RESULT] ??(typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? ""));- let at = pending.length - 1;- while (at >= 0 && pending[at].part.toolCallId !== msg.tool_call_id) at--;- if (at === -1) {- toolResults.set(msg.tool_call_id, result);- } else {- const { turn } = pending[at];- at = pending.findIndex((entry) => entry.turn === turn && entry.part.toolCallId === msg.tool_call_id);- pending[at].part.result = result;- pending.splice(at, 1);- }+ const idKey =+ typeof msg.tool_call_id === "string" ? msg.tool_call_id : undefined;+ const nameKey = typeof msg.name === "string" ? msg.name : undefined;+ // An id always wins over a name; unnamed results bind in call order within the newest turn.+ const bound =+ idKey !== undefined+ ? bindResult((entry) => entry.part.toolCallId === idKey, result)+ : nameKey !== undefined+ ? bindResult((entry) => entry.part.toolName === nameKey, result)+ : bindResult(() => true, result);+ if (!bound) stash(result, idKey, nameKey);continue;}@@ -184,28 +225,72 @@ function oaiMessagesToRecords(if (role === "assistant") {const parts = oaiContentToParts(msg.content);if (parts.length === 0) parts.push(...oaiContentToParts(msg.refusal));+ const argumentsText = (fn: Record<string, unknown>) =>+ typeof fn.arguments === "string"+ ? fn.arguments+ : JSON.stringify(fn.arguments ?? {});+ const parseArgs = (argsStr: string): unknown => {+ // _raw matches what the stream adapter and backend keep for invalid JSON arguments.+ try { return JSON.parse(argsStr); } catch { return { _raw: argsStr }; }+ };const callParts: unknown[] = [];- if (Array.isArray(msg.tool_calls)) {- for (const tc of msg.tool_calls) {+ const addCall = (fn: Record<string, unknown>, callId: unknown) => {+ const argsStr = argumentsText(fn);+ const part: { type: string; toolCallId: string; toolName: string; args: unknown; argsText: string; result?: unknown } = {+ type: "tool-call",+ toolCallId: typeof callId === "string" ? callId : crypto.randomUUID(),+ toolName: typeof fn.name === "string" ? fn.name : "unknown",+ args: parseArgs(argsStr),+ argsText: argsStr,+ };+ callParts.push(part);+ // An earlier result binds now (id, else id-less name, else anonymous), in arrival order.+ const early =+ (typeof callId === "string" ? take(`id:${callId}`) : undefined) ??+ take(`bare:${part.toolName}`) ??+ take("anon");+ if (early !== undefined) part.result = early;+ else pending.push({ turn: idx, part, hasExplicitId: typeof callId === "string" });+ };+ // LangChain nests both call shapes under additional_kwargs.+ const additional =+ typeof msg.additional_kwargs === "object" && msg.additional_kwargs !== null+ ? (msg.additional_kwargs as Record<string, unknown>)+ : undefined;+ const toolCalls = Array.isArray(msg.tool_calls)+ ? msg.tool_calls+ : additional !== undefined && Array.isArray(additional.tool_calls)+ ? additional.tool_calls+ : undefined;+ if (toolCalls !== undefined) {+ for (const tc of toolCalls) {+ if (tc === null || typeof tc !== "object") continue;const tcObj = tc as Record<string, unknown>;- const fn = (tcObj.function as Record<string, unknown>) ?? {};- const tcId = typeof tcObj.id === "string" ? tcObj.id : crypto.randomUUID();- const name = typeof fn.name === "string" ? fn.name : "unknown";- const argsStr = typeof fn.arguments === "string" ? fn.arguments : "{}";- let args: unknown = {};- // _raw matches what the stream adapter and backend keep for invalid JSON arguments.- try { args = JSON.parse(argsStr); } catch { args = { _raw: argsStr }; }- const part = {- type: "tool-call",- toolCallId: tcId,- toolName: name,- args,- argsText: argsStr,- };- callParts.push(part);- pending.push({ turn: idx, part });+ const fn = tcObj.function;+ addCall(+ (typeof fn === "object" && fn !== null ? fn : tcObj) as Record<string, unknown>,+ tcObj.id ?? tcObj.call_id,+ );}}+ const legacyCall =+ (typeof msg.function_call === "object" && msg.function_call) ||+ additional?.function_call;+ if (typeof legacyCall === "object" && legacyCall !== null) {+ const fn = legacyCall as Record<string, unknown>;+ const name = typeof fn.name === "string" ? fn.name : "unknown";+ const args = JSON.stringify(parseArgs(argumentsText(fn)));+ // Converters that upgraded the call to tool_calls sometimes leave the copy, maybe reserialized.+ const alreadyListed = callParts.some((part) => {+ const p = part as { type?: string; toolName?: string; toolCallId?: string; args?: unknown };+ return (+ p.type === "tool-call" &&+ p.toolName === name &&+ (typeof fn.id === "string" ? p.toolCallId === fn.id : JSON.stringify(p.args) === args)+ );+ });+ if (!alreadyListed) addCall(fn, fn.id);+ }const order = (msg as { [ITEM_ORDER]?: unknown[] })[ITEM_ORDER];content = order? order.flatMap((item) =>@@ -231,9 +316,10 @@ function oaiMessagesToRecords(idx++;}- for (const { part } of pending) {- const result = toolResults.get(part.toolCallId);- if (result !== undefined) part.result = result;+ // A keyed result binds by name only to a call without its own id; keyed leftovers drop.+ for (const { part, hasExplicitId } of pending) {+ if (part.result !== undefined) continue;+ part.result = take(`${hasExplicitId ? "bare" : "name"}:${part.toolName}`);}return records;diff --git a/studio/frontend/src/features/chat/utils/ndjson.ts b/studio/frontend/src/features/chat/utils/ndjson.tsindex 1717aa3bb95..b0e87e28b6e 100644--- a/studio/frontend/src/features/chat/utils/ndjson.ts+++ b/studio/frontend/src/features/chat/utils/ndjson.ts@@ -28,6 +28,7 @@ const OPENAI_MESSAGE_ROLES = new Set(["user","assistant","tool",+ "function",]);export function isOpenAIMessageRecord(@@ -40,7 +41,11 @@ export function isOpenAIMessageRecord(return (typeof message.role === "string" &&OPENAI_MESSAGE_ROLES.has(message.role) &&- ("content" in message || Array.isArray(message.tool_calls))+ !Array.isArray(message.messages) &&+ !Array.isArray(message.conversations) &&+ ("content" in message ||+ Array.isArray(message.tool_calls) ||+ "function_call" in message));}diff --git a/studio/frontend/src/features/chat/utils/openwebui-import.ts b/studio/frontend/src/features/chat/utils/openwebui-import.tsindex 778242302d0..90b3a783c25 100644--- a/studio/frontend/src/features/chat/utils/openwebui-import.ts+++ b/studio/frontend/src/features/chat/utils/openwebui-import.ts@@ -58,7 +58,13 @@ function looksLikeOpenWebUIMessage(value: unknown): boolean {function looksLikeOpenAIToolMessage(value: unknown): boolean {if (!isDict(value)) return false;- return value.role === "tool" || "tool_calls" in value || "tool_call_id" in value;+ return (+ value.role === "tool" ||+ value.role === "function" ||+ "tool_calls" in value ||+ "tool_call_id" in value ||+ "function_call" in value+ );}export function isOpenWebUIRecord(value: unknown): boolean {diff --git a/studio/frontend/tests/message-jsonl-import.test.ts b/studio/frontend/tests/message-jsonl-import.test.tsindex c7b4fc64af6..31a673a9c7a 100644--- a/studio/frontend/tests/message-jsonl-import.test.ts+++ b/studio/frontend/tests/message-jsonl-import.test.ts@@ -968,3 +968,510 @@ test("a hosted call before its answer exports in that order", () => {);assert.equal(answerAt, exported.length - 1);});++test("legacy function_call turns survive message JSONL import", () => {+ const [conversation] = parseImportText(+ [+ '{"role":"user","content":"Weather in Paris?"}',+ '{"role":"assistant","content":null,"function_call":{"name":"get_weather","arguments":"{\\"city\\":\\"Paris\\"}"}}',+ '{"role":"function","name":"get_weather","content":"72F sunny"}',+ '{"role":"assistant","content":"It is 72 and sunny."}',+ ].join("\n"),+ "conversation-messages.jsonl",+ );++ assert.deepEqual(+ conversation.messages.map(({ role }) => role),+ ["user", "assistant", "assistant"],+ );+ assert.deepEqual(toolCallResults(conversation), ["72F sunny"]);+ const call = (+ conversation.messages[1].content as ReadonlyArray<{+ type: string;+ toolName?: string;+ args?: unknown;+ }>+ )[0];+ assert.equal(call.type, "tool-call");+ assert.equal(call.toolName, "get_weather");+ assert.deepEqual(call.args, { city: "Paris" });+});++test("legacy function results reach their call inside a messages record", () => {+ const [conversation] = parseImportText(+ JSON.stringify({+ messages: [+ { role: "user", content: "Add 2+2" },+ {+ role: "assistant",+ content: null,+ function_call: { name: "calc", arguments: '{"e":"2+2"}' },+ },+ { role: "function", name: "calc", content: "4" },+ { role: "assistant", content: "4" },+ ],+ }),+ "chat.jsonl",+ );++ assert.deepEqual(+ conversation.messages.map(({ role }) => role),+ ["user", "assistant", "assistant"],+ );+ assert.deepEqual(toolCallResults(conversation), ["4"]);+});++test("each legacy function result reaches the call that named it", () => {+ const [conversation] = parseImportText(+ [+ '{"role":"user","content":"Time and weather?"}',+ '{"role":"assistant","content":null,"function_call":{"name":"get_time","arguments":"{}"}}',+ '{"role":"assistant","content":null,"function_call":{"name":"get_weather","arguments":"{}"}}',+ '{"role":"function","name":"get_time","content":"NOON"}',+ '{"role":"function","name":"get_weather","content":"RAIN"}',+ ].join("\n"),+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["NOON", "RAIN"]);+});++test("a legacy function result ahead of its call still lands on it", () => {+ const [conversation] = parseImportText(+ '{"role":"function","name":"lookup","content":"EARLY"}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"lookup","arguments":"{}"}}\n' ++ '{"role":"assistant","content":"Done"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["EARLY"]);+});++test("assistant text stays beside its legacy function call", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":"Checking.","function_call":{"name":"lookup","arguments":"not json"}}\n' ++ '{"role":"function","name":"lookup","content":"FOUND"}',+ "conversation-messages.jsonl",+ );++ const call = (+ conversation.messages[0].content as ReadonlyArray<{+ type: string;+ toolCallId: string;+ }>+ )[1];+ assert.equal(typeof call.toolCallId, "string");+ assert.notEqual(call.toolCallId.length, 0);+ assert.deepEqual(conversation.messages[0].content, [+ { type: "text", text: "Checking." },+ {+ type: "tool-call",+ toolCallId: call.toolCallId,+ toolName: "lookup",+ args: { _raw: "not json" },+ argsText: "not json",+ result: "FOUND",+ },+ ]);+});++test("already-parsed legacy function arguments survive import", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":{"a":1}}}',+ "conversation-messages.jsonl",+ );++ const call = (+ conversation.messages[0].content as ReadonlyArray<{+ args?: unknown;+ argsText?: string;+ }>+ )[0];+ assert.deepEqual(call.args, { a: 1 });+ assert.equal(call.argsText, '{"a":1}');+});++test("a structured legacy function result imports as json text", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"function","name":"f","content":{"rows":3}}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ['{"rows":3}']);+});++test("an assistant line carrying only function_call still counts as a message", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","function_call":{"name":"f","arguments":"{}"}}',+ "conversation-messages.jsonl",+ );++ assert.equal(conversation.messages.length, 1);+ assert.deepEqual(toolCallResults(conversation), ["undefined"]);+});++test("an early function result reaches only one same-name call", () => {+ const [conversation] = parseImportText(+ '{"role":"function","name":"f","content":"EARLY"}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["EARLY", "undefined"]);+});++test("early function results land on same-name calls in order", () => {+ const [conversation] = parseImportText(+ '{"role":"function","name":"f","content":"FIRST"}\n' ++ '{"role":"function","name":"f","content":"SECOND"}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["FIRST", "SECOND"]);+});++test("batched same-name results bind the newest call still waiting", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"function","name":"f","content":"R1"}\n' ++ '{"role":"function","name":"f","content":"R2"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["R2", "R1"]);+});++test("a legacy function result can name a modern tool call", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"call_1","type":"function","function":{"name":"search","arguments":"{}"}}]}\n' ++ '{"role":"function","name":"search","content":"RESULT"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["RESULT"]);+});++test("a message-shaped record keeps its nested messages conversation", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","function_call":{"name":"f","arguments":"{}"},' ++ '"messages":[{"role":"user","content":"hi"}]}',+ "chat.jsonl",+ );++ assert.deepEqual(+ conversation.messages.map(({ role }) => role),+ ["user"],+ );+});++test("flat tool_calls entries keep their name and arguments", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"t1","name":"search","arguments":{"q":"x"}}]}\n' ++ '{"role":"tool","tool_call_id":"t1","content":"HIT"}',+ "conversation-messages.jsonl",+ );++ const call = (+ conversation.messages[0].content as ReadonlyArray<{+ toolCallId?: string;+ toolName?: string;+ args?: unknown;+ }>+ )[0];+ assert.equal(call.toolCallId, "t1");+ assert.equal(call.toolName, "search");+ assert.deepEqual(call.args, { q: "x" });+ assert.deepEqual(toolCallResults(conversation), ["HIT"]);+});++test("already-parsed arguments on a modern tool call survive import", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"t1","type":"function","function":{"name":"f","arguments":{"a":1}}}]}',+ "conversation-messages.jsonl",+ );++ const call = (+ conversation.messages[0].content as ReadonlyArray<{+ args?: unknown;+ argsText?: string;+ }>+ )[0];+ assert.deepEqual(call.args, { a: 1 });+ assert.equal(call.argsText, '{"a":1}');+});++test("call_id identifies a flat tool call", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"call_id":"c9","name":"f","arguments":"{}"}]}\n' ++ '{"role":"tool","tool_call_id":"c9","content":"OK"}',+ "conversation-messages.jsonl",+ );++ const call = (+ conversation.messages[0].content as ReadonlyArray<{ toolCallId?: string }>+ )[0];+ assert.equal(call.toolCallId, "c9");+ assert.deepEqual(toolCallResults(conversation), ["OK"]);+});++test("a tool result that only names its call still reaches it", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"t1","type":"function","function":{"name":"f","arguments":"{}"}}]}\n' ++ '{"role":"tool","name":"f","content":"BYNAME"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["BYNAME"]);+});++test("a tool result falls back to its name when its id matches nothing", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"tool","tool_call_id":"unrelated","name":"f","content":"FELLBACK"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["FELLBACK"]);+});++test("an unnamed function result lands on the newest unanswered call", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"g","arguments":"{}"}}\n' ++ '{"role":"function","content":"NONAME"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["undefined", "NONAME"]);+});++test("unnamed results for parallel calls bind in call order", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"name":"f","arguments":{}},{"name":"g","arguments":{}}]}\n' ++ '{"role":"tool","content":"FIRST"}\n' ++ '{"role":"tool","content":"SECOND"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["FIRST", "SECOND"]);+});++test("an unnamed early function result waits for a call", () => {+ const [conversation] = parseImportText(+ '{"role":"function","content":"ORPHAN"}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["ORPHAN"]);+});++test("a function_call nested under additional_kwargs survives", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":"","additional_kwargs":{"function_call":{"name":"f","arguments":"{\\"a\\":1}"}}}\n' ++ '{"role":"function","name":"f","content":"KW"}',+ "conversation-messages.jsonl",+ );++ const call = (+ conversation.messages[0].content as ReadonlyArray<{+ toolName?: string;+ args?: unknown;+ }>+ )[0];+ assert.equal(call.toolName, "f");+ assert.deepEqual(call.args, { a: 1 });+ assert.deepEqual(toolCallResults(conversation), ["KW"]);+});++test("tool_calls nested under additional_kwargs survive", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":"","additional_kwargs":{"tool_calls":[{"id":"k1","type":"function","function":{"name":"f","arguments":"{}"}}]}}\n' ++ '{"role":"tool","tool_call_id":"k1","content":"KWTC"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["KWTC"]);+});++test("a function_call duplicated inside tool_calls produces one call", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"t1","type":"function","function":{"name":"f","arguments":"{\\"a\\":1}"}}],"function_call":{"name":"f","arguments":"{\\"a\\":1}"}}',+ "conversation-messages.jsonl",+ );++ const parts = conversation.messages[0].content as ReadonlyArray<{+ type: string;+ }>;+ assert.deepEqual(+ parts.map(({ type }) => type),+ ["tool-call"],+ );+});++test("a keyed early result is not stolen by an earlier different-name call", () => {+ const [conversation] = parseImportText(+ '{"role":"function","name":"g","content":"Rg"}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"g","arguments":"{}"}}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["undefined", "Rg"]);+});++test("a tool result waits for the call its id names", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}\n' ++ '{"role":"tool","tool_call_id":"x","name":"f","content":"R"}\n' ++ '{"role":"assistant","content":null,"tool_calls":[{"id":"x","type":"function","function":{"name":"f","arguments":"{}"}}]}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["undefined", "R"]);+});++test("a function_call id lets a modern tool result bind it", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"function_call":{"id":"fc1","name":"f","arguments":"{}"}}\n' ++ '{"role":"tool","tool_call_id":"fc1","content":"BYID"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["BYID"]);+});++test("same-name calls in one turn take results in call order", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[' ++ '{"id":"a","type":"function","function":{"name":"f","arguments":"{}"}},' ++ '{"id":"b","type":"function","function":{"name":"f","arguments":"{}"}}]}\n' ++ '{"role":"tool","name":"f","content":"R1"}\n' ++ '{"role":"tool","name":"f","content":"R2"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["R1", "R2"]);+});++test("a function_call with different arguments is not deduplicated", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[' ++ '{"id":"t1","type":"function","function":{"name":"f","arguments":"{\\"a\\":1}"}}],' ++ '"function_call":{"name":"f","arguments":"{\\"a\\":2}"}}',+ "conversation-messages.jsonl",+ );++ assert.equal(conversation.messages[0].content.length, 2);+});++test("a keyed result for a call that never appears drops instead of lying", () => {+ const [conversation] = parseImportText(+ '{"role":"tool","tool_call_id":"ghost","name":"stock","content":"AAPL"}\n' ++ '{"role":"assistant","content":null,"function_call":{"name":"f","arguments":"{}"}}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["undefined"]);+});++for (const role of ["tool", "function"]) {+ for (const resultFirst of [false, true]) {+ test(`a ${role} result with an unmatched id cannot bind by name (${resultFirst ? "early" : "late"})`, () => {+ const call = {+ role: "assistant",+ content: null,+ tool_calls: [{ id: "real-call", type: "function", function: { name: "lookup", arguments: "{}" } }],+ };+ const result = { role, tool_call_id: "missing-call", name: "lookup", content: "WRONG RESULT" };+ const messages = resultFirst ? [result, call] : [call, result];+ const [conversation] = parseImportText(+ messages.map((message) => JSON.stringify(message)).join("\n"),+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["undefined"]);+ });+ }+}++test("a null tool_calls entry does not lose the other calls", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[null,{"id":"t1","type":"function","function":{"name":"f","arguments":"{}"}}]}\n' ++ '{"role":"tool","tool_call_id":"t1","content":"OK"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["OK"]);+});++test("a null entry inside a messages record does not lose the conversation", () => {+ const [conversation] = parseImportText(+ '{"messages":[null,{"role":"user","content":"hi"},7,{"role":"assistant","content":"yo"}]}',+ "chat.jsonl",+ );++ assert.deepEqual(+ conversation.messages.map(({ role }) => role),+ ["user", "assistant"],+ );+});++test("an early keyed result is not displaced by a later anonymous one", () => {+ const [conversation] = parseImportText(+ '{"role":"tool","tool_call_id":"a","content":"A"}\n' ++ '{"role":"assistant","content":null,"tool_calls":[{"id":"a","type":"function","function":{"name":"f","arguments":"{}"}},{"id":"b","type":"function","function":{"name":"g","arguments":"{}"}}]}\n' ++ '{"role":"tool","content":"B"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["A", "B"]);+});++test("a reserialized function_call copy of a tool call is not duplicated", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"c1","type":"function","function":{"name":"f","arguments":"{\\"a\\":1}"}}],"function_call":{"name":"f","arguments":"{\\"a\\": 1}"}}\n' ++ '{"role":"tool","tool_call_id":"c1","content":"R"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["R"]);+});++test("a legacy copy with a different explicit id stays its own call", () => {+ const [conversation] = parseImportText(+ '{"role":"assistant","content":null,"tool_calls":[{"id":"a","type":"function","function":{"name":"f","arguments":"{}"}}],"function_call":{"id":"b","name":"f","arguments":"{}"}}\n' ++ '{"role":"tool","tool_call_id":"a","content":"A"}\n' ++ '{"role":"tool","tool_call_id":"b","content":"B"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["A", "B"]);+});++test("a name-only result ahead of its calls keeps arrival order", () => {+ const [conversation] = parseImportText(+ '{"role":"tool","name":"f","content":"A"}\n' ++ '{"role":"assistant","content":null,"tool_calls":[{"id":"a","type":"function","function":{"name":"f","arguments":"{}"}},{"id":"b","type":"function","function":{"name":"f","arguments":"{}"}}]}\n' ++ '{"role":"tool","name":"f","content":"B"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["A", "B"]);+});++test("an anonymous result ahead of its calls keeps arrival order", () => {+ const [conversation] = parseImportText(+ '{"role":"tool","content":"A"}\n' ++ '{"role":"assistant","content":null,"tool_calls":[{"id":"a","type":"function","function":{"name":"f","arguments":"{}"}},{"id":"b","type":"function","function":{"name":"g","arguments":"{}"}}]}\n' ++ '{"role":"tool","content":"B"}',+ "conversation-messages.jsonl",+ );++ assert.deepEqual(toolCallResults(conversation), ["A", "B"]);+});diff --git a/studio/frontend/tests/ndjson-body.test.ts b/studio/frontend/tests/ndjson-body.test.tsindex a5336ea93a6..339db620926 100644--- a/studio/frontend/tests/ndjson-body.test.ts+++ b/studio/frontend/tests/ndjson-body.test.ts@@ -69,7 +69,34 @@ test("message JSONL records form one importable conversation", () => {isOpenAIMessageRecord({ role: "developer", content: "Follow policy" }),true,);+ assert.equal(+ isOpenAIMessageRecord({ role: "function", name: "f", content: "x" }),+ true,+ );+ assert.equal(+ isOpenAIMessageRecord({+ role: "assistant",+ function_call: { name: "f", arguments: "{}" },+ }),+ true,+ );assert.equal(isOpenAIMessageRecord({ messages }), false);+ assert.equal(+ isOpenAIMessageRecord({+ role: "assistant",+ function_call: { name: "f" },+ messages,+ }),+ false,+ );+ assert.equal(+ isOpenAIMessageRecord({ role: "function", content: "x", conversations: [] }),+ false,+ );+ assert.equal(+ isOpenAIMessageRecord({ role: "user", content: "hi", messages: null }),+ true,+ );assert.deepEqual(messageJsonlConversationRecord(messages), { messages });});diff --git a/studio/frontend/tests/openwebui-import.test.ts b/studio/frontend/tests/openwebui-import.test.tsindex 596a3cdd825..e3d0c1ca53e 100644--- a/studio/frontend/tests/openwebui-import.test.ts+++ b/studio/frontend/tests/openwebui-import.test.ts@@ -560,6 +560,19 @@ test("a timestamped OpenAI conversation is not mistaken for an Open WebUI chat",);});+test("a timestamped legacy function-call conversation is not mistaken for an Open WebUI chat", () => {+ assert.equal(+ isOpenWebUIRecord({+ messages: [+ { role: "user", content: "weather?", timestamp: 1 },+ { role: "assistant", content: "", function_call: { name: "w", arguments: "{}" }, timestamp: 2 },+ { role: "function", name: "w", content: "21C", timestamp: 3 },+ ],+ }),+ false,+ );+});+test("a generated image comes over as an image, not as a dropped output item", () => {const record = recordOf([