@illuma-ai/agents 1.4.0-alpha.1 → 1.4.0-alpha.3

package/src/tools/fileSearch/formatter.ts

@@ -0,0 +1,129 @@
+/**
+ * Default result formatters.
+ *
+ * - `plainTextFormatter`: CLI / A2A / generic output. No citation anchors.
+ * - `citationAnchorFormatter`: ranger-style `\ue202turn0fileN` anchors with
+ *   a monotonic `sourceOffset` so multi-call turns stay globally unique.
+ *
+ * Runtimes can supply their own `FileSearchResultFormatter` to override.
+ */
+
+import type {
+  FileSearchResultFormatter,
+  FileSearchFile,
+  RagChunk,
+} from './types';
+
+type AnnotatedChunk = RagChunk & {
+  filename: string;
+  isCurrentMessage: boolean;
+};
+
+export const plainTextFormatter: FileSearchResultFormatter = {
+  format(chunks, { files: _files }) {
+    if (chunks.length === 0) {
+      return { message: 'No relevant results found in the available files.' };
+    }
+    const body = chunks
+      .map((c) => {
+        const page = getPage(c);
+        const rel = (1 - c.distance).toFixed(4);
+        return (
+          `File: ${c.filename}` +
+          (page != null ? `\nPage: ${page}` : '') +
+          `\nRelevance: ${rel}\nContent: ${c.page_content}\n`
+        );
+      })
+      .join('\n---\n');
+
+    const sources = chunks.map((c) => ({
+      type: 'file' as const,
+      fileId: c.file_id,
+      content: c.page_content,
+      fileName: c.filename,
+      relevance: 1 - c.distance,
+      pages: getPage(c) != null ? [getPage(c) as number] : [],
+    }));
+
+    return { message: body, artifact: { file_search: { sources } } };
+  },
+};
+
+export interface CitationAnchorFormatterOptions {
+  /** Tool name used in the `file_search` artifact wrapper. Defaults to `'file_search'`. */
+  toolName?: string;
+  /**
+   * Monotonic counter for source indices within a turn. Pass the SAME
+   * function to the formatter across multiple calls in the same turn so
+   * anchors stay globally unique.
+   */
+  getSourceOffset?: () => number;
+  /** Called after formatting to advance the offset. */
+  advanceSourceOffset?: (by: number) => void;
+}
+
+export function createCitationAnchorFormatter(
+  opts: CitationAnchorFormatterOptions = {}
+): FileSearchResultFormatter {
+  const toolName = opts.toolName ?? 'file_search';
+  const getOffset = opts.getSourceOffset ?? ((): number => 0);
+  const advance = opts.advanceSourceOffset ?? ((_by: number): void => {});
+
+  return {
+    format(chunks): { message: string; artifact?: unknown } {
+      if (chunks.length === 0) {
+        return {
+          message:
+            'No results found or errors occurred while searching the files.',
+        };
+      }
+      const base = getOffset();
+      const body = chunks
+        .map((c, i) => {
+          const globalIndex = base + i;
+          const page = getPage(c);
+          const rel = (1 - c.distance).toFixed(4);
+          return (
+            `[Source ${globalIndex}] File: ${c.filename} | Anchor: \\ue202turn0file${globalIndex}` +
+            (page != null ? ` | Page: ${page}` : '') +
+            ` | Relevance: ${rel}\nContent: ${c.page_content}\n` +
+            `↑ Cite this source using: \\ue202turn0file${globalIndex}`
+          );
+        })
+        .join('\n---\n');
+
+      const sources = chunks.map((c) => ({
+        type: 'file' as const,
+        fileId: c.file_id,
+        content: c.page_content,
+        fileName: c.filename,
+        relevance: 1 - c.distance,
+        pages: getPage(c) != null ? [getPage(c) as number] : [],
+        pageRelevance:
+          getPage(c) != null ? { [getPage(c) as number]: 1 - c.distance } : {},
+      }));
+
+      advance(chunks.length);
+      return {
+        message: body,
+        artifact: { [toolName]: { sources, fileCitations: true } },
+      };
+    },
+  };
+}
+
+/** Extract a 1-indexed page number from the chunk metadata, or null. */
+function getPage(chunk: AnnotatedChunk | RagChunk): number | null {
+  const raw =
+    (chunk.metadata?.page as unknown) ??
+    (chunk.metadata?.page_number as unknown) ??
+    null;
+  if (raw == null) return null;
+  const parsed = typeof raw === 'number' ? raw : parseInt(String(raw), 10);
+  if (Number.isNaN(parsed) || parsed < 0) return null;
+  // rag_api stores 0-indexed; display is 1-indexed
+  return parsed + 1;
+}
+
+// Re-export so consumers only import from the formatter module.
+export type { FileSearchResultFormatter, FileSearchFile, RagChunk };

