kiku-agent 1.2.0 → 1.3.0

package/server/agent/textToolProtocol.js

@@ -0,0 +1,190 @@
+export function extractTopLevelJsonObjects(text) {
+  const objects = [];
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') {
+      if (depth > 0) inString = true;
+      continue;
+    }
+    if (ch === '{') {
+      if (depth === 0) start = i;
+      depth++;
+    } else if (ch === '}') {
+      if (depth > 0) {
+        depth--;
+        if (depth === 0 && start >= 0) {
+          objects.push({ raw: text.slice(start, i + 1), start, end: i + 1 });
+          start = -1;
+        }
+      }
+    }
+  }
+
+  const unbalanced = depth > 0 && start >= 0 ? text.slice(start) : null;
+  return { objects, unbalanced };
+}
+
+const JUNK_PARAM_REGEX = /(kiku_vip_keys|kiku_api_keys|api_key|apikey|secret|password|token|credentials)/i;
+
+export function sanitizeToolArguments(toolName, rawArgs = {}, toolsSchema = []) {
+  if (!rawArgs || typeof rawArgs !== 'object' || Array.isArray(rawArgs)) return {};
+  const toolDef = (toolsSchema || []).find(t => (t.function?.name || t.name) === toolName);
+  const properties = toolDef?.function?.parameters?.properties || toolDef?.parameters?.properties || {};
+
+  const cleanArgs = {};
+  for (const [key, value] of Object.entries(rawArgs)) {
+    if (JUNK_PARAM_REGEX.test(key)) continue;
+
+    const schema = properties[key];
+    let val = value;
+    if (schema) {
+      if (schema.type === 'number' || schema.type === 'integer') {
+        if (typeof val === 'string' && /^-?\d+(\.\d+)?$/.test(val.trim())) {
+          val = schema.type === 'integer' ? parseInt(val.trim(), 10) : parseFloat(val.trim());
+        }
+      } else if (schema.type === 'boolean') {
+        if (typeof val === 'string') {
+          if (val.toLowerCase() === 'true' || val === '1') val = true;
+          else if (val.toLowerCase() === 'false' || val === '0') val = false;
+        }
+      } else if (schema.type === 'string') {
+        if (typeof val === 'number' || typeof val === 'boolean') {
+          val = String(val);
+        }
+      }
+
+      if (schema.enum && Array.isArray(schema.enum)) {
+        const strVal = String(val).toLowerCase().trim();
+        const matched = schema.enum.find(e => String(e).toLowerCase() === strVal);
+        if (matched !== undefined) {
+          val = matched;
+        } else if (schema.enum.includes('all')) {
+          val = 'all';
+        }
+      }
+    }
+
+    cleanArgs[key] = val;
+  }
+  return cleanArgs;
+}
+
+/**
+ * Parse text-emitted tool calls (fenced JSON or ReAct "Action:" blocks).
+ * Returns { calls, malformed } — malformed counts blocks that LOOK like tool
+ * calls but could not be parsed, so the caller can feed that back to the model
+ * instead of silently treating the message as the final answer.
+ */
+export function parseTextToolCallsFromContent(content, toolsSchema) {
+  const result = { calls: [], malformed: 0 };
+  if (!content) return result;
+  const allTools = toolsSchema || [];
+  const isValidTool = (name) => allTools.some(t => t.function?.name === name);
+
+  const pushCall = (prefix, toolName, args) => {
+    const cleanArgs = sanitizeToolArguments(toolName, args, allTools);
+    result.calls.push({
+      id: `${prefix}_${Date.now()}_${result.calls.length}`,
+      function: { name: toolName, arguments: JSON.stringify(cleanArgs) }
+    });
+  };
+
+  const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+  for (const match of content.matchAll(fenceRegex)) {
+    const body = match[1];
+    if (!body.includes('{')) continue;
+    const { objects, unbalanced } = extractTopLevelJsonObjects(body);
+    if (unbalanced) result.malformed++;
+    for (const obj of objects) {
+      let parsed = null;
+      try {
+        parsed = JSON.parse(obj.raw);
+      } catch {
+        parsed = null;
+      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        result.malformed++;
+        continue;
+      }
+      const toolName = parsed.action || parsed.tool || parsed.name || parsed.function;
+      if (!toolName) continue;
+      let toolArgs = parsed.action_input ?? parsed.parameters ?? parsed.arguments ?? parsed.args ?? {};
+      if (toolArgs && typeof toolArgs === 'string') {
+        try { toolArgs = JSON.parse(toolArgs); } catch { toolArgs = { query: toolArgs }; }
+      }
+      if (!toolArgs || typeof toolArgs !== 'object' || Array.isArray(toolArgs)) toolArgs = {};
+      if (isValidTool(String(toolName))) {
+        pushCall('call_txt', String(toolName), toolArgs);
+      }
+    }
+  }
+
+  const actionRegex = /Action:\s*([a-zA-Z0-9_]+)\s*\nAction Input:\s*([\s\S]*?)(?=\nAction:|\nObservation:|$)/g;
+  for (const match of content.matchAll(actionRegex)) {
+    const toolName = match[1].trim();
+    const rawInput = match[2].trim();
+    if (!isValidTool(toolName)) continue;
+    if (rawInput.startsWith('{')) {
+      const { objects, unbalanced } = extractTopLevelJsonObjects(rawInput);
+      const candidate = objects.length > 0 ? objects[0].raw : unbalanced;
+      let parsed = null;
+      if (candidate) {
+        try { parsed = JSON.parse(candidate); } catch { parsed = null; }
+      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        result.malformed++;
+        continue;
+      }
+      pushCall('call_act', toolName, parsed);
+    } else {
+      pushCall('call_act', toolName, { query: rawInput });
+    }
+  }
+
+  return result;
+}
+
+export const MALFORMED_TOOL_CALL_FEEDBACK = '[SYSTEM PARSE ERROR] Your previous message contained a tool-call block that could not be parsed (most likely invalid or truncated JSON). Re-emit the tool call using EXACTLY ONE valid format:\n1. Fenced JSON: ```json {"action": "tool_name", "parameters": { ... }} ``` (complete, strictly valid JSON)\n2. ReAct: "Action: tool_name" followed by "Action Input: {valid JSON object}"\nDo not add any text inside the JSON block and make sure all braces are closed.';
+
+export function buildTextToolProtocolDirective(toolsSchema) {
+  const toolNames = (toolsSchema || []).map(t => t.function?.name).filter(Boolean);
+  const sample = toolNames.includes('web_search') ? 'web_search' : (toolNames[0] || 'web_search');
+  return [
+    '=== TEXT TOOL PROTOCOL (ACTIVE — native function calling is unavailable for this model/provider) ===',
+    'You cannot emit native tool_calls. To use a tool, END your reply with EXACTLY ONE tool call in one of these formats:',
+    '',
+    'Option A (fenced JSON):',
+    '```json',
+    `{"action": "${sample}", "parameters": { "query": "example" }}`,
+    '```',
+    '',
+    `Option B (ReAct):\nAction: ${sample}\nAction Input: {"query": "example"}`,
+    '',
+    'Rules:',
+    `- Use ONLY these tool names: ${toolNames.join(', ')}.`,
+    '- The JSON must be strictly valid: no comments, no trailing commas, escape every quote inside string values.',
+    '- Write the complete JSON argument object — every "{" must have its matching "}".',
+    '- Emit the block and stop; the system executes it and returns the results in the next message.',
+    '- When you have enough verified data, reply with the final answer WITHOUT any tool-call block.',
+  ].join('\n');
+}
+
+/** Strip the emitted call blocks from assistant content so they never leak to
+ * the user (the "NO SYSTEM LEAK" rule). */
+export function stripToolCallBlocks(content) {
+  let cleaned = String(content || '');
+  cleaned = cleaned.replace(/```(?:json)?\s*[\s\S]*?```/g, '');
+  cleaned = cleaned.replace(/Action:\s*[a-zA-Z0-9_]+\s*\nAction Input:[\s\S]*?(?=\nAction:|\nObservation:|$)/g, '');
+  return cleaned.trim();
+}

