137 lines
3.1 KiB
TypeScript
137 lines
3.1 KiB
TypeScript
export interface ParsedToolCall {
|
|
id?: string | undefined;
|
|
name: string;
|
|
arguments: Record<string, unknown>;
|
|
}
|
|
|
|
interface OpenAiToolCallShape {
|
|
id?: string;
|
|
function?: {
|
|
name?: string;
|
|
arguments?: string;
|
|
};
|
|
}
|
|
|
|
function asRecord(value: unknown): Record<string, unknown> {
|
|
return typeof value === "object" && value !== null
|
|
? (value as Record<string, unknown>)
|
|
: {};
|
|
}
|
|
|
|
function parseJsonArguments(raw: unknown): Record<string, unknown> | null {
|
|
if (typeof raw === "string") {
|
|
try {
|
|
const parsed = JSON.parse(raw) as unknown;
|
|
return asRecord(parsed);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (typeof raw === "object" && raw !== null) {
|
|
return raw as Record<string, unknown>;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function parseHermesCalls(content: string): ParsedToolCall[] {
|
|
const matches = [...content.matchAll(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/gu)];
|
|
|
|
return matches.flatMap((match) => {
|
|
const payload = match[1];
|
|
if (!payload) {
|
|
return [];
|
|
}
|
|
|
|
try {
|
|
const parsed = JSON.parse(payload) as
|
|
| {
|
|
id?: string;
|
|
name?: string;
|
|
arguments?: unknown;
|
|
}
|
|
| Array<{
|
|
id?: string;
|
|
name?: string;
|
|
arguments?: unknown;
|
|
}>;
|
|
|
|
const items = Array.isArray(parsed) ? parsed : [parsed];
|
|
return items.flatMap((item) => {
|
|
const args = parseJsonArguments(item.arguments);
|
|
if (!item.name || !args) {
|
|
return [];
|
|
}
|
|
|
|
return [
|
|
{
|
|
id: item.id,
|
|
name: item.name,
|
|
arguments: args,
|
|
},
|
|
];
|
|
});
|
|
} catch {
|
|
return [];
|
|
}
|
|
});
|
|
}
|
|
|
|
function parseOpenAiCalls(value: unknown): ParsedToolCall[] {
|
|
const record = asRecord(value);
|
|
const choices = Array.isArray(record["choices"])
|
|
? (record["choices"] as unknown[])
|
|
: [];
|
|
const firstChoice = choices[0];
|
|
const candidates = [
|
|
record["tool_calls"],
|
|
asRecord(record["message"])["tool_calls"],
|
|
asRecord(asRecord(firstChoice)["message"])["tool_calls"],
|
|
];
|
|
|
|
const toolCallsCandidate = candidates.find(Array.isArray);
|
|
if (!Array.isArray(toolCallsCandidate)) {
|
|
return [];
|
|
}
|
|
|
|
return toolCallsCandidate.flatMap((item) => {
|
|
const call = item as OpenAiToolCallShape;
|
|
const args = parseJsonArguments(call.function?.arguments);
|
|
const name = call.function?.name;
|
|
|
|
if (!name || !args) {
|
|
return [];
|
|
}
|
|
|
|
return [
|
|
{
|
|
id: call.id,
|
|
name,
|
|
arguments: args,
|
|
},
|
|
];
|
|
});
|
|
}
|
|
|
|
export function parseToolCalls(value: unknown): ParsedToolCall[] {
|
|
if (typeof value === "string") {
|
|
return parseHermesCalls(value);
|
|
}
|
|
|
|
const record = asRecord(value);
|
|
const content =
|
|
typeof record["content"] === "string"
|
|
? record["content"]
|
|
: typeof asRecord(record["message"])["content"] === "string"
|
|
? (asRecord(record["message"])["content"] as string)
|
|
: "";
|
|
|
|
const parsedOpenAiCalls = parseOpenAiCalls(value);
|
|
if (parsedOpenAiCalls.length > 0) {
|
|
return parsedOpenAiCalls;
|
|
}
|
|
|
|
return content ? parseHermesCalls(content) : [];
|
|
}
|