package/src/tools/fileSearch/index.ts

@@ -0,0 +1,23 @@
+export { createFileSearchTool, FileSearchToolName } from './tool';
+export {
+  HttpRagClient,
+  getRagBaseUrl,
+  RAG_API_URL_ENV,
+  type HttpRagClientOptions,
+} from './ragClient';
+export {
+  plainTextFormatter,
+  createCitationAnchorFormatter,
+  type CitationAnchorFormatterOptions,
+} from './formatter';
+export { fileSearchInputSchema, type FileSearchInput } from './schema';
+export type {
+  FileSearchFile,
+  RagChunk,
+  RagClient,
+  RagQueryParams,
+  FileSearchResultFormatter,
+  FileSearchToolCallbacks,
+  FileSearchToolConfig,
+  FileSearchToolLogger,
+} from './types';

package/src/tools/fileSearch/ragClient.ts

@@ -0,0 +1,137 @@
+/**
+ * Default HTTP RAG client. Posts to `${baseUrl}/query` with the shape
+ * rag_api expects (`{ file_id, query, k, entity_id? }`). Runtimes that
+ * use a different vector backend implement their own `RagClient`.
+ *
+ * Auth is runtime-provided per call (via `authHeaders` on the params) so
+ * short-lived tokens can be minted per request without the client
+ * caching stale credentials.
+ */
+
+import fetch from 'node-fetch';
+import { getEnvironmentVariable } from '@langchain/core/utils/env';
+import type {
+  RagClient,
+  RagQueryParams,
+  RagChunk,
+  FileSearchToolLogger,
+} from './types';
+
+export const RAG_API_URL_ENV = 'RAG_API_URL';
+
+/** Resolve base URL at call time so env-var changes propagate. */
+export function getRagBaseUrl(override?: string): string {
+  const url = override ?? getEnvironmentVariable(RAG_API_URL_ENV) ?? '';
+  if (!url) {
+    throw new Error(
+      `file_search: ${RAG_API_URL_ENV} is not configured. ` +
+        `Set the env var or pass baseUrl to HttpRagClient.`
+    );
+  }
+  return url.replace(/\/$/, '');
+}
+
+export interface HttpRagClientOptions {
+  /** Base URL of the RAG service (no trailing slash). Falls back to env. */
+  baseUrl?: string;
+  /** Default headers sent on every request (e.g., a static API key). */
+  defaultHeaders?: Record<string, string>;
+  /** Default timeout if params don't override. Default 15_000. */
+  defaultTimeoutMs?: number;
+  logger?: FileSearchToolLogger;
+}
+
+/**
+ * Expected rag_api response shape: `[[{ page_content, metadata }, distance], ...]`
+ * — an array of [doc, score] tuples. Normalized here into `RagChunk[]`.
+ */
+type RagApiResponse = Array<
+  [
+    {
+      page_content: string;
+      metadata?: Record<string, unknown>;
+    },
+    number,
+  ]
+>;
+
+export class HttpRagClient implements RagClient {
+  private readonly baseUrlOverride?: string;
+  private readonly defaultHeaders: Record<string, string>;
+  private readonly defaultTimeoutMs: number;
+  private readonly logger?: FileSearchToolLogger;
+
+  constructor(opts: HttpRagClientOptions = {}) {
+    this.baseUrlOverride = opts.baseUrl;
+    this.defaultHeaders = opts.defaultHeaders ?? {};
+    this.defaultTimeoutMs = opts.defaultTimeoutMs ?? 15_000;
+    this.logger = opts.logger;
+  }
+
+  async query(params: RagQueryParams): Promise<RagChunk[]> {
+    const baseUrl = getRagBaseUrl(this.baseUrlOverride);
+    const url = `${baseUrl}/query`;
+
+    const body: Record<string, unknown> = {
+      file_id: params.file_id,
+      query: params.query,
+      k: params.k ?? 10,
+    };
+    if (params.entity_id) body.entity_id = params.entity_id;
+    if (params.scope) body.scope = params.scope;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      ...this.defaultHeaders,
+      ...(params.authHeaders ?? {}),
+    };
+
+    const timeoutMs = params.timeoutMs ?? this.defaultTimeoutMs;
+    const controller =
+      typeof AbortController !== 'undefined' ? new AbortController() : null;
+    const timer = controller
+      ? setTimeout(() => controller.abort(), timeoutMs)
+      : null;
+
+    this.logger?.debug('[file_search] RAG query', {
+      url,
+      file_id: params.file_id,
+      k: body.k,
+    });
+
+    try {
+      const res = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: controller?.signal as unknown as undefined,
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw new Error(
+          `RAG query failed: ${res.status} ${res.statusText} — ${text.slice(0, 200)}`
+        );
+      }
+      const json = (await res.json()) as RagApiResponse;
+      return this.normalize(params.file_id, json);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  /** Convert rag_api's tuple format into the library's normalized shape. */
+  private normalize(file_id: string, resp: RagApiResponse): RagChunk[] {
+    if (!Array.isArray(resp)) {
+      this.logger?.warn('[file_search] RAG response not an array', { resp });
+      return [];
+    }
+    return resp
+      .filter((row) => Array.isArray(row) && row.length === 2)
+      .map(([doc, distance]) => ({
+        file_id: (doc.metadata?.file_id as string | undefined) ?? file_id,
+        page_content: doc.page_content ?? '',
+        distance: typeof distance === 'number' ? distance : 1,
+        metadata: doc.metadata,
+      }));
+  }
+}

