mirror of
https://github.com/diegosouzapw/OmniRoute.git
synced 2026-08-14 11:12:17 +03:00
398 lines
13 KiB
TypeScript
398 lines
13 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
|
|
// Tool call helper functions for translator
|
|
|
|
const ALPHANUM9 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
|
|
|
|
type JsonRecord = Record<string, unknown>;
|
|
type ToolNameAliases = Map<string, string>;
|
|
|
|
interface ToolFunction extends JsonRecord {
|
|
name?: unknown;
|
|
arguments?: unknown;
|
|
}
|
|
|
|
interface ToolCallRecord extends JsonRecord {
|
|
id?: unknown;
|
|
type?: unknown;
|
|
function?: ToolFunction;
|
|
}
|
|
|
|
interface ToolContentBlock extends JsonRecord {
|
|
type?: unknown;
|
|
id?: unknown;
|
|
tool_use_id?: unknown;
|
|
}
|
|
|
|
interface ToolMessage extends JsonRecord {
|
|
role?: unknown;
|
|
tool_calls?: ToolCallRecord[];
|
|
tool_call_id?: unknown;
|
|
content?: unknown;
|
|
}
|
|
|
|
interface ToolCallBody extends JsonRecord {
|
|
messages?: ToolMessage[];
|
|
}
|
|
|
|
function toRecord(value: unknown): JsonRecord | null {
|
|
return value && typeof value === "object" && !Array.isArray(value) ? (value as JsonRecord) : null;
|
|
}
|
|
|
|
function aliasOpenAIToolName(name: unknown, maxLength: number, aliases: ToolNameAliases): unknown {
|
|
if (typeof name !== "string" || name.length === 0) return name;
|
|
|
|
const safe = name.replace(/[^A-Za-z0-9_-]/g, "_");
|
|
if (safe === name && safe.length <= maxLength) return safe;
|
|
|
|
const hash = createHash("sha256").update(name).digest("hex").slice(0, 12);
|
|
const prefixLength = Math.max(0, maxLength - hash.length - 1);
|
|
const shortened =
|
|
prefixLength > 0 ? `${safe.slice(0, prefixLength)}_${hash}` : hash.slice(0, maxLength);
|
|
aliases.set(shortened, name);
|
|
return shortened;
|
|
}
|
|
|
|
/**
|
|
* Mutates an OpenAI-compatible request so every function name satisfies a
|
|
* provider's maximum length and `[A-Za-z0-9_-]` character constraints.
|
|
* Returns alias → original entries for response restoration.
|
|
*/
|
|
export function normalizeOpenAIToolNames(body: unknown, maxLength: number): ToolNameAliases {
|
|
const aliases: ToolNameAliases = new Map();
|
|
const root = toRecord(body);
|
|
if (!root || !Number.isInteger(maxLength) || maxLength < 1) return aliases;
|
|
|
|
const alias = (name: unknown): unknown => aliasOpenAIToolName(name, maxLength, aliases);
|
|
|
|
if (Array.isArray(root.tools)) {
|
|
for (const tool of root.tools) {
|
|
const fn = toRecord(toRecord(tool)?.function);
|
|
if (fn && typeof fn.name === "string") fn.name = alias(fn.name);
|
|
}
|
|
}
|
|
|
|
const toolChoiceFunction = toRecord(toRecord(root.tool_choice)?.function);
|
|
if (toolChoiceFunction && typeof toolChoiceFunction.name === "string") {
|
|
toolChoiceFunction.name = alias(toolChoiceFunction.name);
|
|
}
|
|
|
|
if (Array.isArray(root.messages)) {
|
|
for (const message of root.messages) {
|
|
const msg = toRecord(message);
|
|
if (!msg) continue;
|
|
if (Array.isArray(msg.tool_calls)) {
|
|
for (const toolCall of msg.tool_calls) {
|
|
const fn = toRecord(toRecord(toolCall)?.function);
|
|
if (fn && typeof fn.name === "string") fn.name = alias(fn.name);
|
|
}
|
|
}
|
|
if (msg.role === "tool" && typeof msg.name === "string") {
|
|
msg.name = alias(msg.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
return aliases;
|
|
}
|
|
|
|
/**
|
|
* Case-insensitive fallback for tool name lookups from upstream responses.
|
|
*
|
|
* Many upstream providers/models return tool call names in lowercase (e.g., "bash")
|
|
* even when the tool definition used PascalCase ("Bash"). This helper tries an exact
|
|
* match first (fast path for well-behaved providers), then falls back to a
|
|
* case-insensitive scan over the map entries.
|
|
*
|
|
* Returns the mapped value on match, or `undefined` when no entry matches.
|
|
*/
|
|
export function caseInsensitiveToolNameLookup(
|
|
name: string,
|
|
map: Map<string, string> | null | undefined
|
|
): string | undefined {
|
|
if (!map || !name) return undefined;
|
|
|
|
// Fast path: exact match (PascalCase-preserving providers)
|
|
const exact = map.get(name);
|
|
if (exact !== undefined) return exact;
|
|
|
|
// Fallback: case-insensitive scan
|
|
const lowerName = name.toLowerCase();
|
|
for (const [key, value] of map) {
|
|
if (key.toLowerCase() === lowerName) {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/** Restore normalized function names in OpenAI Chat Completions responses. */
|
|
export function restoreOpenAIToolNames(body: unknown, aliases: unknown): boolean {
|
|
if (!(aliases instanceof Map) || aliases.size === 0) return false;
|
|
const root = toRecord(body);
|
|
if (!root || !Array.isArray(root.choices)) return false;
|
|
|
|
let changed = false;
|
|
const restoreCalls = (calls: unknown): void => {
|
|
if (!Array.isArray(calls)) return;
|
|
for (const toolCall of calls) {
|
|
const fn = toRecord(toRecord(toolCall)?.function);
|
|
if (!fn || typeof fn.name !== "string") continue;
|
|
const original = caseInsensitiveToolNameLookup(fn.name, aliases);
|
|
if (typeof original !== "string" || original === fn.name) continue;
|
|
fn.name = original;
|
|
changed = true;
|
|
}
|
|
};
|
|
|
|
for (const choice of root.choices) {
|
|
const record = toRecord(choice);
|
|
if (!record) continue;
|
|
restoreCalls(toRecord(record.delta)?.tool_calls);
|
|
restoreCalls(toRecord(record.message)?.tool_calls);
|
|
}
|
|
|
|
return changed;
|
|
}
|
|
|
|
// Fallback streaming tool_call id when a provider response omits one (index optional).
|
|
// `call_<ts>` when no index is given; `call_<index>_<ts>` when an index is supplied.
|
|
export function fallbackToolCallId(index?: number): string {
|
|
return index === undefined ? `call_${Date.now()}` : `call_${index}_${Date.now()}`;
|
|
}
|
|
|
|
// Generate unique tool call ID (default long form)
|
|
export function generateToolCallId() {
|
|
return `call_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
|
|
}
|
|
|
|
// Generate 9-char [a-zA-Z0-9] id for providers that require it (e.g. Mistral)
|
|
function generateToolCallId9(): string {
|
|
let s = "";
|
|
for (let i = 0; i < 9; i++) {
|
|
s += ALPHANUM9[Math.floor(Math.random() * ALPHANUM9.length)];
|
|
}
|
|
return s;
|
|
}
|
|
|
|
/** @param options.use9CharId - When true, normalize ids to 9-char [a-zA-Z0-9] (e.g. Mistral); when false, only fix type/arguments, leave ids as-is */
|
|
export function ensureToolCallIds<T extends ToolCallBody>(
|
|
body: T,
|
|
options?: { use9CharId?: boolean }
|
|
): T {
|
|
if (!body.messages || !Array.isArray(body.messages)) return body;
|
|
|
|
const use9CharId = options?.use9CharId === true;
|
|
|
|
for (let i = 0; i < body.messages.length; i++) {
|
|
const msg = body.messages[i];
|
|
if (msg.role !== "assistant" || !msg.tool_calls || !Array.isArray(msg.tool_calls)) continue;
|
|
|
|
const used9 = new Set<string>();
|
|
const newIdsInOrder: string[] = [];
|
|
|
|
for (const tc of msg.tool_calls) {
|
|
if (!tc.type) {
|
|
tc.type = "function";
|
|
}
|
|
if (tc.function?.arguments && typeof tc.function.arguments !== "string") {
|
|
tc.function.arguments = JSON.stringify(tc.function.arguments);
|
|
}
|
|
if (use9CharId) {
|
|
let newId: string;
|
|
do {
|
|
newId = generateToolCallId9();
|
|
} while (used9.has(newId));
|
|
used9.add(newId);
|
|
newIdsInOrder.push(newId);
|
|
tc.id = newId;
|
|
} else {
|
|
// Leave id as-is, only ensure it exists for later tool message matching
|
|
const id =
|
|
tc.id != null && String(tc.id).trim() !== "" ? String(tc.id) : generateToolCallId();
|
|
tc.id = id;
|
|
newIdsInOrder.push(id);
|
|
}
|
|
}
|
|
|
|
// Tool responses (role "tool") follow in the same order as tool_calls. Rewrite
|
|
// every id only when the provider requires generated 9-char ids; otherwise keep
|
|
// explicit client ids and fill only missing ones. Overwriting a compacted orphan's
|
|
// explicit id by position can make it impersonate a different parallel call.
|
|
// Stop at the next assistant so we only link responses belonging to this turn.
|
|
if (newIdsInOrder.length > 0) {
|
|
let idx = 0;
|
|
for (let j = i + 1; j < body.messages.length; j++) {
|
|
const later = body.messages[j];
|
|
if (later.role === "assistant") break;
|
|
if (later.role !== "tool") continue;
|
|
if (idx < newIdsInOrder.length) {
|
|
if (
|
|
use9CharId ||
|
|
later.tool_call_id == null ||
|
|
String(later.tool_call_id).trim() === ""
|
|
) {
|
|
later.tool_call_id = newIdsInOrder[idx];
|
|
}
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return body;
|
|
}
|
|
|
|
// Get tool_call ids from assistant message (OpenAI format: tool_calls, Claude format: tool_use in content)
|
|
export function getToolCallIds(msg: ToolMessage): string[] {
|
|
if (msg.role !== "assistant") return [];
|
|
|
|
const ids: string[] = [];
|
|
|
|
// OpenAI format: tool_calls array
|
|
if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
|
|
for (const tc of msg.tool_calls) {
|
|
if (tc.id) ids.push(String(tc.id));
|
|
}
|
|
}
|
|
|
|
// Claude format: tool_use blocks in content
|
|
if (Array.isArray(msg.content)) {
|
|
for (const block of msg.content as ToolContentBlock[]) {
|
|
if (block.type === "tool_use" && block.id) {
|
|
ids.push(String(block.id));
|
|
}
|
|
}
|
|
}
|
|
|
|
return ids;
|
|
}
|
|
|
|
// Check if user message has tool_result for given ids (OpenAI format: role=tool, Claude format: tool_result in content)
|
|
export function hasToolResults(
|
|
msg: ToolMessage | null | undefined,
|
|
toolCallIds: string[]
|
|
): boolean {
|
|
if (!msg || !toolCallIds.length) return false;
|
|
|
|
// OpenAI format: role = "tool" with tool_call_id
|
|
if (msg.role === "tool" && msg.tool_call_id) {
|
|
return toolCallIds.includes(String(msg.tool_call_id));
|
|
}
|
|
|
|
// Claude format: tool_result blocks in user message content
|
|
if (msg.role === "user" && Array.isArray(msg.content)) {
|
|
for (const block of msg.content as ToolContentBlock[]) {
|
|
if (
|
|
block.type === "tool_result" &&
|
|
block.tool_use_id &&
|
|
toolCallIds.includes(String(block.tool_use_id))
|
|
) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Fix missing tool responses - insert empty tool_result if assistant has tool_use but next message has no tool_result.
|
|
// Inserts in the same shape as the opening assistant message: OpenAI tool_calls → role:"tool";
|
|
// Claude tool_use blocks → role:"user" with tool_result content blocks.
|
|
export function fixMissingToolResponses<T extends ToolCallBody>(body: T): T {
|
|
if (!body.messages || !Array.isArray(body.messages)) return body;
|
|
|
|
const newMessages: ToolMessage[] = [];
|
|
|
|
for (let i = 0; i < body.messages.length; i++) {
|
|
const msg = body.messages[i];
|
|
const nextMsg = body.messages[i + 1];
|
|
|
|
newMessages.push(msg);
|
|
|
|
// Check if this is assistant with tool_calls/tool_use
|
|
const toolCallIds = getToolCallIds(msg);
|
|
if (toolCallIds.length === 0) continue;
|
|
|
|
// Check if next message has tool_result
|
|
if (nextMsg && !hasToolResults(nextMsg, toolCallIds)) {
|
|
const hasOpenAIToolCalls = Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0;
|
|
if (hasOpenAIToolCalls) {
|
|
for (const id of toolCallIds) {
|
|
newMessages.push({
|
|
role: "tool",
|
|
tool_call_id: id,
|
|
content: "",
|
|
});
|
|
}
|
|
} else {
|
|
newMessages.push({
|
|
role: "user",
|
|
content: toolCallIds.map((id) => ({
|
|
type: "tool_result",
|
|
tool_use_id: id,
|
|
content: "",
|
|
})),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
body.messages = newMessages;
|
|
return body;
|
|
}
|
|
|
|
// Strip tool-result carriers whose id has no matching tool call anywhere in the
|
|
// conversation. Mirrors fixMissingToolResponses on the result side: that helper
|
|
// ensures every call has a result; this one ensures every result has a call.
|
|
// Client-side history truncation/compaction can drop the assistant turn that
|
|
// issued a tool call while leaving its stale tool result behind, which strict
|
|
// upstream APIs reject before model execution. Handles both OpenAI-format
|
|
// role:"tool" messages and Claude-format tool_result content blocks. Drops a
|
|
// user message entirely if stripping empties its content array. Returns the
|
|
// same body reference when nothing needs to change (no-op fast path).
|
|
export function stripOrphanedToolResults<T extends ToolCallBody>(body: T): T {
|
|
if (!body.messages || !Array.isArray(body.messages)) return body;
|
|
|
|
const knownCallIds = new Set<string>();
|
|
for (const msg of body.messages) {
|
|
for (const id of getToolCallIds(msg)) {
|
|
knownCallIds.add(id);
|
|
}
|
|
}
|
|
|
|
let changed = false;
|
|
const filteredMessages: ToolMessage[] = [];
|
|
|
|
for (const msg of body.messages) {
|
|
if (msg.role === "tool" && msg.tool_call_id) {
|
|
if (knownCallIds.has(String(msg.tool_call_id))) {
|
|
filteredMessages.push(msg);
|
|
} else {
|
|
changed = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (Array.isArray(msg.content)) {
|
|
const cleanedContent = (msg.content as ToolContentBlock[]).filter((block) => {
|
|
if (block?.type !== "tool_result") return true;
|
|
return typeof block.tool_use_id === "string" && knownCallIds.has(block.tool_use_id);
|
|
});
|
|
|
|
if (cleanedContent.length !== msg.content.length) {
|
|
changed = true;
|
|
if (cleanedContent.length === 0) continue;
|
|
msg.content = cleanedContent;
|
|
}
|
|
}
|
|
|
|
filteredMessages.push(msg);
|
|
}
|
|
|
|
if (!changed) return body;
|
|
body.messages = filteredMessages;
|
|
return body;
|
|
}
|