lynkr 9.5.0 → 9.6.0

package/src/agents/decomposition/planner.js

@@ -0,0 +1,223 @@
+/**
+ * Decomposition planner (Phase 2).
+ *
+ * Turns a complex task into a small subtask DAG using a single model call
+ * (plan-and-solve style — plan generated in one shot). Output is validated:
+ * ids unique, dependencies reference real ids, no cycles, subtask count capped.
+ * If anything fails to parse/validate the planner returns null and the caller
+ * falls back to a monolithic solve.
+ */
+
+const { callModel, extractText } = require("./model-call");
+const logger = require("../../logger");
+
+// Agent types the dispatcher knows how to spawn. Planner is steered toward
+// these; unknown types are coerced to general-purpose at dispatch time.
+const KNOWN_AGENT_TYPES = [
+  "Explore",
+  "Plan",
+  "general-purpose",
+  "Test",
+  "Debug",
+  "Fix",
+  "Refactor",
+  "Documentation",
+];
+
+function buildPlannerPrompt(task, maxSubtasks) {
+  return `You are a task-decomposition planner. Break the task below into the SMALLEST set of focused subtasks that can be solved with isolated context. Fewer is better — do NOT over-split. If the task is not genuinely divisible, return a single subtask.
+
+Rules:
+- At most ${maxSubtasks} subtasks.
+- Each subtask must be independently solvable given only its prompt plus the results of the subtasks it depends on.
+- Mark dependencies via "dependsOn" (array of subtask ids). Independent subtasks (empty dependsOn) will run in parallel.
+- Prefer assigning each subtask an agent type from: ${KNOWN_AGENT_TYPES.join(", ")}.
+- Keep each subtask prompt self-contained and specific.
+
+Respond with ONLY a JSON object, no prose, in exactly this shape:
+{
+  "strategy": "one short sentence on how you split it",
+  "subtasks": [
+    { "id": "s1", "agentType": "Explore", "prompt": "...", "dependsOn": [] }
+  ]
+}
+
+TASK:
+${task}`;
+}
+
+/**
+ * Extract the first balanced JSON object from a string (handles models that
+ * wrap JSON in prose or ```json fences).
+ */
+function extractJsonObject(text) {
+  if (!text) return null;
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = fenced ? fenced[1] : text;
+
+  const start = candidate.indexOf("{");
+  if (start === -1) return null;
+
+  let depth = 0;
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < candidate.length; i++) {
+    const ch = candidate[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escape = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        const slice = candidate.slice(start, i + 1);
+        try {
+          return JSON.parse(slice);
+        } catch {
+          return null;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Validate and normalise a parsed plan. Returns a clean plan or null.
+ */
+function validatePlan(parsed, maxSubtasks) {
+  if (!parsed || !Array.isArray(parsed.subtasks) || parsed.subtasks.length === 0) {
+    return null;
+  }
+
+  const subtasks = [];
+  const seenIds = new Set();
+
+  for (let i = 0; i < parsed.subtasks.length && subtasks.length < maxSubtasks; i++) {
+    const st = parsed.subtasks[i];
+    if (!st || typeof st.prompt !== "string" || st.prompt.trim().length === 0) {
+      return null; // malformed subtask → reject whole plan, fall back
+    }
+    const id = typeof st.id === "string" && st.id.trim() ? st.id.trim() : `s${i + 1}`;
+    if (seenIds.has(id)) return null; // duplicate ids
+    seenIds.add(id);
+
+    const agentType = KNOWN_AGENT_TYPES.includes(st.agentType)
+      ? st.agentType
+      : "general-purpose";
+
+    const dependsOn = Array.isArray(st.dependsOn)
+      ? st.dependsOn.filter((d) => typeof d === "string")
+      : [];
+
+    subtasks.push({ id, agentType, prompt: st.prompt.trim(), dependsOn });
+  }
+
+  // Dependencies must reference real ids and contain no cycles.
+  for (const st of subtasks) {
+    for (const dep of st.dependsOn) {
+      if (!seenIds.has(dep)) return null; // dangling dependency
+    }
+  }
+  if (hasCycle(subtasks)) return null;
+
+  return {
+    strategy: typeof parsed.strategy === "string" ? parsed.strategy : "",
+    subtasks,
+  };
+}
+
+/**
+ * Cycle detection via DFS colouring.
+ */
+function hasCycle(subtasks) {
+  const byId = new Map(subtasks.map((s) => [s.id, s]));
+  const state = new Map(); // id → 0 unvisited, 1 visiting, 2 done
+
+  function visit(id) {
+    const cur = state.get(id) || 0;
+    if (cur === 1) return true; // back-edge → cycle
+    if (cur === 2) return false;
+    state.set(id, 1);
+    const node = byId.get(id);
+    for (const dep of node?.dependsOn || []) {
+      if (visit(dep)) return true;
+    }
+    state.set(id, 2);
+    return false;
+  }
+
+  for (const s of subtasks) {
+    if (visit(s.id)) return true;
+  }
+  return false;
+}
+
+/**
+ * Generate a validated plan for a task.
+ * @param {Object} params
+ * @param {string} params.task
+ * @param {string} [params.model="sonnet"] - planning needs reasoning; use a capable model
+ * @param {number} [params.maxSubtasks=6]
+ * @param {Function} [params.invoke] - injectable model invoker (for tests)
+ * @returns {Promise<{strategy:string, subtasks:Array, usage:Object}|null>}
+ */
+async function generatePlan({ task, model = "sonnet", maxSubtasks = 6, invoke } = {}) {
+  if (!task || typeof task !== "string") return null;
+
+  let responseJson;
+  try {
+    responseJson = await callModel({
+      messages: [{ role: "user", content: buildPlannerPrompt(task, maxSubtasks) }],
+      model,
+      maxTokens: 1500,
+      temperature: 0.1,
+      invoke,
+    });
+  } catch (err) {
+    logger.warn({ err: err.message }, "[Decomposition] Planner model call failed");
+    return null;
+  }
+
+  const text = extractText(responseJson);
+  const parsed = extractJsonObject(text);
+  const plan = validatePlan(parsed, maxSubtasks);
+
+  if (!plan) {
+    logger.warn(
+      { preview: text.slice(0, 200) },
+      "[Decomposition] Plan failed validation — will fall back to monolithic"
+    );
+    return null;
+  }
+
+  plan.usage = {
+    inputTokens: responseJson?.usage?.input_tokens || 0,
+    outputTokens: responseJson?.usage?.output_tokens || 0,
+  };
+
+  logger.info(
+    { subtasks: plan.subtasks.length, strategy: plan.strategy },
+    "[Decomposition] Plan generated"
+  );
+  return plan;
+}
+
+module.exports = {
+  generatePlan,
+  validatePlan,
+  extractJsonObject,
+  hasCycle,
+  buildPlannerPrompt,
+  KNOWN_AGENT_TYPES,
+};

package/src/agents/decomposition/synthesizer.js

@@ -0,0 +1,89 @@
+/**
+ * Result synthesizer (Phase 4).
+ *
+ * Combines the (compressed) results of all subtasks into one coherent final
+ * answer to the original task. Single model call. If synthesis fails, the
+ * caller falls back to concatenating the subtask results.
+ */
+
+const { callModel, extractText } = require("./model-call");
+const logger = require("../../logger");
+
+const MAX_RESULT_CHARS = 4000;
+
+function buildSynthesisPrompt(task, subtaskResults) {
+  const blocks = subtaskResults
+    .map((r) => {
+      const status = r.success ? "OK" : `FAILED (${r.error})`;
+      const body = r.success
+        ? truncate(r.result, MAX_RESULT_CHARS)
+        : "(no result)";
+      return `### Subtask ${r.id} [${r.agentType}] — ${status}\n${body}`;
+    })
+    .join("\n\n");
+
+  return `You are synthesizing the results of several subtasks into one final answer for the original request. Integrate the findings into a single coherent response. Resolve overlaps, note any subtask that failed, and do not invent results that no subtask produced.
+
+ORIGINAL TASK:
+${task}
+
+SUBTASK RESULTS:
+${blocks}
+
+Write the final answer now.`;
+}
+
+function truncate(text, max) {
+  if (typeof text !== "string") return String(text ?? "");
+  return text.length <= max ? text : text.slice(0, max) + "\n…[truncated]";
+}
+
+/**
+ * Concatenation fallback used when the synthesis model call fails.
+ */
+function concatFallback(subtaskResults) {
+  return subtaskResults
+    .filter((r) => r.success && r.result)
+    .map((r) => `## ${r.id} (${r.agentType})\n${r.result}`)
+    .join("\n\n");
+}
+
+/**
+ * @param {Object} params
+ * @param {string} params.task
+ * @param {Array} params.subtaskResults - from dispatcher
+ * @param {string} [params.model="sonnet"]
+ * @param {Function} [params.invoke]
+ * @returns {Promise<{text:string, fallback:boolean, usage:Object}>}
+ */
+async function synthesize({ task, subtaskResults, model = "sonnet", invoke } = {}) {
+  const anySuccess = subtaskResults.some((r) => r.success);
+  if (!anySuccess) {
+    return { text: "All subtasks failed; no result could be produced.", fallback: true, usage: {} };
+  }
+
+  try {
+    const responseJson = await callModel({
+      messages: [{ role: "user", content: buildSynthesisPrompt(task, subtaskResults) }],
+      model,
+      maxTokens: 4096,
+      temperature: 0.3,
+      invoke,
+    });
+    const text = extractText(responseJson);
+    if (!text) throw new Error("Empty synthesis");
+    return {
+      text,
+      fallback: false,
+      usage: {
+        inputTokens: responseJson?.usage?.input_tokens || 0,
+        outputTokens: responseJson?.usage?.output_tokens || 0,
+      },
+    };
+  } catch (err) {
+    logger.warn({ err: err.message }, "[Decomposition] Synthesis failed — concatenating results");
+    return { text: concatFallback(subtaskResults), fallback: true, usage: {} };
+  }
+}
+
+module.exports = { synthesize, buildSynthesisPrompt, concatFallback };

package/src/agents/decomposition/telemetry.js

@@ -0,0 +1,55 @@
+/**
+ * Decomposition telemetry + shadow mode (Phase 6).
+ *
+ * Appends one JSON line per decomposition decision to
+ * data/decomposition-decisions.jsonl so the net token effect can be audited.
+ * Because the research is clear that decomposition can COST more than it saves,
+ * a shadow mode (TASK_DECOMPOSITION_SHADOW=true) runs the gate + records what it
+ * WOULD have done without actually decomposing — so savings can be validated on
+ * real traffic before enabling for real.
+ */
+
+const fs = require("fs");
+const path = require("path");
+const logger = require("../../logger");
+
+const LOG_PATH = path.join(__dirname, "../../../data/decomposition-decisions.jsonl");
+
+function estimateTokens(text) {
+  if (typeof text !== "string") return 0;
+  return Math.ceil(text.length / 4);
+}
+
+/**
+ * Rough net-savings estimate.
+ * monolithic ≈ what one big context would have cost (estimated input tokens).
+ * decomposed ≈ planning + Σ(subagent in+out) + synthesis.
+ * Positive `savedTokens` = decomposition was cheaper.
+ */
+function estimateSavings({ monolithicTokens, planUsage, dispatchStats, synthUsage }) {
+  const decomposed =
+    (planUsage?.inputTokens || 0) +
+    (planUsage?.outputTokens || 0) +
+    (dispatchStats?.inputTokens || 0) +
+    (dispatchStats?.outputTokens || 0) +
+    (synthUsage?.inputTokens || 0) +
+    (synthUsage?.outputTokens || 0);
+  return {
+    monolithicTokens: monolithicTokens || 0,
+    decomposedTokens: decomposed,
+    savedTokens: (monolithicTokens || 0) - decomposed,
+  };
+}
+
+function record(entry) {
+  const line = { timestamp: Date.now(), ...entry };
+  try {
+    fs.mkdirSync(path.dirname(LOG_PATH), { recursive: true });
+    fs.appendFileSync(LOG_PATH, JSON.stringify(line) + "\n");
+  } catch (err) {
+    logger.debug({ err: err.message }, "[Decomposition] Telemetry append failed");
+  }
+  return line;
+}
+
+module.exports = { record, estimateSavings, estimateTokens, LOG_PATH };

package/src/clients/databricks.js

@@ -1104,6 +1104,64 @@ async function invokeLMStudio(body) {
   return performJsonRequest(endpoint, { headers, body: lmstudioBody }, "LM Studio");
 }
 
+/**
+ * Flatten an Anthropic-style content value into a plain string for the
+ * Bedrock Converse API.
+ *
+ * Prompt-cache injection (injectPromptCaching) rewrites string `system`
+ * fields and message `content` into arrays of `{ type, text, cache_control }`
+ * blocks. The Converse API has no `cache_control` concept and expects
+ * `system: [{ text: "<string>" }]` and message content blocks shaped as
+ * `{ text: "<string>" }`. Passing the injected array through unchanged would
+ * either drop the cache markers silently or nest an array under `text`,
+ * producing a ValidationException.
+ *
+ * @param {string|Array|undefined} value - String or array of content blocks
+ * @returns {string} Concatenated plain text
+ */
+function flattenContentToText(value) {
+  if (value == null) return "";
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    return value
+      .map(block => {
+        if (typeof block === "string") return block;
+        if (block && typeof block === "object") return block.text || block.content || "";
+        return "";
+      })
+      .join("");
+  }
+  return String(value);
+}
+
+/**
+ * Normalize a request body for the Bedrock Converse API.
+ *
+ * Strips `cache_control` markers and flattens any array-shaped `system` /
+ * message `content` (left behind by prompt-cache injection) back into the
+ * plain strings the Converse API expects. Returns a shallow copy with a
+ * normalized `messages` array; the original body is not mutated.
+ *
+ * @param {Object} body - Anthropic-format request body
+ * @returns {Object} Body safe for Converse request construction
+ */
+function normalizeBodyForConverse(body) {
+  const normalized = { ...body };
+
+  if (normalized.system !== undefined) {
+    normalized.system = flattenContentToText(normalized.system);
+  }
+
+  if (Array.isArray(normalized.messages)) {
+    normalized.messages = normalized.messages.map(msg => ({
+      ...msg,
+      content: flattenContentToText(msg.content),
+    }));
+  }
+
+  return normalized;
+}
+
 async function invokeBedrock(body) {
   // 1. Validate Bearer token
   if (!config.bedrock?.apiKey) {
@@ -1130,7 +1188,10 @@ async function invokeBedrock(body) {
     }, "=== INJECTING STANDARD TOOLS (Bedrock) ===");
   }
 
-  const bedrockBody = { ...body, tools: toolsToSend };
+  // Normalize away cache_control / array shapes that prompt-cache injection
+  // may have applied: the Converse API expects plain-string system and
+  // message content, not Anthropic cache_control blocks.
+  const bedrockBody = { ...normalizeBodyForConverse(body), tools: toolsToSend };
 
   // 4. Detect model family and convert format
   const modelId = body._tierModel || config.bedrock.modelId;
@@ -2124,6 +2185,13 @@ async function invokeModel(body, options = {}) {
   const { injectPromptCaching } = require('./prompt-cache-injection');
   injectPromptCaching(body, initialProvider);
 
+  // Always-on markdown formatting guard. Stops formatting-weak backends
+  // (Moonshot/Kimi, Ollama, etc.) from emitting mangled ASCII box-drawing
+  // "diagrams". Keyed off the routing-resolved provider/model; skipped for
+  // Claude-family backends which already format cleanly.
+  const { injectFormatGuard } = require('../context/output-format-guard');
+  injectFormatGuard(body, { provider: initialProvider, model: tierSelectedModel });
+
   // Build routing decision object for response headers
   const routingDecision = {
     provider: initialProvider,
@@ -2323,6 +2391,71 @@ async function invokeModel(body, options = {}) {
     healthTracker.recordFailure(initialProvider, err, err.status);
     getLatencyTracker().record(initialProvider, routingDecision?.model, failLatency);
 
+    // Tier-aware escalate-then-demote fallback (TIER_FALLBACK_ENABLED).
+    // On failure, try a MORE capable tier first (climb toward REASONING); only
+    // if every higher tier is unavailable do we fall downward to SIMPLE/local.
+    // Runs before the flat global fallback below and is never silent.
+    if (config.tierFallback?.enabled && !options._tierFallbackInner && routingDecision.tier) {
+      const { getFallbackChain } = require("../routing/tier-fallback");
+      const chain = getFallbackChain(routingDecision.tier);
+      for (const cand of chain) {
+        try {
+          logger.warn({
+            fromTier: routingDecision.tier,
+            fromProvider: initialProvider,
+            toTier: cand.tier,
+            toProvider: cand.provider,
+            toModel: cand.model,
+            direction: cand.direction,
+          }, "[TierFallback] Primary tier failed — attempting tier fallback");
+
+          const attempt = await invokeModel(
+            { ...body, _tierModel: cand.model },
+            {
+              forceProvider: cand.provider,
+              _tierFallbackInner: true,
+              disableFallback: true,
+              _cascadeInner: true,
+              workspace,
+              tenantPolicy,
+            }
+          );
+
+          metricsCollector.recordFallbackAttempt(initialProvider, cand.provider, "tier_fallback");
+          logger.warn({
+            servedTier: cand.tier,
+            servedProvider: cand.provider,
+            fromTier: routingDecision.tier,
+            direction: cand.direction,
+          }, "[TierFallback] Served by tier fallback");
+
+          return {
+            ...attempt,
+            actualProvider: cand.provider,
+            routingDecision: {
+              ...routingDecision,
+              provider: cand.provider,
+              model: cand.model,
+              servedTier: cand.tier,
+              fromTier: routingDecision.tier,
+              fallback: true,
+              fallbackDirection: cand.direction,
+              method: "tier_fallback",
+            },
+          };
+        } catch (innerErr) {
+          logger.warn(
+            { toProvider: cand.provider, error: innerErr.message },
+            "[TierFallback] Candidate failed, trying next"
+          );
+        }
+      }
+      logger.warn(
+        { fromTier: routingDecision.tier },
+        "[TierFallback] All tier candidates exhausted — falling through"
+      );
+    }
+
     // Check if we should fallback (any provider can fall back, not just ollama)
     const shouldFallback =
       isFallbackEnabled() &&
@@ -2579,4 +2712,5 @@ function destroyHttpAgents() {
 module.exports = {
   invokeModel,
   destroyHttpAgents,
+  normalizeBodyForConverse,
 };

package/src/clients/openrouter-utils.js

@@ -1,4 +1,5 @@
 const logger = require("../logger");
+const { repairToolCallIds } = require("./tool-call-repair");
 
 /**
  * Convert Anthropic tool format to OpenAI/OpenRouter format
@@ -146,35 +147,11 @@ function convertAnthropicMessagesToOpenRouter(anthropicMessages) {
     }
   }
 
-  // Fix tool_call_id mismatches: ensure every tool message's tool_call_id
-  // matches the id in the preceding assistant's tool_calls array.
-  // IDs can drift when multiple conversion layers (Anthropic↔OpenAI) each
-  // generate their own IDs.
-  for (let i = 0; i < converted.length; i++) {
-    const msg = converted[i];
-    if (msg.role !== 'tool') continue;
-
-    // Find the nearest preceding assistant with tool_calls
-    for (let j = i - 1; j >= 0; j--) {
-      const prev = converted[j];
-      if (prev.role === 'user') break;
-      if (prev.role === 'assistant' && Array.isArray(prev.tool_calls) && prev.tool_calls.length > 0) {
-        if (!prev.tool_calls.some(tc => tc.id === msg.tool_call_id)) {
-          // Mismatch — pick the first unmatched tool_call id
-          const usedIds = new Set();
-          for (let k = j + 1; k < converted.length; k++) {
-            if (converted[k].role === 'tool' && k !== i) usedIds.add(converted[k].tool_call_id);
-          }
-          const available = prev.tool_calls.find(tc => !usedIds.has(tc.id));
-          if (available) {
-            logger.info({ from: msg.tool_call_id, to: available.id }, "Fixed tool_call_id mismatch");
-            msg.tool_call_id = available.id;
-          }
-        }
-        break;
-      }
-    }
-  }
+  // Repair tool_call_id linkage before handing to OpenAI-compatible providers:
+  // backfill blank assistant tool_call ids, re-link drifted/blank tool_call_ids
+  // to the nearest preceding assistant tool_call, and drop orphan tool results.
+  // Moonshot/Kimi (and others) hard-400 on any empty or unmatched tool_call_id.
+  repairToolCallIds(converted);
 
   // Kimi/Moonshot (and some OpenAI-compatible APIs) reject a message whose
   // content is an empty string with "Invalid request: tokenization failed".

package/src/clients/prompt-cache-injection.js

@@ -119,6 +119,51 @@ function needsCacheInjection(provider) {
   return EXPLICIT_CACHE_PROVIDERS.has(provider);
 }
 
+// Model families that do NOT support cache_control breakpoints. cache_control
+// is an Anthropic construct; on aggregating providers (Bedrock, OpenRouter) it
+// only applies to models that natively understand it (Claude, and Gemini via
+// proxy). Injecting markers onto these families produces request shapes the
+// upstream model rejects or silently ignores.
+const NON_CACHE_MODEL_PATTERNS = [
+  /(^|[./-])titan/i,
+  /(^|[./-])nova/i,
+  /(^|[./-])llama/i,
+  /(^|[./-])mistral/i,
+  /(^|[./-])mixtral/i,
+  /(^|[./-])cohere/i,
+  /(^|[./-])command/i, // cohere command-*
+  /(^|[./-])j2/i,      // ai21 jurassic
+  /(^|[./-])jamba/i,
+  /(^|[./-])deepseek/i,
+  /(^|[./-])qwen/i,
+  /(^|[./-])gpt/i,
+  /(^|[./-])openai/i,
+];
+
+/**
+ * Determine whether the model targeted by this request supports cache_control.
+ *
+ * Some providers in EXPLICIT_CACHE_PROVIDERS (notably bedrock and openrouter)
+ * route to many model families, only some of which understand cache_control.
+ * This guard inspects the resolved model id and blocks injection for families
+ * that are known not to support it. When the model id is absent or
+ * unrecognized, injection is allowed (fail-open) — Claude/Gemini-style ids and
+ * Anthropic-only providers fall through to true.
+ *
+ * @param {Object} body - Request body (may carry the resolved model id)
+ * @param {string} provider - Provider name
+ * @returns {boolean}
+ */
+function modelSupportsCacheControl(body, provider) {
+  // Providers that only ever route to Anthropic models always support it.
+  if (provider === 'azure-anthropic' || provider === 'databricks') return true;
+
+  const modelId = body && (body._tierModel || body.model);
+  if (!modelId || typeof modelId !== 'string') return true; // unknown → fail open
+
+  return !NON_CACHE_MODEL_PATTERNS.some(re => re.test(modelId));
+}
+
 /**
  * Inject provider-side prompt caching into the request body.
  * Call this before sending to the provider.
@@ -129,6 +174,9 @@ function needsCacheInjection(provider) {
  */
 function injectPromptCaching(body, provider) {
   if (!needsCacheInjection(provider)) return 0;
+  // Gate on model capability: a provider may support cache_control in general
+  // while the specific routed model does not.
+  if (!modelSupportsCacheControl(body, provider)) return 0;
   return injectAnthropicCacheBreakpoints(body);
 }
 
@@ -137,4 +185,5 @@ module.exports = {
   injectAnthropicCacheBreakpoints,
   injectGeminiCacheBreakpoints,
   needsCacheInjection,
+  modelSupportsCacheControl,
 };

package/src/clients/responses-format.js

@@ -8,6 +8,7 @@
  */
 
 const logger = require("../logger");
+const { repairToolCallIds } = require("./tool-call-repair");
 
 /**
  * Map client tool names back to Lynkr tool names
@@ -203,6 +204,12 @@ function convertResponsesToChat(responsesRequest) {
         return cleaned;
       });
 
+    // Repair tool_call_id linkage now, before anything downstream consumes the
+    // converted array. Codex bundled-plugin (Browser/Computer-use) calls and
+    // synthetic tool outputs can arrive without a usable call_id, which
+    // otherwise flattens to a blank tool_call_id and 400s at the provider.
+    repairToolCallIds(messages);
+
     logger.info({
       originalCount: input.length,
       filteredCount: messages.length,