package/src/tools/fileSearch/schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+export const fileSearchInputSchema = z.object({
+  query: z
+    .string()
+    .describe(
+      "A natural language query to search for relevant information in the files. Be SPECIFIC and TARGETED — use keywords for the specific section or topic you need. For comprehensive tasks (summaries, overviews), call this tool multiple times with different targeted queries (e.g., 'introduction', 'methodology', 'results', 'conclusions') rather than one broad query."
+    ),
+  target_files: z
+    .array(z.string())
+    .optional()
+    .describe(
+      'Optional list of filenames (or partial names) to limit the search to. When provided, only files whose name contains one of these strings will be searched. Use this to avoid searching irrelevant files. Omit to search all available files.'
+    ),
+});
+
+export type FileSearchInput = z.infer<typeof fileSearchInputSchema>;
+
+export const FileSearchToolName = 'file_search';

package/src/tools/fileSearch/tool.ts

@@ -0,0 +1,207 @@
+/**
+ * file_search tool factory — library-native equivalent of the CodeExecutor
+ * pattern. Runtimes supply a `RagClient`, the file list for this turn, and
+ * an optional formatter (ranger uses citation anchors; CLI/A2A use plain
+ * text).
+ *
+ * The tool itself:
+ *   1. Accepts `{ query, target_files? }` from the LLM.
+ *   2. Filters files by `target_files` substring match when provided.
+ *   3. Queries each file in bounded concurrent batches.
+ *   4. Enforces per-file timeouts (failures isolated per file).
+ *   5. Flattens chunks, deprioritizes stale-turn files, caps results.
+ *   6. Hands formatted output to the runtime's formatter for final shape.
+ */
+
+import { tool, DynamicStructuredTool } from '@langchain/core/tools';
+import {
+  fileSearchInputSchema,
+  type FileSearchInput,
+  FileSearchToolName,
+} from './schema';
+import type {
+  FileSearchToolConfig,
+  FileSearchFile,
+  RagChunk,
+  RagQueryParams,
+} from './types';
+import { plainTextFormatter } from './formatter';
+
+const DEFAULT_QUERY_TIMEOUT_MS = 15_000;
+const DEFAULT_CONCURRENCY = 10;
+const DEFAULT_TOP_K = 10;
+
+/**
+ * Build the tool description. Runtimes that use citation anchors supply
+ * `fileCitations: true` (via the formatter); the description includes the
+ * citation ruleset only when that's on.
+ */
+function buildDescription(opts: { fileCitations: boolean }): string {
+  const core = `Performs semantic search across the attached "${FileSearchToolName}" documents using natural language queries. Analyzes the content of loaded files to find relevant information, quotes, and passages matching the query.
+
+**Use target_files to narrow the search:**
+When you know which file(s) contain the relevant information, ALWAYS pass target_files. This is faster and returns more focused results. Pass partial filenames — they match via substring.
+
+**Multiple searches for thorough analysis:**
+For summaries/overviews, call this tool MULTIPLE times with DIFFERENT queries targeting different aspects (intro, methodology, results, conclusions). A single search only returns chunks from one part of the document.`;
+
+  if (!opts.fileCitations) return core;
+
+  return `${core}
+
+**CITING FILE SEARCH RESULTS — MANDATORY:**
+Cite EVERY statement derived from file content. Place the citation anchor IMMEDIATELY after each paragraph using that source. Each search result has a unique source index — use DIFFERENT indices for different claims; do not reuse the same anchor for all paragraphs. Format: \`\\ue202turn0fileN\`. With a page: include \`(p. N)\` inline. Multiple sources: \`\\ue200\\ue202turn0file0\\ue202turn0file1\\ue201\`. NEVER substitute with footnotes, brackets, or symbols.`;
+}
+
+export function createFileSearchTool(
+  config: FileSearchToolConfig
+): DynamicStructuredTool {
+  const {
+    ragClient,
+    files,
+    entity_id,
+    scope,
+    getAuthHeaders,
+    formatter = plainTextFormatter,
+    queryTimeoutMs = DEFAULT_QUERY_TIMEOUT_MS,
+    concurrencyLimit = DEFAULT_CONCURRENCY,
+    topK = DEFAULT_TOP_K,
+    resultCap,
+    callbacks,
+    logger,
+  } = config;
+
+  // Monotonic call counter used by citation-style formatters to keep source
+  // indices unique across multiple invocations within a single turn.
+  let callIndex = 0;
+
+  // Infer whether the formatter wants citations from the artifact it emits
+  // on an empty-chunk format. This keeps the description/behavior aligned
+  // without forcing the host to declare `fileCitations` twice.
+  const fileCitations = formatter !== plainTextFormatter;
+
+  return tool(
+    async (rawInput: FileSearchInput) => {
+      const { query, target_files } = rawInput;
+
+      if (files.length === 0) {
+        return [
+          'No files to search. Instruct the user to add files for the search.',
+          undefined,
+        ];
+      }
+
+      // target_files: case-insensitive substring match, fallback to all
+      // files with a warning if the filter excludes everything.
+      let filesToQuery: FileSearchFile[] = files;
+      if (target_files && target_files.length > 0) {
+        const lowerTargets = target_files.map((t) => t.toLowerCase());
+        const matched = files.filter((f) =>
+          lowerTargets.some((t) => f.filename.toLowerCase().includes(t))
+        );
+        if (matched.length === 0) {
+          logger?.warn(
+            `[file_search] No files matched target_files ${target_files.join(', ')}; falling back to all files`
+          );
+          filesToQuery = files;
+        } else {
+          logger?.info(
+            `[file_search] Filtered to ${matched.length}/${files.length} via target_files`
+          );
+          filesToQuery = matched;
+        }
+      }
+
+      const authHeaders = getAuthHeaders ? await getAuthHeaders() : undefined;
+
+      const queryOne = async (file: FileSearchFile): Promise<RagChunk[]> => {
+        const params: RagQueryParams = {
+          file_id: file.file_id,
+          query,
+          k: topK,
+          entity_id,
+          scope,
+          authHeaders,
+          timeoutMs: queryTimeoutMs,
+        };
+        try {
+          const chunks = await ragClient.query(params);
+          callbacks?.onFileQueried?.(file, chunks.length);
+          return chunks;
+        } catch (err) {
+          const e = err instanceof Error ? err : new Error(String(err));
+          logger?.error(
+            `[file_search] Query failed for ${file.filename}: ${e.message}`
+          );
+          callbacks?.onFileError?.(file, e);
+          return [];
+        }
+      };
+
+      // Bounded-concurrency batching. Server-side rerankers handle their
+      // own concurrency; this protects the HTTP connection pool when the
+      // agent has many files.
+      const allChunks: RagChunk[] = [];
+      for (let i = 0; i < filesToQuery.length; i += concurrencyLimit) {
+        const batch = filesToQuery.slice(i, i + concurrencyLimit);
+        const batchResults = await Promise.all(batch.map(queryOne));
+        for (const chunks of batchResults) allChunks.push(...chunks);
+      }
+
+      if (allChunks.length === 0) {
+        return [
+          'No content found in the files. The files may not have been processed correctly or the query may need refinement.',
+          undefined,
+        ];
+      }
+
+      // Build annotated results: attach filename + isCurrentMessage via
+      // a file-id lookup (metadata wins, factory list is fallback).
+      const fileById = new Map(files.map((f) => [f.file_id, f]));
+      const annotated = allChunks.map((c) => {
+        const matched = fileById.get(c.file_id);
+        const filename =
+          (c.metadata?.source
+            ? String(c.metadata.source).split(/[/\\]/).pop()
+            : undefined) ??
+          matched?.filename ??
+          'Unknown';
+        return {
+          ...c,
+          filename,
+          isCurrentMessage: matched?.isCurrentMessage === true,
+        };
+      });
+
+      // Sort: current-turn files first, then by relevance (lower distance).
+      annotated.sort((a, b) => {
+        if (a.isCurrentMessage !== b.isCurrentMessage)
+          return a.isCurrentMessage ? -1 : 1;
+        return a.distance - b.distance;
+      });
+
+      const cap = resultCap ?? Math.max(10, filesToQuery.length * 3);
+      const limited = annotated.slice(0, cap);
+
+      const { message, artifact } = formatter.format(limited, {
+        callIndex,
+        files,
+      });
+      callIndex += 1;
+
+      // Suppress unused-variable warning for fileCitations (currently only
+      // used to gate description; kept in case formatters need it).
+      void fileCitations;
+
+      return [message, artifact];
+    },
+    {
+      name: FileSearchToolName,
+      responseFormat: 'content_and_artifact',
+      description: buildDescription({ fileCitations }),
+      schema: fileSearchInputSchema,
+    }
+  );
+}
+
+export { FileSearchToolName } from './schema';

