const DEFAULT_MAX_PLAIN_TEXT_TOOL_PAYLOAD_BYTES = 256_000;

const END_TOOL_REQUEST = "[END_TOOL_REQUEST]";

const HARMONY_CHANNEL_MARKER = "<|channel|>";

const HARMONY_MESSAGE_MARKER = "<|message|>";

const HARMONY_CALL_MARKER = "<|call|>";

type PlainTextToolCallOpening = {

end: number;

name: string;

requiresClosing: boolean;

};

function isToolNameChar(char: string | undefined): boolean {

return Boolean(char && /[A-Za-z0-9_-]/.test(char));

return null;

}

function parseOpening(text: string, start: number): { end: number; name: string } | null {

function parseBracketOpening(text: string, start: number): PlainTextToolCallOpening | null {

if (text[start] !== "[") {

return null;

}

if (afterLineBreak === null) {

return null;

}

return { end: afterLineBreak, name };

return { end: afterLineBreak, name, requiresClosing: true };

}

function parseHarmonyOpening(text: string, start: number): PlainTextToolCallOpening | null {

let cursor = start;

if (text.startsWith(HARMONY_CHANNEL_MARKER, cursor)) {

cursor += HARMONY_CHANNEL_MARKER.length;

}

const channelStart = cursor;

while (/[A-Za-z_]/.test(text[cursor] ?? "")) {

cursor += 1;

}

const channel = text.slice(channelStart, cursor);

if (channel !== "commentary" && channel !== "analysis" && channel !== "final") {

return null;

}

cursor = skipHorizontalWhitespace(text, cursor);

if (!text.startsWith("to=", cursor)) {

return null;

}

cursor += 3;

const nameStart = cursor;

while (isToolNameChar(text[cursor])) {

cursor += 1;

}

if (cursor === nameStart) {

return null;

}

const name = text.slice(nameStart, cursor);

cursor = skipHorizontalWhitespace(text, cursor);

if (!text.startsWith("code", cursor)) {

return null;

}

cursor += 4;

cursor = skipWhitespace(text, cursor);

if (text.startsWith(HARMONY_MESSAGE_MARKER, cursor)) {

cursor = skipWhitespace(text, cursor + HARMONY_MESSAGE_MARKER.length);

}

return { end: cursor, name, requiresClosing: false };

}

function parseOpening(text: string, start: number): PlainTextToolCallOpening | null {

return parseBracketOpening(text, start) ?? parseHarmonyOpening(text, start);

}

function consumeJsonObject(

return null;

}

function parseOptionalHarmonyClosing(text: string, start: number): number {

const cursor = skipWhitespace(text, start);

if (text.startsWith(HARMONY_CALL_MARKER, cursor)) {

return cursor + HARMONY_CALL_MARKER.length;

}

return start;

}

function parsePlainTextToolCallBlockAt(

text: string,

start: number,

if (!payload) {

return null;

}

const end = parseClosing(text, payload.end, opening.name);

if (end === null) {

const closingEnd = opening.requiresClosing

? parseClosing(text, payload.end, opening.name)

: parseOptionalHarmonyClosing(text, payload.end);

if (closingEnd === null) {

return null;

}

return {

arguments: payload.value,

end,

end: closingEnd,

name: opening.name,

raw: text.slice(start, end),

raw: text.slice(start, closingEnd),

start,

};

}

}

export function stripPlainTextToolCallBlocks(text: string): string {

if (!text || !/\[[A-Za-z0-9_-]+\]/.test(text)) {

if (

!text ||

(!/\[[A-Za-z0-9_-]+\]/.test(text) &&

!/(?:^|\n)\s*(?:<\|channel\|>)?(?:commentary|analysis|final)\s+to=/.test(text))

) {

return text;

}

let result = "";

}

result += text.slice(cursor, index);

cursor = block.end;

index = block.end;

const afterBlockLineBreak = consumeLineBreak(text, cursor);

if (afterBlockLineBreak !== null) {

cursor = afterBlockLineBreak;

}

index = cursor;

}

result += text.slice(cursor);

return result;