Skip to content

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.

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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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(
[