package/src/tools/fileSearch/types.ts

@@ -0,0 +1,149 @@
+/**
+ * File-search tool types. Mirrors the web_search / code_executor split —
+ * the library owns tool logic; the host supplies a `RagClient` + config
+ * shaped to its own deployment (auth strategy, scope identity, file set).
+ */
+
+export interface FileSearchFile {
+  /** Stable identifier within the RAG backend. */
+  file_id: string;
+  /** Human-readable name surfaced in tool results and prompts. */
+  filename: string;
+  /**
+   * Hint that this file arrived on the *current* conversation turn (as
+   * opposed to an earlier turn). Hosts that don't distinguish leave this
+   * undefined; the formatter deprioritizes older files when set.
+   */
+  isCurrentMessage?: boolean;
+}
+
+/**
+ * A single chunk returned by the RAG backend for a query.
+ * Shape is normalized here so the library stays independent of any
+ * specific RAG service's response format — the `RagClient` is responsible
+ * for translating the backend response into this shape.
+ */
+export interface RagChunk {
+  file_id: string;
+  page_content: string;
+  distance: number; // 0 = perfect match, 1 = orthogonal
+  metadata?: Record<string, unknown>;
+}
+
+export interface RagQueryParams {
+  file_id: string;
+  query: string;
+  /** Top-K chunks to return per file. Default 10. */
+  k?: number;
+  /** Optional tenant/entity ID — forwarded to the backend verbatim. */
+  entity_id?: string;
+  /**
+   * Scope identifier. Hosts use this for per-tenant isolation in the RAG
+   * backend (ranger → userId, cli → agentId, a2a → task-id).
+   */
+  scope?: string;
+  /**
+   * Per-request auth headers — the host builds these (e.g., ranger sends
+   * `Authorization: Bearer <short-lived-JWT-for-userId>`). Allows
+   * different runtimes to use different auth strategies without the
+   * library knowing.
+   */
+  authHeaders?: Record<string, string>;
+  /** Optional per-call timeout override. */
+  timeoutMs?: number;
+}
+
+/**
+ * Pluggable RAG backend. Runtimes provide an implementation that speaks
+ * to whatever vector DB / search service they've deployed (rag_api is the
+ * default; azure search, pinecone, etc. are valid alternates).
+ */
+export interface RagClient {
+  query(params: RagQueryParams): Promise<RagChunk[]>;
+}
+
+/**
+ * Formatter callback that shapes raw chunks into the runtime's preferred
+ * presentation. Ranger uses citation anchors (`\ue202turn0fileN`), CLI
+ * uses plain text, A2A server can return structured parts.
+ */
+export interface FileSearchResultFormatter {
+  format(
+    chunks: Array<RagChunk & { filename: string; isCurrentMessage: boolean }>,
+    context: {
+      /**
+       * Monotonic call index within a single turn. Ranger uses this to
+       * keep citation source indices globally unique across multiple
+       * file_search invocations.
+       */
+      callIndex: number;
+      /** Same files list the factory was seeded with (for lookups). */
+      files: FileSearchFile[];
+    }
+  ): {
+    /** Message returned to the LLM (content). */
+    message: string;
+    /** Optional artifact payload (sources, metadata) returned alongside. */
+    artifact?: unknown;
+  };
+}
+
+export interface FileSearchToolCallbacks {
+  /**
+   * Fires when a RAG query completes successfully for one file. Hosts can
+   * use this for telemetry, streaming UI updates, etc.
+   */
+  onFileQueried?: (file: FileSearchFile, chunkCount: number) => void;
+  /** Fires when a RAG query fails. Hosts can log or surface via UI. */
+  onFileError?: (file: FileSearchFile, error: Error) => void;
+}
+
+export interface FileSearchToolLogger {
+  debug: (msg: string, ...args: unknown[]) => void;
+  info: (msg: string, ...args: unknown[]) => void;
+  warn: (msg: string, ...args: unknown[]) => void;
+  error: (msg: string, ...args: unknown[]) => void;
+}
+
+export interface FileSearchToolConfig {
+  /** The RAG backend client. Required. */
+  ragClient: RagClient;
+  /** Files the agent has access to this turn. Empty = tool self-reports so. */
+  files: FileSearchFile[];
+  /** Tenant/entity ID forwarded to the backend per-query. */
+  entity_id?: string;
+  /**
+   * Per-turn scope identity. Most runtimes pin this once (userId/agentId);
+   * if omitted, no scope is sent to the backend.
+   */
+  scope?: string;
+  /**
+   * Per-call auth header builder. Called on every tool invocation so
+   * the host can mint fresh short-lived tokens (ranger's JWT pattern).
+   * When omitted, no auth headers are sent.
+   */
+  getAuthHeaders?: () =>
+    | Record<string, string>
+    | Promise<Record<string, string>>;
+  /**
+   * Result formatter. When omitted, the default plain-text formatter is
+   * used (suitable for CLI/A2A runtimes that don't need citation anchors).
+   */
+  formatter?: FileSearchResultFormatter;
+  /** Per-file query timeout in ms. Default 15_000. */
+  queryTimeoutMs?: number;
+  /**
+   * Max concurrent in-flight RAG queries. Protects HTTP connection pools
+   * under heavy file counts. Default 10.
+   */
+  concurrencyLimit?: number;
+  /** Top-K chunks per file. Default 10. */
+  topK?: number;
+  /**
+   * Cap on total chunks returned to the LLM after sorting. Default is
+   * `max(10, filesCount * 3)`.
+   */
+  resultCap?: number;
+  callbacks?: FileSearchToolCallbacks;
+  logger?: FileSearchToolLogger;
+}