package/server/agent/tokenTracker.js

@@ -0,0 +1,220 @@
+import { EventEmitter } from 'node:events';
+
+export function computePercentile(sortedValues, percentile) {
+  if (!Array.isArray(sortedValues) || sortedValues.length === 0) return null;
+  const sorted = [...sortedValues].sort((a, b) => a - b);
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(percentile * sorted.length) - 1));
+  return sorted[index];
+}
+
+function round(value, digits = 2) {
+  if (value === null || value === undefined || !Number.isFinite(value)) return 0;
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
+
+export class TokenTracker extends EventEmitter {
+  /**
+   * @param {object} options
+   * @param {string} [options.sessionId]
+   * @param {string} [options.modelId]
+   * @param {number} [options.contextLimit]  Maximum context window (0 = unknown).
+   */
+  constructor({ sessionId = null, modelId = 'unknown', contextLimit = 0 } = {}) {
+    super();
+    this.sessionId = sessionId;
+    this.modelId = modelId;
+    this.contextLimit = Number(contextLimit) || 0;
+    this.startTime = null;
+    this.endTime = null;
+    this.segments = [];
+    this.currentSegment = null;
+    this.finished = false;
+  }
+
+ 
+  start({ promptTokens = 0, contextLimit } = {}) {
+    if (contextLimit !== undefined && contextLimit !== null) this.contextLimit = Number(contextLimit) || 0;
+    if (this.startTime === null) this.startTime = Date.now();
+    if (promptTokens > 0 && this.segments.length === 0) {
+      this.pendingInitialPromptTokens = Number(promptTokens);
+    }
+    return this.startTime;
+  }
+
+ 
+  beginSegment(label = null) {
+    this.start();
+    const segment = {
+      index: this.segments.length,
+      label,
+      tStart: Date.now(),
+      tFirst: null,
+      tokenTimestamps: [],
+      promptTokens: null,
+      completionTokens: null,
+    };
+    this.currentSegment = segment;
+    this.emit('segment-start', { index: segment.index, tStart: segment.tStart });
+    return segment;
+  }
+
+ 
+  markFirstToken(segment = this.currentSegment) {
+    if (!segment || segment.tFirst !== null) return;
+    segment.tFirst = Date.now();
+    this.emit('first-token', { index: segment.index, ttft: segment.tFirst - this.startTime });
+  }
+
+ 
+  markToken(segment = this.currentSegment) {
+    if (!segment) return;
+    const now = Date.now();
+    if (segment.tFirst === null) {
+      segment.tFirst = now;
+      this.emit('first-token', { index: segment.index, ttft: now - this.startTime });
+    }
+    segment.tokenTimestamps.push(now);
+    this.emit('token', { index: segment.index, at: now, tokens: segment.tokenTimestamps.length });
+  }
+
+  
+  endSegment({ promptTokens = null, completionTokens = null } = {}, segment = this.currentSegment) {
+    if (!segment) return null;
+    segment.tEnd = Date.now();
+    segment.promptTokens = Number.isFinite(Number(promptTokens)) && Number(promptTokens) > 0
+      ? Number(promptTokens)
+      : null;
+    segment.completionTokens = Number.isFinite(Number(completionTokens)) && Number(completionTokens) > 0
+      ? Number(completionTokens)
+      : segment.tokenTimestamps.length || null;
+    this.segments.push(segment);
+    if (this.currentSegment === segment) this.currentSegment = null;
+    this.emit('segment-end', {
+      index: segment.index,
+      durationMs: segment.tEnd - segment.tStart,
+      completionTokens: segment.completionTokens,
+    });
+    return segment;
+  }
+
+
+  updateUsage({ promptTokens, completionTokens, contextLimit } = {}) {
+    if (contextLimit !== undefined && contextLimit !== null) this.contextLimit = Number(contextLimit) || 0;
+    if (this.segments.length > 0) {
+      const last = this.segments[this.segments.length - 1];
+      if (Number.isFinite(Number(promptTokens)) && Number(promptTokens) > 0) last.promptTokens = Number(promptTokens);
+      if (Number.isFinite(Number(completionTokens)) && Number(completionTokens) > 0) last.completionTokens = Number(completionTokens);
+    }
+  }
+
+  
+  finish({ promptTokens = null, completionTokens = null, contextLimit } = {}) {
+    if (contextLimit !== undefined && contextLimit !== null) this.contextLimit = Number(contextLimit) || 0;
+    if (this.currentSegment && this.currentSegment.tEnd === undefined) {
+      this.endSegment({}, this.currentSegment);
+    }
+    this.endTime = Date.now();
+    this.finished = true;
+    const payload = this.getPayload({ promptTokens, completionTokens });
+    this.emit('complete', payload);
+    return payload;
+  }
+
+ 
+  getPayload({ promptTokens = null, completionTokens = null } = {}) {
+    const segments = this.segments;
+    if (this.startTime === null) return null;
+
+    const endMs = this.endTime ?? Date.now();
+    const totalLatencyMs = Math.max(0, endMs - this.startTime);
+
+    const countedTokens = segments.reduce((sum, s) => sum + s.tokenTimestamps.length, 0);
+    const segmentPromptSum = segments.reduce((sum, s) => sum + (s.promptTokens ?? 0), 0);
+    const segmentCompletionSum = segments.reduce((sum, s) => sum + (s.completionTokens ?? 0), 0);
+
+    const prompt = Number(promptTokens) > 0 ? Number(promptTokens)
+      : segmentPromptSum > 0 ? segmentPromptSum
+        : (this.pendingInitialPromptTokens || 0);
+    const completion = Number(completionTokens) > 0 ? Number(completionTokens)
+      : segmentCompletionSum > 0 ? segmentCompletionSum
+        : countedTokens;
+
+    const totalTokens = prompt + completion;
+
+    const firstSegment = segments[0] || null;
+    const ttft = firstSegment && firstSegment.tFirst !== null
+      ? Math.max(0, firstSegment.tFirst - this.startTime)
+      : null;
+    const prefillDuration = ttft;
+
+    const decodeDuration = segments.reduce((sum, s) => {
+      if (s.tFirst === null || s.tEnd === undefined) return sum;
+      return sum + Math.max(0, s.tEnd - s.tFirst);
+    }, 0);
+
+    const prefillPrompt = firstSegment?.promptTokens ?? prompt;
+    const prefillTps = ttft > 0 && prefillPrompt > 0
+      ? prefillPrompt / (ttft / 1000)
+      : 0;
+    const decodeTps = decodeDuration > 0 && completion > 1
+      ? (completion - 1) / (decodeDuration / 1000)
+      : 0;
+    const e2eTps = totalLatencyMs > 0 && totalTokens > 0
+      ? totalTokens / (totalLatencyMs / 1000)
+      : 0;
+
+    const interTokenDeltas = [];
+    for (const segment of segments) {
+      for (let i = 1; i < segment.tokenTimestamps.length; i++) {
+        interTokenDeltas.push(segment.tokenTimestamps[i] - segment.tokenTimestamps[i - 1]);
+      }
+    }
+    const itlMean = interTokenDeltas.length > 0
+      ? interTokenDeltas.reduce((a, b) => a + b, 0) / interTokenDeltas.length
+      : null;
+    const itlP95 = computePercentile(interTokenDeltas, 0.95);
+
+    const contextLimit = this.contextLimit > 0 ? this.contextLimit : null;
+    const contextUsagePct = contextLimit && contextLimit > 0
+      ? round((totalTokens / contextLimit) * 100, 2)
+      : null;
+
+    return {
+      session_id: this.sessionId,
+      model_id: this.modelId,
+      counts: {
+        prompt_tokens: Math.round(prompt),
+        completion_tokens: Math.round(completion),
+        total_tokens: Math.round(totalTokens),
+        context_limit: contextLimit,
+        remaining_tokens: contextLimit ? Math.max(0, contextLimit - Math.round(totalTokens)) : null,
+      },
+      timing_ms: {
+        start_time: this.startTime,
+        ttft: round(ttft, 1),
+        prefill_duration: round(prefillDuration, 1),
+        decode_duration: round(decodeDuration, 1),
+        total_latency: round(totalLatencyMs, 1),
+      },
+      rates: {
+        prefill_tps: round(prefillTps, 1),
+        decode_tps: round(decodeTps, 1),
+        e2e_tps: round(e2eTps, 1),
+        itl_mean_ms: itlMean === null ? null : round(itlMean, 1),
+        itl_p95_ms: itlP95 === null ? null : round(itlP95, 1),
+      },
+      context_usage_pct: contextUsagePct,
+      stream_segments: segments.length,
+    };
+  }
+
+  reset() {
+    this.startTime = null;
+    this.endTime = null;
+    this.segments = [];
+    this.currentSegment = null;
+    this.finished = false;
+    this.pendingInitialPromptTokens = 0;
+  }
+}