v2.4.0-unsloth-studio-lift: port 3 Unsloth Studio AGPL-3.0 modules
Batch 1 — tool-call-parser.ts: replaces xml-parser.ts with a port of
Unsloth's tool_call_parser.py. Adds balanced-brace JSON scanner,
single-param fast path, hasToolSignal/stripToolMarkup/parseToolCallsFromText
exports, and stream-finalization stripping at all three final-write sites
(error-handler, finalizeCompletion, executeToolPhase). Anthropic <invoke>
shape preserved. 75+12 tests.
Batch 2 — web/html-to-md.ts: parse5 tree-walking HTML-to-Markdown converter
ported from Unsloth's _html_to_md.py. Replaces web_fetch's regex stripHtml
with structured markdown output (headings, links, lists, tables, code blocks,
blockquotes, entity decoding). 29 tests.
Batch 3 — llama-args-validator.ts: port of llama_server_args.py deny-list
validator. Wired into AGENTS.md frontmatter parser — llama_extra_args field
validated at load time, rejects managed flags (model identity, networking,
auth/TLS, server UI). No runtime consumer yet (llama-swap boundary). 76 tests.
All three files carry SPDX-License-Identifier: AGPL-3.0-only headers.
LICENSE flipped to AGPL-3.0-only in prior commit (a938cf1).
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -9,6 +9,7 @@ import * as modelContext from '../model-context.js';
|
||||
import { maybeFlagForCompaction } from './payload.js';
|
||||
import { insertParts, partsFromAssistantMessage } from './parts.js';
|
||||
import type { PartInsert } from './parts.js';
|
||||
import { stripToolMarkup } from './tool-call-parser.js';
|
||||
import type { InferenceContext, StreamResult, TurnArgs } from './turn.js';
|
||||
|
||||
export async function handleAbortOrError(
|
||||
@@ -21,6 +22,7 @@ export async function handleAbortOrError(
|
||||
const isAbort = err instanceof Error && err.name === 'AbortError';
|
||||
const finalStatus = isAbort ? 'cancelled' : 'failed';
|
||||
const errMsg = err instanceof Error ? err.message : String(err);
|
||||
accumulated = stripToolMarkup(accumulated, { final: true });
|
||||
// v1.8.2: persist a structured error metadata blob on genuine failures so
|
||||
// the bubble can render the reason on reload without re-deriving from the
|
||||
// (one-shot) WS error frame. User-initiated abort skips this — there's no
|
||||
@@ -101,7 +103,8 @@ export async function finalizeCompletion(
|
||||
session: Session
|
||||
): Promise<void> {
|
||||
const { sessionId, chatId, assistantMessageId } = args;
|
||||
const { content, finishReason, promptTokens, completionTokens } = result;
|
||||
const content = stripToolMarkup(result.content, { final: true });
|
||||
const { finishReason, promptTokens, completionTokens } = result;
|
||||
|
||||
// v1.11.3: see executeToolPhase for the rationale.
|
||||
const mctx = await modelContext.getModelContext(session.model);
|
||||
|
||||
142
apps/server/src/services/inference/llama-args-validator.ts
Normal file
142
apps/server/src/services/inference/llama-args-validator.ts
Normal file
@@ -0,0 +1,142 @@
|
||||
// SPDX-License-Identifier: AGPL-3.0-only
|
||||
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
|
||||
// Ported from studio/backend/core/inference/llama_server_args.py.
|
||||
// Original: https://github.com/unslothai/unsloth/blob/main/studio/backend/core/inference/llama_server_args.py
|
||||
|
||||
// Each group is the full set of aliases (short + long) for one hard-denied
|
||||
// flag, taken from the llama-server README. Flags NOT in this list pass
|
||||
// through and override auto-set values via llama.cpp's last-wins CLI parsing.
|
||||
const DENYLIST_GROUPS: ReadonlyArray<ReadonlySet<string>> = [
|
||||
// Model identity
|
||||
new Set(['-m', '--model']),
|
||||
new Set(['-mu', '--model-url']),
|
||||
new Set(['-dr', '--docker-repo']),
|
||||
new Set(['-hf', '-hfr', '--hf-repo']),
|
||||
new Set(['-hff', '--hf-file']),
|
||||
new Set(['-hfv', '-hfrv', '--hf-repo-v']),
|
||||
new Set(['-hffv', '--hf-file-v']),
|
||||
new Set(['-hft', '--hf-token']),
|
||||
new Set(['-mm', '--mmproj']),
|
||||
new Set(['-mmu', '--mmproj-url']),
|
||||
// Networking
|
||||
new Set(['--host']),
|
||||
new Set(['--port']),
|
||||
new Set(['--path']),
|
||||
new Set(['--api-prefix']),
|
||||
new Set(['--reuse-port']),
|
||||
// Auth / TLS
|
||||
new Set(['--api-key']),
|
||||
new Set(['--api-key-file']),
|
||||
new Set(['--ssl-key-file']),
|
||||
new Set(['--ssl-cert-file']),
|
||||
// Single-model server / UI
|
||||
new Set(['--webui', '--no-webui']),
|
||||
new Set(['--ui', '--no-ui']),
|
||||
new Set(['--ui-config']),
|
||||
new Set(['--ui-config-file']),
|
||||
new Set(['--ui-mcp-proxy', '--no-ui-mcp-proxy']),
|
||||
new Set(['--models-dir']),
|
||||
new Set(['--models-preset']),
|
||||
new Set(['--models-max']),
|
||||
new Set(['--models-autoload', '--no-models-autoload']),
|
||||
];
|
||||
|
||||
const DENYLIST: ReadonlySet<string> = new Set(
|
||||
DENYLIST_GROUPS.flatMap((g) => [...g]),
|
||||
);
|
||||
|
||||
function flagName(token: string): string | null {
|
||||
if (!token.startsWith('-') || token === '-' || token === '--') return null;
|
||||
if (token.length >= 2 && (token[1]!.match(/\d/) || token[1] === '.')) return null;
|
||||
return token.split('=', 1)[0]!;
|
||||
}
|
||||
|
||||
export function validateExtraArgs(args?: Iterable<string>): string[] {
|
||||
if (!args) return [];
|
||||
const out: string[] = [];
|
||||
for (const raw of args) {
|
||||
const token = String(raw);
|
||||
const flag = flagName(token);
|
||||
if (flag !== null && DENYLIST.has(flag)) {
|
||||
throw new Error(
|
||||
`llama-server flag '${flag}' is managed and cannot be passed as an extra arg`,
|
||||
);
|
||||
}
|
||||
out.push(token);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function isManagedFlag(flag: string): boolean {
|
||||
return DENYLIST.has(flag);
|
||||
}
|
||||
|
||||
// Shadowing flag groups: pass-through flags that shadow first-class settings.
|
||||
const CONTEXT_FLAGS = new Set(['-c', '--ctx-size']);
|
||||
const CACHE_FLAGS = new Set(['-ctk', '--cache-type-k', '-ctv', '--cache-type-v']);
|
||||
const SPEC_FLAGS = new Set([
|
||||
'--spec-default',
|
||||
'--spec-type',
|
||||
'--spec-ngram-size-n',
|
||||
'--spec-ngram-size',
|
||||
'--draft-min',
|
||||
'--draft-max',
|
||||
'--spec-draft-n-max',
|
||||
'--spec-draft-n-min',
|
||||
'--spec-draft-p-min',
|
||||
'--spec-draft-p-split',
|
||||
'--spec-ngram-mod-n-match',
|
||||
'--spec-ngram-mod-n-min',
|
||||
'--spec-ngram-mod-n-max',
|
||||
]);
|
||||
const TEMPLATE_FLAGS = new Set([
|
||||
'--chat-template',
|
||||
'--chat-template-file',
|
||||
'--chat-template-kwargs',
|
||||
'--jinja',
|
||||
'--no-jinja',
|
||||
]);
|
||||
|
||||
const BOOLEAN_SHADOWING_FLAGS = new Set([
|
||||
'--spec-default', '--jinja', '--no-jinja',
|
||||
]);
|
||||
|
||||
export interface StripOptions {
|
||||
stripContext?: boolean;
|
||||
stripCache?: boolean;
|
||||
stripSpec?: boolean;
|
||||
stripTemplate?: boolean;
|
||||
}
|
||||
|
||||
export function stripShadowingFlags(
|
||||
args: Iterable<string>,
|
||||
opts?: StripOptions,
|
||||
): string[] {
|
||||
const shadowing = new Set<string>();
|
||||
if (opts?.stripContext !== false) for (const f of CONTEXT_FLAGS) shadowing.add(f);
|
||||
if (opts?.stripCache !== false) for (const f of CACHE_FLAGS) shadowing.add(f);
|
||||
if (opts?.stripSpec !== false) for (const f of SPEC_FLAGS) shadowing.add(f);
|
||||
if (opts?.stripTemplate !== false) for (const f of TEMPLATE_FLAGS) shadowing.add(f);
|
||||
|
||||
const tokens = [...args].map(String);
|
||||
const out: string[] = [];
|
||||
let i = 0;
|
||||
const n = tokens.length;
|
||||
while (i < n) {
|
||||
const tok = tokens[i]!;
|
||||
const flag = flagName(tok);
|
||||
if (flag === null || !shadowing.has(flag)) {
|
||||
out.push(tok);
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
if (BOOLEAN_SHADOWING_FLAGS.has(flag) || tok.includes('=')) {
|
||||
i++;
|
||||
} else if (i + 1 < n && flagName(tokens[i + 1]!) === null) {
|
||||
i += 2;
|
||||
} else {
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
@@ -1,6 +1,9 @@
|
||||
import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
|
||||
import type { LanguageModel } from 'ai';
|
||||
|
||||
// TODO: When per-agent llama-server flag overrides are added, route them
|
||||
// through validateExtraArgs (./llama-args-validator.ts) first.
|
||||
|
||||
// v1.13.1-A: AI SDK provider against llama-swap. baseURL is threaded from
|
||||
// config.LLAMA_SWAP_URL at call time (not module-load) so tests can stub the
|
||||
// upstream without touching env vars. No apiKey — llama-swap is unauth in our
|
||||
|
||||
@@ -7,9 +7,7 @@ import * as modelContext from '../model-context.js';
|
||||
import { toolJsonSchemas, type ToolJsonSchema } from '../tools.js';
|
||||
import { matchToolGlob } from '../agents.js';
|
||||
import type { OpenAiMessage } from './payload.js';
|
||||
// v1.13.16: extractToolCallBlocks replaces the inline opener-search loop and
|
||||
// recognizes both Qwen <tool_call> and Anthropic <invoke> markup in one pass.
|
||||
import { extractToolCallBlocks } from './xml-parser.js';
|
||||
import { extractToolCallBlocks } from './tool-call-parser.js';
|
||||
import { DB_FLUSH_INTERVAL_MS, type StreamPhaseState } from './types.js';
|
||||
import type {
|
||||
InferenceContext,
|
||||
|
||||
426
apps/server/src/services/inference/tool-call-parser.ts
Normal file
426
apps/server/src/services/inference/tool-call-parser.ts
Normal file
@@ -0,0 +1,426 @@
|
||||
// SPDX-License-Identifier: AGPL-3.0-only
|
||||
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved.
|
||||
// Ported from studio/backend/core/inference/tool_call_parser.py.
|
||||
// Original: https://github.com/unslothai/unsloth/blob/main/studio/backend/core/inference/tool_call_parser.py
|
||||
|
||||
// ── Constants ────────────────────────────────────────────────────────────
|
||||
|
||||
export const XML_TOOL_OPEN = '<tool_call>';
|
||||
export const XML_TOOL_CLOSE = '</tool_call>';
|
||||
export const INVOKE_TOOL_OPEN = '<invoke';
|
||||
export const INVOKE_TOOL_CLOSE = '</invoke>';
|
||||
|
||||
export const TOOL_XML_SIGNALS = [XML_TOOL_OPEN, '<function=', INVOKE_TOOL_OPEN] as const;
|
||||
|
||||
export const TOOL_ERROR_PREFIXES = [
|
||||
'Error',
|
||||
'Search failed',
|
||||
'Execution error',
|
||||
'Blocked:',
|
||||
'Exit code',
|
||||
'Failed to fetch',
|
||||
'Failed to resolve',
|
||||
'No query provided',
|
||||
] as const;
|
||||
|
||||
export const DUPLICATE_CALL_NUDGE =
|
||||
'You already made this exact call. Do not repeat the same tool ' +
|
||||
'call. Try a different approach: fetch a URL from previous ' +
|
||||
'results, use Python to process data you already have, or ' +
|
||||
'provide your final answer now.';
|
||||
|
||||
export const TOOL_ERROR_NUDGE =
|
||||
'\n\nThe tool call encountered an issue. Please try a different ' +
|
||||
'approach or rephrase your request.';
|
||||
|
||||
export const BUDGET_EXHAUSTED_NUDGE =
|
||||
'You have used all available tool calls. Based on everything you ' +
|
||||
'have found so far, provide your final answer now. Do not call ' +
|
||||
'any more tools.';
|
||||
|
||||
// ── Strip patterns ───────────────────────────────────────────────────────
|
||||
|
||||
const TOOL_CLOSED_PATS = [
|
||||
/<tool_call>.*?<\/tool_call>/gs,
|
||||
/<function=\w+>.*?<\/function>/gs,
|
||||
/<invoke\s[^>]*>.*?<\/invoke>/gs,
|
||||
];
|
||||
|
||||
const TOOL_ALL_PATS = [
|
||||
...TOOL_CLOSED_PATS,
|
||||
/<tool_call>.*$/gs,
|
||||
/<function=\w+>.*$/gs,
|
||||
/<invoke\s[^>]*>.*$/gs,
|
||||
];
|
||||
|
||||
// ── Strip / signal ───────────────────────────────────────────────────────
|
||||
|
||||
export function stripToolMarkup(text: string, opts?: { final?: boolean }): string {
|
||||
const pats = opts?.final ? TOOL_ALL_PATS : TOOL_CLOSED_PATS;
|
||||
for (const pat of pats) {
|
||||
text = text.replace(pat, '');
|
||||
}
|
||||
return opts?.final ? text.trim() : text;
|
||||
}
|
||||
|
||||
export function hasToolSignal(text: string): boolean {
|
||||
return TOOL_XML_SIGNALS.some((s) => text.includes(s));
|
||||
}
|
||||
|
||||
// ── parseToolCallsFromText (Unsloth port + Anthropic extension) ──────────
|
||||
|
||||
export interface OpenAiToolCall {
|
||||
id: string;
|
||||
type: 'function';
|
||||
function: { name: string; arguments: string };
|
||||
}
|
||||
|
||||
const TC_JSON_START_RE = /<tool_call>\s*\{/g;
|
||||
const TC_FUNC_START_RE = /<function=(\w+)>\s*/g;
|
||||
const TC_END_TAG_RE = /<\/tool_call>/;
|
||||
const TC_FUNC_CLOSE_RE = /\s*<\/function>\s*$/;
|
||||
const TC_PARAM_START_RE = /<parameter=(\w+)>\s*/g;
|
||||
const TC_PARAM_CLOSE_RE = /\s*<\/parameter>\s*$/;
|
||||
|
||||
const TC_INVOKE_START_RE = /<invoke\s+name\s*=\s*(?:"([^"]*)"|'([^']*)')\s*>/g;
|
||||
const TC_INVOKE_CLOSE_RE = /\s*<\/invoke>\s*$/;
|
||||
const TC_INVOKE_PARAM_RE = /<parameter\s+name\s*=\s*(?:"([^"]*)"|'([^']*)')\s*>/g;
|
||||
const TC_INVOKE_PARAM_CLOSE_RE = /\s*<\/parameter>\s*$/;
|
||||
|
||||
function scanBalancedBraces(content: string, start: number): number {
|
||||
let depth = 0;
|
||||
let i = start;
|
||||
let inString = false;
|
||||
while (i < content.length) {
|
||||
const ch = content[i]!;
|
||||
if (inString) {
|
||||
if (ch === '\\' && i + 1 < content.length) {
|
||||
i += 2;
|
||||
continue;
|
||||
}
|
||||
if (ch === '"') inString = false;
|
||||
} else if (ch === '"') {
|
||||
inString = true;
|
||||
} else if (ch === '{') {
|
||||
depth++;
|
||||
} else if (ch === '}') {
|
||||
depth--;
|
||||
if (depth === 0) return i;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
export function parseToolCallsFromText(
|
||||
content: string,
|
||||
opts?: { idOffset?: number },
|
||||
): OpenAiToolCall[] {
|
||||
const toolCalls: OpenAiToolCall[] = [];
|
||||
const idOffset = opts?.idOffset ?? 0;
|
||||
|
||||
// Pattern 1: <tool_call>{json}</tool_call> -- balanced-brace JSON scanner.
|
||||
// Skips braces inside JSON strings so nested objects parse correctly.
|
||||
TC_JSON_START_RE.lastIndex = 0;
|
||||
let m: RegExpExecArray | null;
|
||||
while ((m = TC_JSON_START_RE.exec(content)) !== null) {
|
||||
const braceStart = m.index + m[0].length - 1;
|
||||
const braceEnd = scanBalancedBraces(content, braceStart);
|
||||
if (braceEnd === -1) continue;
|
||||
const jsonStr = content.slice(braceStart, braceEnd + 1);
|
||||
try {
|
||||
const obj = JSON.parse(jsonStr) as Record<string, unknown>;
|
||||
const name = typeof obj.name === 'string' ? obj.name : '';
|
||||
let args: string;
|
||||
const rawArgs = obj.arguments ?? {};
|
||||
if (typeof rawArgs === 'string') {
|
||||
args = rawArgs;
|
||||
} else {
|
||||
args = JSON.stringify(rawArgs);
|
||||
}
|
||||
toolCalls.push({
|
||||
id: `call_${idOffset + toolCalls.length}`,
|
||||
type: 'function',
|
||||
function: { name, arguments: args },
|
||||
});
|
||||
} catch {
|
||||
// malformed JSON -- skip
|
||||
}
|
||||
}
|
||||
|
||||
// Pattern 2: <function=name><parameter=key>value -- closing tags optional.
|
||||
// Body boundary uses </tool_call> or next <function= (not </function>,
|
||||
// because code parameter values can contain that literal).
|
||||
if (toolCalls.length === 0) {
|
||||
TC_FUNC_START_RE.lastIndex = 0;
|
||||
const funcStarts: Array<{ match: RegExpExecArray; name: string }> = [];
|
||||
while ((m = TC_FUNC_START_RE.exec(content)) !== null) {
|
||||
funcStarts.push({ match: m, name: m[1]! });
|
||||
}
|
||||
for (let idx = 0; idx < funcStarts.length; idx++) {
|
||||
const { match: fm, name: funcName } = funcStarts[idx]!;
|
||||
const bodyStart = fm.index + fm[0].length;
|
||||
const nextFunc = idx + 1 < funcStarts.length
|
||||
? funcStarts[idx + 1]!.match.index
|
||||
: content.length;
|
||||
const endTag = TC_END_TAG_RE.exec(content.slice(bodyStart));
|
||||
let bodyEnd = endTag ? bodyStart + endTag.index : content.length;
|
||||
bodyEnd = Math.min(bodyEnd, nextFunc);
|
||||
let body = content.slice(bodyStart, bodyEnd);
|
||||
body = body.replace(TC_FUNC_CLOSE_RE, '');
|
||||
|
||||
const args: Record<string, string> = {};
|
||||
TC_PARAM_START_RE.lastIndex = 0;
|
||||
const paramStarts: Array<{ match: RegExpExecArray; name: string }> = [];
|
||||
let pm: RegExpExecArray | null;
|
||||
while ((pm = TC_PARAM_START_RE.exec(body)) !== null) {
|
||||
paramStarts.push({ match: pm, name: pm[1]! });
|
||||
}
|
||||
if (paramStarts.length === 1) {
|
||||
// Single param: take everything to body end so embedded
|
||||
// </parameter> in code strings is preserved.
|
||||
const p = paramStarts[0]!;
|
||||
let val = body.slice(p.match.index + p.match[0].length);
|
||||
val = val.replace(TC_PARAM_CLOSE_RE, '');
|
||||
args[p.name] = val.trim();
|
||||
} else {
|
||||
for (let pidx = 0; pidx < paramStarts.length; pidx++) {
|
||||
const p = paramStarts[pidx]!;
|
||||
const valStart = p.match.index + p.match[0].length;
|
||||
const nextParam = pidx + 1 < paramStarts.length
|
||||
? paramStarts[pidx + 1]!.match.index
|
||||
: body.length;
|
||||
let val = body.slice(valStart, nextParam);
|
||||
val = val.replace(TC_PARAM_CLOSE_RE, '');
|
||||
args[p.name] = val.trim();
|
||||
}
|
||||
}
|
||||
|
||||
toolCalls.push({
|
||||
id: `call_${idOffset + toolCalls.length}`,
|
||||
type: 'function',
|
||||
function: { name: funcName, arguments: JSON.stringify(args) },
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Pattern 3: <invoke name="..."><parameter name="...">value -- Anthropic
|
||||
// shape that qwen3.6 drifts to from Claude Code documentation residue.
|
||||
// Closing tags optional; same single-param fast path as pattern 2.
|
||||
if (toolCalls.length === 0) {
|
||||
TC_INVOKE_START_RE.lastIndex = 0;
|
||||
const invokeStarts: Array<{ match: RegExpExecArray; name: string }> = [];
|
||||
while ((m = TC_INVOKE_START_RE.exec(content)) !== null) {
|
||||
const name = (m[1] ?? m[2] ?? '').trim();
|
||||
if (name) invokeStarts.push({ match: m, name });
|
||||
}
|
||||
for (let idx = 0; idx < invokeStarts.length; idx++) {
|
||||
const { match: im, name: invokeName } = invokeStarts[idx]!;
|
||||
const bodyStart = im.index + im[0].length;
|
||||
const nextInvoke = idx + 1 < invokeStarts.length
|
||||
? invokeStarts[idx + 1]!.match.index
|
||||
: content.length;
|
||||
const closeTag = content.slice(bodyStart).match(/<\/invoke>/);
|
||||
let bodyEnd = closeTag ? bodyStart + (closeTag.index ?? 0) : content.length;
|
||||
bodyEnd = Math.min(bodyEnd, nextInvoke);
|
||||
let body = content.slice(bodyStart, bodyEnd);
|
||||
body = body.replace(TC_INVOKE_CLOSE_RE, '');
|
||||
|
||||
const args: Record<string, string> = {};
|
||||
TC_INVOKE_PARAM_RE.lastIndex = 0;
|
||||
const paramStarts: Array<{ match: RegExpExecArray; name: string }> = [];
|
||||
let pm: RegExpExecArray | null;
|
||||
while ((pm = TC_INVOKE_PARAM_RE.exec(body)) !== null) {
|
||||
const pname = (pm[1] ?? pm[2] ?? '').trim();
|
||||
if (pname) paramStarts.push({ match: pm, name: pname });
|
||||
}
|
||||
if (paramStarts.length === 1) {
|
||||
const p = paramStarts[0]!;
|
||||
let val = body.slice(p.match.index + p.match[0].length);
|
||||
val = val.replace(TC_INVOKE_PARAM_CLOSE_RE, '');
|
||||
args[p.name] = val.trim();
|
||||
} else {
|
||||
for (let pidx = 0; pidx < paramStarts.length; pidx++) {
|
||||
const p = paramStarts[pidx]!;
|
||||
const valStart = p.match.index + p.match[0].length;
|
||||
const nextParam = pidx + 1 < paramStarts.length
|
||||
? paramStarts[pidx + 1]!.match.index
|
||||
: body.length;
|
||||
let val = body.slice(valStart, nextParam);
|
||||
val = val.replace(TC_INVOKE_PARAM_CLOSE_RE, '');
|
||||
args[p.name] = val.trim();
|
||||
}
|
||||
}
|
||||
|
||||
toolCalls.push({
|
||||
id: `call_${idOffset + toolCalls.length}`,
|
||||
type: 'function',
|
||||
function: { name: invokeName, arguments: JSON.stringify(args) },
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return toolCalls;
|
||||
}
|
||||
|
||||
// ── BooCode streaming helpers ────────────────────────────────────────────
|
||||
|
||||
export interface ParsedCall {
|
||||
name: string;
|
||||
args: Record<string, unknown>;
|
||||
}
|
||||
|
||||
const PLACEHOLDER_LITERALS = new Set(['...', 'placeholder', '<path>', '<file>']);
|
||||
const ANGLE_BRACKET_SENTINEL_RE = /^<[^>]+>$/;
|
||||
|
||||
export function isPlaceholderArgValue(value: unknown): boolean {
|
||||
if (typeof value !== 'string') return false;
|
||||
const trimmed = value.trim();
|
||||
if (trimmed === '') return true;
|
||||
if (PLACEHOLDER_LITERALS.has(trimmed)) return true;
|
||||
if (ANGLE_BRACKET_SENTINEL_RE.test(trimmed)) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
function hasPlaceholderArgs(args: Record<string, unknown>): boolean {
|
||||
for (const value of Object.values(args)) {
|
||||
if (isPlaceholderArgValue(value)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function logRejectedPlaceholder(parsed: ParsedCall): void {
|
||||
console.debug(
|
||||
{ toolName: parsed.name, args: parsed.args },
|
||||
'rejected placeholder tool call at parse time',
|
||||
);
|
||||
}
|
||||
|
||||
const QWEN_FUNCTION_RE = /<function\s*=\s*([^>\s]+)\s*>/;
|
||||
const QWEN_PARAM_RE = /<parameter\s*=\s*([^>\s]+)\s*>([\s\S]*?)<\/parameter>/g;
|
||||
|
||||
export function parseXmlToolCall(block: string): ParsedCall | null {
|
||||
const nameMatch = block.match(QWEN_FUNCTION_RE);
|
||||
if (!nameMatch || !nameMatch[1]) return null;
|
||||
const name = nameMatch[1].trim();
|
||||
if (!name) return null;
|
||||
const args: Record<string, unknown> = {};
|
||||
for (const m of block.matchAll(QWEN_PARAM_RE)) {
|
||||
const key = (m[1] ?? '').trim();
|
||||
if (!key) continue;
|
||||
const raw = (m[2] ?? '').trim();
|
||||
try {
|
||||
args[key] = JSON.parse(raw);
|
||||
} catch {
|
||||
args[key] = raw;
|
||||
}
|
||||
}
|
||||
return { name, args };
|
||||
}
|
||||
|
||||
const INVOKE_NAME_RE =
|
||||
/<invoke\s+name\s*=\s*("([^"]*)"|'([^']*)')\s*>/;
|
||||
const INVOKE_PARAM_RE =
|
||||
/<parameter\s+name\s*=\s*("([^"]*)"|'([^']*)')\s*>([\s\S]*?)<\/parameter>/g;
|
||||
|
||||
export function parseInvokeToolCall(block: string): ParsedCall | null {
|
||||
const nameMatch = block.match(INVOKE_NAME_RE);
|
||||
if (!nameMatch) return null;
|
||||
const name = (nameMatch[2] ?? nameMatch[3] ?? '').trim();
|
||||
if (!name) return null;
|
||||
const args: Record<string, unknown> = {};
|
||||
for (const m of block.matchAll(INVOKE_PARAM_RE)) {
|
||||
const key = ((m[2] ?? m[3] ?? '') as string).trim();
|
||||
if (!key) continue;
|
||||
const raw = (m[4] ?? '').trim();
|
||||
try {
|
||||
args[key] = JSON.parse(raw);
|
||||
} catch {
|
||||
args[key] = raw;
|
||||
}
|
||||
}
|
||||
return { name, args };
|
||||
}
|
||||
|
||||
const ALL_OPENERS = [XML_TOOL_OPEN, INVOKE_TOOL_OPEN] as const;
|
||||
|
||||
export function partialXmlOpenerStart(s: string): number {
|
||||
let earliest = -1;
|
||||
for (const op of ALL_OPENERS) {
|
||||
const idx = s.indexOf(op);
|
||||
if (idx === -1) continue;
|
||||
if (earliest === -1 || idx < earliest) earliest = idx;
|
||||
}
|
||||
if (earliest !== -1) return earliest;
|
||||
const lastLt = s.lastIndexOf('<');
|
||||
if (lastLt === -1) return -1;
|
||||
const suffix = s.slice(lastLt);
|
||||
for (const op of ALL_OPENERS) {
|
||||
if (op.startsWith(suffix) && suffix.length < op.length) return lastLt;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
export interface ToolCallExtraction {
|
||||
flushed: string;
|
||||
calls: ParsedCall[];
|
||||
remaining: string;
|
||||
}
|
||||
|
||||
interface OpenerSpec {
|
||||
open: string;
|
||||
close: string;
|
||||
parse: (block: string) => ParsedCall | null;
|
||||
}
|
||||
|
||||
const OPENER_SPECS: ReadonlyArray<OpenerSpec> = [
|
||||
{ open: XML_TOOL_OPEN, close: XML_TOOL_CLOSE, parse: parseXmlToolCall },
|
||||
{ open: INVOKE_TOOL_OPEN, close: INVOKE_TOOL_CLOSE, parse: parseInvokeToolCall },
|
||||
];
|
||||
|
||||
export function extractToolCallBlocks(buffer: string): ToolCallExtraction {
|
||||
let flushed = '';
|
||||
const calls: ParsedCall[] = [];
|
||||
let pos = 0;
|
||||
|
||||
while (pos < buffer.length) {
|
||||
let next: { spec: OpenerSpec; openIdx: number; closeIdx: number } | null = null;
|
||||
for (const spec of OPENER_SPECS) {
|
||||
const openIdx = buffer.indexOf(spec.open, pos);
|
||||
if (openIdx === -1) continue;
|
||||
const closeIdx = buffer.indexOf(spec.close, openIdx);
|
||||
if (closeIdx === -1) continue;
|
||||
if (next === null || openIdx < next.openIdx) {
|
||||
next = { spec, openIdx, closeIdx };
|
||||
}
|
||||
}
|
||||
if (next === null) break;
|
||||
|
||||
if (next.openIdx > pos) {
|
||||
flushed += buffer.slice(pos, next.openIdx);
|
||||
}
|
||||
const blockEnd = next.closeIdx + next.spec.close.length;
|
||||
const block = buffer.slice(next.openIdx, blockEnd);
|
||||
const parsed = next.spec.parse(block);
|
||||
if (parsed) {
|
||||
if (hasPlaceholderArgs(parsed.args)) {
|
||||
logRejectedPlaceholder(parsed);
|
||||
flushed += block;
|
||||
} else {
|
||||
calls.push(parsed);
|
||||
}
|
||||
}
|
||||
pos = blockEnd;
|
||||
}
|
||||
|
||||
const tail = buffer.slice(pos);
|
||||
const partialIdx = partialXmlOpenerStart(tail);
|
||||
if (partialIdx === -1) {
|
||||
flushed += tail;
|
||||
return { flushed, calls, remaining: '' };
|
||||
}
|
||||
if (partialIdx > 0) {
|
||||
flushed += tail.slice(0, partialIdx);
|
||||
}
|
||||
return { flushed, calls, remaining: tail.slice(partialIdx) };
|
||||
}
|
||||
@@ -14,6 +14,7 @@ import { formatUnknownToolError } from './tool-suggestions.js';
|
||||
// Resolves the grant root before pausing the loop so the user is never
|
||||
// prompted about paths we couldn't grant anyway (e.g. /etc/passwd).
|
||||
import { resolveGrantRoot } from '../grant_resolver.js';
|
||||
import { stripToolMarkup } from './tool-call-parser.js';
|
||||
import type {
|
||||
InferenceContext,
|
||||
StreamResult,
|
||||
@@ -100,7 +101,8 @@ export async function executeToolPhase(
|
||||
projectRoot: string
|
||||
): Promise<ToolPhaseResult> {
|
||||
const { sessionId, chatId, assistantMessageId } = args;
|
||||
const { content, toolCalls, promptTokens, completionTokens } = result;
|
||||
const content = stripToolMarkup(result.content, { final: true });
|
||||
const { toolCalls, promptTokens, completionTokens } = result;
|
||||
|
||||
// v1.11.3: ctx_max comes from llama-swap /upstream/<model>/props, not the
|
||||
// streaming completion (which doesn't emit n_ctx). getModelContext caches
|
||||
|
||||
@@ -1,204 +0,0 @@
|
||||
// v1.10.5: XML-tag tool-call fallback. Some models emit
|
||||
// <tool_call><function=foo><parameter=key>value</parameter></function></tool_call>
|
||||
// in plain content instead of using the OpenAI tool_calls JSON channel.
|
||||
// The streaming loop in stream-phase.ts extracts these blocks via these helpers.
|
||||
//
|
||||
// v1.13.16: also recognize Anthropic <invoke name="..."><parameter name="...">
|
||||
// markup. qwen3.6-35b-a3b-mxfp4 drifts to this format when prompted as an
|
||||
// "Architect"-style agent because Claude Code documentation in its
|
||||
// pre-training data uses this shape. Both formats route through the same
|
||||
// synthetic ToolCall path with shared xml_call_${idx} IDs; downstream
|
||||
// dispatch handles unknown tool names with a richer error (see
|
||||
// tool-suggestions.ts + tool-phase.ts).
|
||||
|
||||
export const XML_TOOL_OPEN = '<tool_call>';
|
||||
export const XML_TOOL_CLOSE = '</tool_call>';
|
||||
|
||||
// v1.13.16: Anthropic <invoke> opener is matched by prefix (not the full
|
||||
// `<invoke ...>` tag) because attributes follow. Closer is the literal tag.
|
||||
export const INVOKE_TOOL_OPEN = '<invoke';
|
||||
export const INVOKE_TOOL_CLOSE = '</invoke>';
|
||||
|
||||
export interface ParsedCall {
|
||||
name: string;
|
||||
args: Record<string, unknown>;
|
||||
}
|
||||
|
||||
const PLACEHOLDER_LITERALS = new Set(['...', 'placeholder', '<path>', '<file>']);
|
||||
const ANGLE_BRACKET_SENTINEL_RE = /^<[^>]+>$/;
|
||||
|
||||
/** True when a string arg looks like a model placeholder, not a real path/value. */
|
||||
export function isPlaceholderArgValue(value: unknown): boolean {
|
||||
if (typeof value !== 'string') return false;
|
||||
const trimmed = value.trim();
|
||||
if (trimmed === '') return true;
|
||||
if (PLACEHOLDER_LITERALS.has(trimmed)) return true;
|
||||
if (ANGLE_BRACKET_SENTINEL_RE.test(trimmed)) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
function hasPlaceholderArgs(args: Record<string, unknown>): boolean {
|
||||
for (const value of Object.values(args)) {
|
||||
if (isPlaceholderArgValue(value)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
function logRejectedPlaceholder(parsed: ParsedCall): void {
|
||||
// Pure helper — no Fastify logger here (stream-phase.ts stays unchanged).
|
||||
console.debug(
|
||||
{ toolName: parsed.name, args: parsed.args },
|
||||
'rejected placeholder tool call at parse time',
|
||||
);
|
||||
}
|
||||
|
||||
// v1.10.5: Qwen-flavor parser. Tightened in v1.13.16 to tolerate whitespace
|
||||
// around `=` (e.g. `<function = view_file>`). Name capture is non-whitespace,
|
||||
// non-`>` so a stray space doesn't get absorbed into the function name.
|
||||
const QWEN_FUNCTION_RE = /<function\s*=\s*([^>\s]+)\s*>/;
|
||||
const QWEN_PARAM_RE = /<parameter\s*=\s*([^>\s]+)\s*>([\s\S]*?)<\/parameter>/g;
|
||||
|
||||
export function parseXmlToolCall(block: string): ParsedCall | null {
|
||||
const nameMatch = block.match(QWEN_FUNCTION_RE);
|
||||
if (!nameMatch || !nameMatch[1]) return null;
|
||||
const name = nameMatch[1].trim();
|
||||
if (!name) return null;
|
||||
const args: Record<string, unknown> = {};
|
||||
for (const m of block.matchAll(QWEN_PARAM_RE)) {
|
||||
const key = (m[1] ?? '').trim();
|
||||
if (!key) continue;
|
||||
const raw = (m[2] ?? '').trim();
|
||||
try {
|
||||
args[key] = JSON.parse(raw);
|
||||
} catch {
|
||||
args[key] = raw;
|
||||
}
|
||||
}
|
||||
return { name, args };
|
||||
}
|
||||
|
||||
// v1.13.16: Anthropic-flavor parser. Same JSON-parse-with-string-fallback
|
||||
// shape as parseXmlToolCall so the dispatch layer doesn't need to care which
|
||||
// flavor produced the call.
|
||||
const INVOKE_NAME_RE =
|
||||
/<invoke\s+name\s*=\s*("([^"]*)"|'([^']*)')\s*>/;
|
||||
const INVOKE_PARAM_RE =
|
||||
/<parameter\s+name\s*=\s*("([^"]*)"|'([^']*)')\s*>([\s\S]*?)<\/parameter>/g;
|
||||
|
||||
export function parseInvokeToolCall(block: string): ParsedCall | null {
|
||||
const nameMatch = block.match(INVOKE_NAME_RE);
|
||||
if (!nameMatch) return null;
|
||||
const name = (nameMatch[2] ?? nameMatch[3] ?? '').trim();
|
||||
if (!name) return null;
|
||||
const args: Record<string, unknown> = {};
|
||||
for (const m of block.matchAll(INVOKE_PARAM_RE)) {
|
||||
const key = ((m[2] ?? m[3] ?? '') as string).trim();
|
||||
if (!key) continue;
|
||||
const raw = (m[4] ?? '').trim();
|
||||
try {
|
||||
args[key] = JSON.parse(raw);
|
||||
} catch {
|
||||
args[key] = raw;
|
||||
}
|
||||
}
|
||||
return { name, args };
|
||||
}
|
||||
|
||||
// Locate the first character that begins (or completely contains) an
|
||||
// unfinished opener (either flavor) in `s`. Returns -1 when `s` can be
|
||||
// flushed to the client in full without risking a partial tag leak.
|
||||
// Case 1: a full opener (`<tool_call>` or `<invoke`) with no matching
|
||||
// closer — caller must keep everything from that index forward
|
||||
// until the next chunk arrives with the closer.
|
||||
// Case 2: `s` ends with a strict prefix of either opener (e.g. `<tool_c`
|
||||
// or `<invo`). Caller must keep just that suffix in the buffer.
|
||||
// Note: case 1 assumes the calling loop already extracted every complete
|
||||
// block before reaching this check.
|
||||
const ALL_OPENERS = [XML_TOOL_OPEN, INVOKE_TOOL_OPEN] as const;
|
||||
|
||||
export function partialXmlOpenerStart(s: string): number {
|
||||
let earliest = -1;
|
||||
for (const op of ALL_OPENERS) {
|
||||
const idx = s.indexOf(op);
|
||||
if (idx === -1) continue;
|
||||
if (earliest === -1 || idx < earliest) earliest = idx;
|
||||
}
|
||||
if (earliest !== -1) return earliest;
|
||||
const lastLt = s.lastIndexOf('<');
|
||||
if (lastLt === -1) return -1;
|
||||
const suffix = s.slice(lastLt);
|
||||
for (const op of ALL_OPENERS) {
|
||||
if (op.startsWith(suffix) && suffix.length < op.length) return lastLt;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// v1.13.16: unified extraction. Replaces the inline loop that used to live
|
||||
// in stream-phase.ts. Pure function — returns the visible text to flush,
|
||||
// the parsed tool-call payloads in source order, and the buffer remainder
|
||||
// to retain for the next streaming chunk. Parse failures are silently
|
||||
// dropped (matches the pre-v1.13.16 behavior — leaking partial XML to the
|
||||
// chat looks worse than swallowing a bad block).
|
||||
export interface ToolCallExtraction {
|
||||
flushed: string;
|
||||
calls: ParsedCall[];
|
||||
remaining: string;
|
||||
}
|
||||
|
||||
interface OpenerSpec {
|
||||
open: string;
|
||||
close: string;
|
||||
parse: (block: string) => ParsedCall | null;
|
||||
}
|
||||
|
||||
const OPENER_SPECS: ReadonlyArray<OpenerSpec> = [
|
||||
{ open: XML_TOOL_OPEN, close: XML_TOOL_CLOSE, parse: parseXmlToolCall },
|
||||
{ open: INVOKE_TOOL_OPEN, close: INVOKE_TOOL_CLOSE, parse: parseInvokeToolCall },
|
||||
];
|
||||
|
||||
export function extractToolCallBlocks(buffer: string): ToolCallExtraction {
|
||||
let flushed = '';
|
||||
const calls: ParsedCall[] = [];
|
||||
let pos = 0;
|
||||
|
||||
while (pos < buffer.length) {
|
||||
let next: { spec: OpenerSpec; openIdx: number; closeIdx: number } | null = null;
|
||||
for (const spec of OPENER_SPECS) {
|
||||
const openIdx = buffer.indexOf(spec.open, pos);
|
||||
if (openIdx === -1) continue;
|
||||
const closeIdx = buffer.indexOf(spec.close, openIdx);
|
||||
if (closeIdx === -1) continue;
|
||||
if (next === null || openIdx < next.openIdx) {
|
||||
next = { spec, openIdx, closeIdx };
|
||||
}
|
||||
}
|
||||
if (next === null) break;
|
||||
|
||||
if (next.openIdx > pos) {
|
||||
flushed += buffer.slice(pos, next.openIdx);
|
||||
}
|
||||
const blockEnd = next.closeIdx + next.spec.close.length;
|
||||
const block = buffer.slice(next.openIdx, blockEnd);
|
||||
const parsed = next.spec.parse(block);
|
||||
if (parsed) {
|
||||
if (hasPlaceholderArgs(parsed.args)) {
|
||||
logRejectedPlaceholder(parsed);
|
||||
flushed += block;
|
||||
} else {
|
||||
calls.push(parsed);
|
||||
}
|
||||
}
|
||||
pos = blockEnd;
|
||||
}
|
||||
|
||||
const tail = buffer.slice(pos);
|
||||
const partialIdx = partialXmlOpenerStart(tail);
|
||||
if (partialIdx === -1) {
|
||||
flushed += tail;
|
||||
return { flushed, calls, remaining: '' };
|
||||
}
|
||||
if (partialIdx > 0) {
|
||||
flushed += tail.slice(0, partialIdx);
|
||||
}
|
||||
return { flushed, calls, remaining: tail.slice(partialIdx) };
|
||||
}
|
||||
Reference in New Issue
Block a user