@robota-sdk/agent-provider 3.0.0-beta.64

package/src/gemma/pseudo-tool-call-tag-parser.ts

@@ -0,0 +1,153 @@
+import type {
+  IGemmaConsumedPseudoBlock,
+  IGemmaConsumedPseudoToolTag,
+  IGemmaParsedPseudoTag,
+  IGemmaPseudoProjectionOptions,
+  TGemmaJsonValue,
+} from './pseudo-tool-call-types';
+
+const XML_START_MARKER = '<';
+
+export function createGemmaPseudoStartMarkers(toolNames: readonly string[]): string[] {
+  void toolNames;
+  return [XML_START_MARKER];
+}
+
+export function findNextGemmaPseudoStartMarker(
+  text: string,
+  cursor: number,
+  markers: readonly string[],
+): number {
+  void markers;
+  return text.indexOf(XML_START_MARKER, cursor);
+}
+
+export function longestGemmaPseudoStartPrefixSuffixLength(
+  text: string,
+  markers: readonly string[],
+): number {
+  void markers;
+  return text.endsWith(XML_START_MARKER) ? XML_START_MARKER.length : 0;
+}
+
+export function parseGemmaPseudoTag(
+  text: string,
+  start: number,
+): IGemmaParsedPseudoTag | undefined {
+  const tagEnd = text.indexOf('>', start + 1);
+  if (tagEnd === -1) {
+    return undefined;
+  }
+
+  const rawOpenTag = text.slice(start, tagEnd + 1);
+  const tagMatch = rawOpenTag.match(/^<\s*([A-Za-z][\w:-]*)([\s/>][\s\S]*?|)>$/);
+  if (!tagMatch) {
+    return undefined;
+  }
+
+  const tagName = tagMatch[1] ?? '';
+  return {
+    tagName,
+    normalizedName: tagName.toLowerCase(),
+    rawOpenTag,
+    attributes: parseAttributes(tagMatch[2] ?? ''),
+    openEnd: tagEnd + 1,
+    selfClosing: /\/\s*>$/.test(rawOpenTag),
+  };
+}
+
+export function consumeGemmaPseudoControlBlock(
+  text: string,
+  tag: IGemmaParsedPseudoTag,
+  options: IGemmaPseudoProjectionOptions,
+): IGemmaConsumedPseudoBlock {
+  if (tag.selfClosing) {
+    return {
+      innerText: '',
+      end: tag.openEnd,
+      complete: true,
+    };
+  }
+
+  const closeStart = indexOfClosingTag(text, tag.tagName, tag.openEnd);
+  if (closeStart === -1) {
+    return {
+      innerText: text.slice(tag.openEnd),
+      end: options.final ? text.length : tag.openEnd - tag.rawOpenTag.length,
+      complete: false,
+    };
+  }
+
+  const closingTagEnd = text.indexOf('>', closeStart);
+  return {
+    innerText: text.slice(tag.openEnd, closeStart),
+    end: closingTagEnd === -1 ? text.length : closingTagEnd + 1,
+    complete: true,
+  };
+}
+
+export function consumeGemmaPseudoToolTag(
+  text: string,
+  tag: IGemmaParsedPseudoTag,
+): IGemmaConsumedPseudoToolTag {
+  if (tag.selfClosing) {
+    return { rawText: tag.rawOpenTag, end: tag.openEnd };
+  }
+
+  const closeStart = indexOfClosingTag(text, tag.tagName, tag.openEnd);
+  if (closeStart === -1) {
+    return { rawText: tag.rawOpenTag, end: tag.openEnd };
+  }
+
+  const closingTagEnd = text.indexOf('>', closeStart);
+  const end = closingTagEnd === -1 ? text.length : closingTagEnd + 1;
+  return { rawText: text.slice(tag.openEnd - tag.rawOpenTag.length, end), end };
+}
+
+export function findGemmaDeclaredToolName(
+  tagName: string,
+  toolNames: readonly string[],
+): string | undefined {
+  const normalizedTagName = normalizeToolName(tagName);
+  return toolNames.find((toolName) => normalizeToolName(toolName) === normalizedTagName);
+}
+
+function parseAttributes(attributeText: string): Record<string, TGemmaJsonValue> {
+  const attributes: Record<string, TGemmaJsonValue> = {};
+  const pattern = /([A-Za-z_][\w:-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+  let match = pattern.exec(attributeText);
+  while (match) {
+    const key = match[1] ?? '';
+    const rawValue = match[2] ?? match[3] ?? '';
+    attributes[key] = parseAttributeValue(decodeXmlEntities(rawValue));
+    match = pattern.exec(attributeText);
+  }
+  return attributes;
+}
+
+function parseAttributeValue(value: string): TGemmaJsonValue {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+
+function decodeXmlEntities(value: string): string {
+  return value
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&');
+}
+
+function indexOfClosingTag(text: string, tagName: string, cursor: number): number {
+  return text.toLowerCase().indexOf(`</${tagName.toLowerCase()}>`, cursor);
+}
+
+function normalizeToolName(value: string): string {
+  return value.replace(/[^a-z0-9]/gi, '').toLowerCase();
+}

package/src/gemma/pseudo-tool-call-types.ts

@@ -0,0 +1,31 @@
+export type TGemmaJsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | TGemmaJsonValue[]
+  | { [key: string]: TGemmaJsonValue };
+
+export interface IGemmaPseudoProjectionOptions {
+  final: boolean;
+}
+
+export interface IGemmaParsedPseudoTag {
+  tagName: string;
+  normalizedName: string;
+  rawOpenTag: string;
+  attributes: Record<string, TGemmaJsonValue>;
+  openEnd: number;
+  selfClosing: boolean;
+}
+
+export interface IGemmaConsumedPseudoBlock {
+  innerText: string;
+  end: number;
+  complete: boolean;
+}
+
+export interface IGemmaConsumedPseudoToolTag {
+  rawText: string;
+  end: number;
+}

package/src/gemma/reasoning-projector.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { GemmaReasoningProjector, projectGemmaReasoningText } from './index';
+
+describe('Gemma reasoning projection', () => {
+  it('removes complete thought channel blocks from full text', () => {
+    const result = projectGemmaReasoningText(
+      'Hello <|channel>thought\nhidden reasoning<channel|>world',
+    );
+
+    expect(result.visibleText).toBe('Hello world');
+    expect(result.removedReasoning).toBe(true);
+    expect(result.rawText).toContain('hidden reasoning');
+  });
+
+  it('removes malformed empty thought markers emitted by local templates', () => {
+    const result = projectGemmaReasoningText('<|channel>\n<channel|>thought\nFinal answer');
+
+    expect(result.visibleText).toBe('Final answer');
+    expect(result.removedReasoning).toBe(true);
+  });
+
+  it('handles reasoning markers split across streamed deltas', () => {
+    const projector = new GemmaReasoningProjector();
+
+    expect(projector.project('<|cha')).toBe('');
+    expect(projector.project('nnel>thought\nhidden')).toBe('');
+    expect(projector.project(' reasoning<channel|>Visible')).toBe('Visible');
+    expect(projector.flush()).toBe('');
+    expect(projector.rawText).toContain('hidden reasoning');
+    expect(projector.removedReasoning).toBe(true);
+  });
+
+  it('removes captured local channel markers split across background streamed deltas', () => {
+    const projector = new GemmaReasoningProjector();
+    const deltas = ['<|channel>', 's', '\n', '<channel|>', '으로'];
+
+    const visibleText =
+      deltas.map((delta) => projector.project(delta)).join('') + projector.flush();
+
+    expect(visibleText).toBe('으로');
+    expect(projector.rawText).toBe('<|channel>s\n<channel|>으로');
+    expect(projector.removedReasoning).toBe(true);
+  });
+
+  it('preserves ordinary text that is not inside channel markers', () => {
+    const projector = new GemmaReasoningProjector();
+
+    expect(projector.project('A thought about code')).toBe('A thought about code');
+    expect(projector.flush()).toBe('');
+    expect(projector.removedReasoning).toBe(false);
+  });
+});

package/src/gemma/reasoning-projector.ts

@@ -0,0 +1,144 @@
+const START_MARKER = '<|channel>';
+const END_MARKER = '<channel|>';
+const THOUGHT_LABEL = 'thought';
+
+export interface IGemmaReasoningProjection {
+  rawText: string;
+  visibleText: string;
+  removedReasoning: boolean;
+}
+
+interface IProjectionOptions {
+  final: boolean;
+}
+
+interface IProjectionState {
+  visibleParts: string[];
+  removedReasoning: boolean;
+}
+
+export function projectGemmaReasoningText(rawText: string): IGemmaReasoningProjection {
+  const result = projectText(rawText, { final: true });
+  return {
+    rawText,
+    visibleText: result.visibleParts.join(''),
+    removedReasoning: result.removedReasoning,
+  };
+}
+
+export class GemmaReasoningProjector {
+  private buffer = '';
+  private emittedVisibleText = '';
+  private hasRemovedReasoning = false;
+
+  get rawText(): string {
+    return this.buffer;
+  }
+
+  get removedReasoning(): boolean {
+    return this.hasRemovedReasoning;
+  }
+
+  project(delta: string): string {
+    if (delta.length === 0) {
+      return '';
+    }
+
+    this.buffer += delta;
+    return this.projectVisibleText({ final: false });
+  }
+
+  flush(): string {
+    return this.projectVisibleText({ final: true });
+  }
+
+  private projectVisibleText(options: IProjectionOptions): string {
+    const result = projectText(this.buffer, options);
+    this.hasRemovedReasoning = this.hasRemovedReasoning || result.removedReasoning;
+
+    const nextVisibleText = result.visibleParts.join('');
+    const delta = nextVisibleText.slice(this.emittedVisibleText.length);
+    this.emittedVisibleText = nextVisibleText;
+    return delta;
+  }
+}
+
+function projectText(rawText: string, options: IProjectionOptions): IProjectionState {
+  const state: IProjectionState = {
+    visibleParts: [],
+    removedReasoning: false,
+  };
+
+  let cursor = 0;
+  while (cursor < rawText.length) {
+    const nextMarker = rawText.indexOf(START_MARKER, cursor);
+    if (nextMarker === -1) {
+      appendVisibleTail(state, rawText.slice(cursor), options);
+      break;
+    }
+
+    appendVisibleTail(state, rawText.slice(cursor, nextMarker), options);
+    const afterStart = nextMarker + START_MARKER.length;
+    const markerEnd = rawText.indexOf(END_MARKER, afterStart);
+
+    if (markerEnd === -1) {
+      if (options.final) {
+        state.removedReasoning = true;
+      }
+      break;
+    }
+
+    state.removedReasoning = true;
+    cursor = consumeChannelBlock(rawText, afterStart, markerEnd);
+  }
+
+  return state;
+}
+
+function appendVisibleTail(
+  state: IProjectionState,
+  tail: string,
+  options: IProjectionOptions,
+): void {
+  if (tail.length === 0) {
+    return;
+  }
+
+  if (options.final) {
+    state.visibleParts.push(tail);
+    return;
+  }
+
+  const heldLength = longestStartMarkerPrefixSuffixLength(tail);
+  state.visibleParts.push(tail.slice(0, tail.length - heldLength));
+}
+
+function consumeChannelBlock(rawText: string, afterStart: number, markerEnd: number): number {
+  const channelText = rawText.slice(afterStart, markerEnd);
+  let cursor = markerEnd + END_MARKER.length;
+
+  if (channelText.trim().length === 0) {
+    const followingThoughtLabel = rawText.slice(cursor).match(/^thought(?:\r?\n)*/);
+    if (followingThoughtLabel) {
+      cursor += followingThoughtLabel[0].length;
+    }
+    return cursor;
+  }
+
+  const channelLabel = channelText.split(/\r?\n/, 1)[0]?.trim();
+  if (channelLabel === THOUGHT_LABEL) {
+    return cursor;
+  }
+
+  return cursor;
+}
+
+function longestStartMarkerPrefixSuffixLength(text: string): number {
+  const maxLength = Math.min(text.length, START_MARKER.length - 1);
+  for (let length = maxLength; length > 0; length -= 1) {
+    if (START_MARKER.startsWith(text.slice(text.length - length))) {
+      return length;
+    }
+  }
+  return 0;
+}

package/src/gemma/streaming-projection.ts

@@ -0,0 +1,79 @@
+import type OpenAI from 'openai';
+import { isAssistantMessage } from '@robota-sdk/agent-core';
+import type { ILogger, IToolSchema, TUniversalMessage } from '@robota-sdk/agent-core';
+import { OpenAICompatibleResponseParser } from '../shared/openai-compatible/index.js';
+import type { IOpenAICompatibleToolCallTextProjector } from '../shared/openai-compatible/index.js';
+import { createStreamTextMessage, createStreamToolCallMessage } from './message-factory';
+import { GemmaReasoningProjector } from './reasoning-projector';
+import { createGemmaToolCallProjector } from './tool-call-projector';
+
+export interface IGemmaStreamProjectionState {
+  reasoningProjector: GemmaReasoningProjector;
+  responseParser: OpenAICompatibleResponseParser;
+  toolCallProjector?: IOpenAICompatibleToolCallTextProjector;
+}
+
+export function createGemmaStreamProjectionState(
+  logger: ILogger,
+  tools: readonly IToolSchema[] | undefined,
+): IGemmaStreamProjectionState {
+  return {
+    reasoningProjector: new GemmaReasoningProjector(),
+    responseParser: new OpenAICompatibleResponseParser({ logger }),
+    ...(tools && { toolCallProjector: createGemmaToolCallProjector(tools) }),
+  };
+}
+
+export function projectGemmaStreamChunk(
+  chunk: OpenAI.Chat.ChatCompletionChunk,
+  state: IGemmaStreamProjectionState,
+): TUniversalMessage[] {
+  const choice = chunk.choices?.[0];
+  if (!choice) {
+    return [];
+  }
+
+  const nativeToolCallMessage = state.responseParser.parseStreamingChunk(chunk);
+  if (nativeToolCallMessage && isAssistantMessage(nativeToolCallMessage)) {
+    if (nativeToolCallMessage.toolCalls?.length) {
+      return [nativeToolCallMessage];
+    }
+  }
+
+  return projectGemmaTextDelta(choice.delta.content || '', choice.finish_reason, state);
+}
+
+export function flushGemmaStreamProjection(
+  state: IGemmaStreamProjectionState,
+): TUniversalMessage[] {
+  const messages = projectGemmaTextDelta('', null, state, true);
+  const flushedContent = state.reasoningProjector.flush();
+  if (flushedContent.length > 0) {
+    messages.push(createStreamTextMessage(flushedContent, null));
+  }
+  return messages;
+}
+
+function projectGemmaTextDelta(
+  rawContent: string,
+  finishReason: OpenAI.Chat.ChatCompletionChunk.Choice['finish_reason'],
+  state: IGemmaStreamProjectionState,
+  flushToolProjector = false,
+): TUniversalMessage[] {
+  const toolProjection = flushToolProjector
+    ? state.toolCallProjector?.flush()
+    : state.toolCallProjector?.project(rawContent);
+  const messages: TUniversalMessage[] = [];
+
+  if (toolProjection?.toolCalls.length) {
+    messages.push(createStreamToolCallMessage(toolProjection.toolCalls, finishReason));
+  }
+
+  const contentAfterToolProjection = toolProjection?.visibleText ?? rawContent;
+  const visibleContent = state.reasoningProjector.project(contentAfterToolProjection);
+  if (visibleContent.length > 0) {
+    messages.push(createStreamTextMessage(visibleContent, finishReason));
+  }
+
+  return messages;
+}

package/src/gemma/tool-call-argument-parser.ts

@@ -0,0 +1,126 @@
+const STRING_DELIMITER = '<|"|>';
+
+export interface IGemmaArgumentObject {
+  [key: string]: TGemmaArgumentValue;
+}
+
+export type TGemmaArgumentValue =
+  | string
+  | number
+  | boolean
+  | null
+  | IGemmaArgumentObject
+  | TGemmaArgumentValue[];
+
+export class GemmaArgumentParser {
+  private cursor = 0;
+
+  constructor(private readonly source: string) {}
+
+  parse(): IGemmaArgumentObject | undefined {
+    const value = this.parseObject();
+    this.skipWhitespace();
+    if (this.cursor !== this.source.length) {
+      return undefined;
+    }
+    return value;
+  }
+
+  private parseObject(): IGemmaArgumentObject | undefined {
+    if (!this.consume('{')) return undefined;
+    const result: IGemmaArgumentObject = {};
+    this.skipWhitespace();
+    if (this.consume('}')) return result;
+
+    while (this.cursor < this.source.length) {
+      const key = this.parseKey();
+      if (!key || !this.consume(':')) return undefined;
+      const value = this.parseValue();
+      if (value === undefined) return undefined;
+      result[key] = value;
+      this.skipWhitespace();
+      if (this.consume('}')) return result;
+      if (!this.consume(',')) return undefined;
+    }
+    return undefined;
+  }
+
+  private parseArray(): TGemmaArgumentValue[] | undefined {
+    if (!this.consume('[')) return undefined;
+    const result: TGemmaArgumentValue[] = [];
+    this.skipWhitespace();
+    if (this.consume(']')) return result;
+
+    while (this.cursor < this.source.length) {
+      const value = this.parseValue();
+      if (value === undefined) return undefined;
+      result.push(value);
+      this.skipWhitespace();
+      if (this.consume(']')) return result;
+      if (!this.consume(',')) return undefined;
+    }
+    return undefined;
+  }
+
+  private parseValue(): TGemmaArgumentValue | undefined {
+    this.skipWhitespace();
+    if (this.source.startsWith(STRING_DELIMITER, this.cursor)) return this.parseString();
+    if (this.source.startsWith('{', this.cursor)) return this.parseObject();
+    if (this.source.startsWith('[', this.cursor)) return this.parseArray();
+    if (this.consumeLiteral('true')) return true;
+    if (this.consumeLiteral('false')) return false;
+    if (this.consumeLiteral('null')) return null;
+    return this.parseNumber();
+  }
+
+  private parseKey(): string | undefined {
+    this.skipWhitespace();
+    if (this.source.startsWith(STRING_DELIMITER, this.cursor)) return this.parseString();
+    const match = /^[A-Za-z_][A-Za-z0-9_-]*/.exec(this.source.slice(this.cursor));
+    if (!match) return undefined;
+    this.cursor += match[0].length;
+    this.skipWhitespace();
+    return match[0];
+  }
+
+  private parseString(): string | undefined {
+    if (!this.consume(STRING_DELIMITER)) return undefined;
+    const end = this.source.indexOf(STRING_DELIMITER, this.cursor);
+    if (end === -1) return undefined;
+    const value = this.source.slice(this.cursor, end);
+    this.cursor = end + STRING_DELIMITER.length;
+    this.skipWhitespace();
+    return value;
+  }
+
+  private parseNumber(): number | undefined {
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(
+      this.source.slice(this.cursor),
+    );
+    if (!match) return undefined;
+    this.cursor += match[0].length;
+    this.skipWhitespace();
+    return Number(match[0]);
+  }
+
+  private consume(expected: string): boolean {
+    this.skipWhitespace();
+    if (!this.source.startsWith(expected, this.cursor)) return false;
+    this.cursor += expected.length;
+    this.skipWhitespace();
+    return true;
+  }
+
+  private consumeLiteral(expected: string): boolean {
+    if (!this.source.startsWith(expected, this.cursor)) return false;
+    this.cursor += expected.length;
+    this.skipWhitespace();
+    return true;
+  }
+
+  private skipWhitespace(): void {
+    while (/\s/.test(this.source[this.cursor] ?? '')) {
+      this.cursor += 1;
+    }
+  }
+}