@illuma-ai/agents 1.5.0 → 2.1.1

package/src/specs/anthropic.simple.test.ts

@@ -376,67 +376,6 @@ describe(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     );
   });
 
-  test(`${capitalizeFirstLetter(provider)}: follow-up after assistant message with only whitespace text content`, async () => {
-    /**
-     * Regression for upstream discussion #12806.
-     *
-     * The Anthropic API has two distinct rejection rules (verified against
-     * the live API):
-     *   1. Strict empty `text: ''`  → rejected anywhere
-     *      "messages: text content blocks must be non-empty"
-     *   2. Whitespace-only `text: ' '` / '\n' / '\t' → rejected when the
-     *      assistant message has no other accepted blocks (no tool blocks,
-     *      no non-whitespace text)
-     *      "messages: text content blocks must contain non-whitespace text"
-     *
-     * Anthropic responses for some prompts include a whitespace-only text
-     * block as the sole text content. Re-sending that history on a
-     * follow-up turn triggers rule 2.
-     *
-     * The wire-send filter in `_formatContent` must drop any text block
-     * whose trimmed content is empty. The previous filter used strict
-     * `text === ''` only, which caught rule 1 but not rule 2.
-     */
-    const llmConfig = getLLMConfig(provider);
-    const customHandlers1 = setupCustomHandlers();
-
-    const followUpRun = await Run.create<t.IState>({
-      runId: 'repro-12806-followup',
-      graphConfig: {
-        type: 'standard',
-        llmConfig,
-        instructions: 'You are a friendly AI assistant.',
-      },
-      returnContent: true,
-      skipCleanup: true,
-      customHandlers: customHandlers1,
-    });
-
-    // Build history with an assistant message whose entire content array
-    // is a single whitespace-only text block. This is the precise shape
-    // the API rejects under rule 2 above.
-    conversationHistory = [
-      new HumanMessage('hi'),
-      new (require('@langchain/core/messages').AIMessage)({
-        content: [{ type: 'text', text: ' ' }],
-      }),
-      new HumanMessage('please respond with a short greeting'),
-    ];
-
-    // With the fix: `_formatContent` drops the whitespace text block,
-    // the assistant content becomes an empty array, and the API accepts.
-    // Without the fix: the whitespace block is forwarded and the API
-    // rejects with "messages: text content blocks must contain non-whitespace text".
-    const finalContentParts = await followUpRun.processStream(
-      { messages: conversationHistory },
-      config
-    );
-    expect(finalContentParts).toBeDefined();
-    const finalMessages = followUpRun.getRunMessages();
-    expect(finalMessages).toBeDefined();
-    expect(finalMessages?.length).toBeGreaterThan(0);
-  });
-
   test('should handle errors appropriately', async () => {
     // Test error scenarios
     await expect(async () => {

package/src/tools/BashExecutor.ts

@@ -4,23 +4,17 @@ import { HttpsProxyAgent } from 'https-proxy-agent';
 import { getEnvironmentVariable } from '@langchain/core/utils/env';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type * as t from '@/types';
-import { getCodeBaseURL, renderFileSection } from './CodeExecutor';
+import { imageExtRegex, getCodeBaseURL } from './CodeExecutor';
 import { Constants, EnvVar } from '@/common';
 
 config();
 
+const imageMessage = 'Image is already displayed to the user';
 const otherMessage = 'File is already downloaded by the user';
-const inheritedFileMessage =
-  'Available as an input — already known to the user';
 const accessMessage =
   'Note: Files from previous executions are automatically available and can be modified.';
 const emptyOutputMessage =
   "stdout: Empty. Ensure you're writing output explicitly.\n";
-const inheritedFilesHeader =
-  'Available files (inputs, not generated by this execution):';
-const generatedFilesHeader = 'Generated files:';
-const inheritedNote =
-  'Note: Files in "Available files" are inputs the user (or a skill) already provided to the sandbox. They were not produced by this execution and you should not present them as new outputs in your response.';
 
 export const BashExecutionToolSchema = {
   type: 'object',
@@ -221,38 +215,20 @@ function createBashExecutionTool(
         }
         if (result.stderr) formattedOutput += `stderr:\n${result.stderr}\n`;
         if (result.files && result.files.length > 0) {
-          /* Split inherited (read-only / unchanged-input passthroughs from
-           * codeapi) from genuine generated outputs. The LLM was previously
-           * shown skill files under "Generated files:" with the message
-           * "File is already downloaded by the user", which led it to
-           * (a) believe it had just produced files it merely referenced
-           * and (b) sometimes invent paths like /mnt/user-data/uploads/
-           * trying to find the "originals". Labeling them as inputs makes
-           * the mental model accurate. */
-          const inheritedFiles = result.files.filter(
-            (f) => f.inherited === true
-          );
-          const generatedFiles = result.files.filter(
-            (f) => f.inherited !== true
-          );
+          formattedOutput += 'Generated files:\n';
 
-          formattedOutput += renderFileSection(
-            generatedFilesHeader,
-            generatedFiles,
-            otherMessage
-          );
-          formattedOutput += renderFileSection(
-            inheritedFilesHeader,
-            inheritedFiles,
-            inheritedFileMessage
-          );
+          const fileCount = result.files.length;
+          for (let i = 0; i < fileCount; i++) {
+            const file = result.files[i];
+            const isImage = imageExtRegex.test(file.name);
+            formattedOutput += `- /mnt/data/${file.name} | ${isImage ? imageMessage : otherMessage}`;
 
-          if (generatedFiles.length > 0) {
-            formattedOutput += `\n\n${accessMessage}`;
-          }
-          if (inheritedFiles.length > 0) {
-            formattedOutput += `\n\n${inheritedNote}`;
+            if (i < fileCount - 1) {
+              formattedOutput += fileCount <= 3 ? ', ' : ',\n';
+            }
           }
+
+          formattedOutput += `\n\n${accessMessage}`;
           return [
             formattedOutput.trim(),
             {

package/src/tools/CodeExecutor.ts

@@ -15,41 +15,10 @@ export const getCodeBaseURL = (): string =>
 
 const imageMessage = 'Image is already displayed to the user';
 const otherMessage = 'File is already downloaded by the user';
-const inheritedFileMessage =
-  'Available as an input — already known to the user';
 const accessMessage =
   'Note: Files from previous executions are automatically available and can be modified.';
 const emptyOutputMessage =
   "stdout: Empty. Ensure you're writing output explicitly.\n";
-const inheritedFilesHeader =
-  'Available files (inputs, not generated by this execution):';
-const generatedFilesHeader = 'Generated files:';
-const inheritedNote =
-  'Note: Files in "Available files" are inputs the user (or a skill) already provided to the sandbox. They were not produced by this execution and you should not present them as new outputs in your response.';
-
-/**
- * Renders one section of the post-execution file listing. Used by the
- * code/bash tool formatters to keep generated outputs and inherited
- * inputs visually separated. See BashExecutor for full docs.
- */
-export function renderFileSection(
-  header: string,
-  files: t.FileRefs,
-  defaultMessage: string
-): string {
-  if (files.length === 0) return '';
-  let out = `${header}\n`;
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
-    const isImage = imageExtRegex.test(file.name);
-    out += `- /mnt/data/${file.name} | ${isImage ? imageMessage : defaultMessage}`;
-    if (i < files.length - 1) {
-      out += files.length <= 3 ? ', ' : ',\n';
-    }
-  }
-  out += '\n';
-  return out;
-}
 
 const SUPPORTED_LANGUAGES = [
   'py',
@@ -333,33 +302,20 @@ function createCodeExecutionTool(
         }
 
         if (result.files && result.files.length > 0) {
-          /* Split inherited (read-only passthrough) inputs from real
-           * generated outputs so the LLM doesn't conflate skill files
-           * with newly-produced artifacts. */
-          const inheritedFiles = result.files.filter(
-            (f) => f.inherited === true
-          );
-          const generatedFiles = result.files.filter(
-            (f) => f.inherited !== true
-          );
+          formattedOutput += 'Generated files:\n';
 
-          formattedOutput += renderFileSection(
-            generatedFilesHeader,
-            generatedFiles,
-            otherMessage
-          );
-          formattedOutput += renderFileSection(
-            inheritedFilesHeader,
-            inheritedFiles,
-            inheritedFileMessage
-          );
+          const fileCount = result.files.length;
+          for (let i = 0; i < fileCount; i++) {
+            const file = result.files[i];
+            const isImage = imageExtRegex.test(file.name);
+            formattedOutput += `- /mnt/data/${file.name} | ${isImage ? imageMessage : otherMessage}`;
 
-          if (generatedFiles.length > 0) {
-            formattedOutput += `\n\n${accessMessage}`;
-          }
-          if (inheritedFiles.length > 0) {
-            formattedOutput += `\n\n${inheritedNote}`;
+            if (i < fileCount - 1) {
+              formattedOutput += fileCount <= 3 ? ', ' : ',\n';
+            }
           }
+
+          formattedOutput += `\n\n${accessMessage}`;
           return [
             formattedOutput.trim(),
             {

package/src/tools/ProgrammaticToolCalling.ts

@@ -6,7 +6,7 @@ import { getEnvironmentVariable } from '@langchain/core/utils/env';
 import { tool, DynamicStructuredTool } from '@langchain/core/tools';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
-import { getCodeBaseURL, renderFileSection } from './CodeExecutor';
+import { imageExtRegex, getCodeBaseURL } from './CodeExecutor';
 import { EnvVar, Constants } from '@/common';
 
 config();
@@ -15,14 +15,8 @@ config();
 // Constants
 // ============================================================================
 
+const imageMessage = 'Image is already displayed to the user';
 const otherMessage = 'File is already downloaded by the user';
-const inheritedFileMessage =
-  'Available as an input — already known to the user';
-const inheritedFilesHeader =
-  'Available files (inputs, not generated by this execution):';
-const generatedFilesHeader = 'Generated files:';
-const inheritedNote =
-  'Note: Files in "Available files" are inputs the user (or a skill) already provided to the sandbox. They were not produced by this execution and you should not present them as new outputs in your response.';
 const accessMessage =
   'Note: Files from previous executions are automatically available and can be modified.';
 const emptyOutputMessage =
@@ -569,29 +563,20 @@ export function formatCompletedResponse(
   }
 
   if (response.files && response.files.length > 0) {
-    /* See BashExecutor for the rationale: split inherited (read-only
-     * passthrough) inputs from real generated outputs so the LLM doesn't
-     * conflate skill files with newly-produced artifacts. */
-    const inheritedFiles = response.files.filter((f) => f.inherited === true);
-    const generatedFiles = response.files.filter((f) => f.inherited !== true);
-
-    formatted += renderFileSection(
-      generatedFilesHeader,
-      generatedFiles,
-      otherMessage
-    );
-    formatted += renderFileSection(
-      inheritedFilesHeader,
-      inheritedFiles,
-      inheritedFileMessage
-    );
+    formatted += 'Generated files:\n';
 
-    if (generatedFiles.length > 0) {
-      formatted += `\n\n${accessMessage}`;
-    }
-    if (inheritedFiles.length > 0) {
-      formatted += `\n\n${inheritedNote}`;
+    const fileCount = response.files.length;
+    for (let i = 0; i < fileCount; i++) {
+      const file = response.files[i];
+      const isImage = imageExtRegex.test(file.name);
+      formatted += `- /mnt/data/${file.name} | ${isImage ? imageMessage : otherMessage}`;
+
+      if (i < fileCount - 1) {
+        formatted += fileCount <= 3 ? ', ' : ',\n';
+      }
     }
+
+    formatted += `\n\n${accessMessage}`;
   }
 
   return [

package/src/tools/ToolNode.ts

@@ -754,19 +754,74 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       }
     }
 
-    // Field-level recovery: extract missing fields from the raw buffer
+    // Field-level recovery: extract missing fields from the raw buffer.
+    //
+    // Only attempt this when `parsedArgs` is missing top-level keys that
+    // appear at depth 0 in the raw JSON. The previous implementation walked
+    // EVERY `"key":` match the regex found — including keys nested inside
+    // arrays/objects like `steps[].options[].label` — and tried to "recover"
+    // them as top-level fields. That produced confusing log spam (false
+    // positives like `recoveredFields=[question,label,value]` for a clean
+    // multi-step `ask_user` call) and could inject stray top-level fields
+    // into `args` for downstream tool execution.
     const parsedArgs = typeof args === 'object' ? { ...args } : {};
     const recoveredFields: string[] = [];
 
-    // Extract field names from the raw JSON string
-    const fieldPattern = /"([^"]+)"\s*:/g;
-    let match;
-    const rawFieldNames: string[] = [];
-    while ((match = fieldPattern.exec(rawArgs)) !== null) {
-      rawFieldNames.push(match[1]);
+    /**
+     * Extract only TOP-LEVEL keys from the raw JSON. Walks the buffer
+     * tracking brace/bracket depth so nested keys are skipped.
+     */
+    const topLevelKeys: string[] = [];
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    let i = 0;
+    while (i < rawArgs.length) {
+      const ch = rawArgs[i];
+      if (escaped) {
+        escaped = false;
+        i++;
+        continue;
+      }
+      if (inString) {
+        if (ch === '\\') escaped = true;
+        else if (ch === '"') inString = false;
+        i++;
+        continue;
+      }
+      if (ch === '"') {
+        // Possible key — only count if at depth 1 (inside the outer object)
+        const start = i + 1;
+        let j = start;
+        while (j < rawArgs.length) {
+          const c = rawArgs[j];
+          if (c === '\\') {
+            j += 2;
+            continue;
+          }
+          if (c === '"') break;
+          j++;
+        }
+        if (j < rawArgs.length) {
+          // Skip whitespace after closing quote and check for ':'
+          let k = j + 1;
+          while (k < rawArgs.length && /\s/.test(rawArgs[k])) k++;
+          if (depth === 1 && rawArgs[k] === ':') {
+            topLevelKeys.push(rawArgs.slice(start, j));
+          }
+          i = j + 1;
+          continue;
+        }
+        inString = true;
+        i++;
+        continue;
+      }
+      if (ch === '{' || ch === '[') depth++;
+      else if (ch === '}' || ch === ']') depth--;
+      i++;
     }
 
-    for (const fieldName of rawFieldNames) {
+    for (const fieldName of topLevelKeys) {
       if (
         parsedArgs[fieldName] == null ||
         parsedArgs[fieldName] === '' ||
@@ -991,6 +1046,12 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
       // Dispatch ON_RUN_STEP_COMPLETED via custom event (same path as dispatchToolEvents)
       const stepId = this.toolCallStepIds?.get(toolCallId) ?? '';
       if (!stepId) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `[ToolNode.handleRunToolCompletions] missing stepId for toolCallId=${toolCallId} ` +
+            `name=${call.name} — ON_RUN_STEP_COMPLETED skipped, output will not be persisted. ` +
+            `If this is a resumed HITL tool call, verify Graph.resetValues preserves toolCallStepIds when keepContent=true.`
+        );
         continue;
       }
 

package/src/tools/__tests__/ProgrammaticToolCalling.test.ts

@@ -664,66 +664,6 @@ for member in team:
       expect(output).toContain('chart.png');
       expect(output).toContain('Image is already displayed to the user');
     });
-
-    it('splits inherited inputs from generated outputs into distinct sections', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'analysis done\n',
-        stderr: '',
-        files: [
-          { id: 'g1', name: 'report.pdf' },
-          { id: 'i1', name: 'pptx/SKILL.md', inherited: true },
-          { id: 'i2', name: 'pptx/scripts/clean.py', inherited: true },
-          { id: 'g2', name: 'chart.png' },
-        ],
-        session_id: 'sess_abc123',
-      };
-
-      const [output, artifact] = formatCompletedResponse(response);
-
-      /* Generated section lists only outputs the run produced. */
-      const generatedIdx = output.indexOf('Generated files:');
-      const inheritedIdx = output.indexOf('Available files (inputs');
-      expect(generatedIdx).toBeGreaterThan(-1);
-      expect(inheritedIdx).toBeGreaterThan(generatedIdx);
-
-      /* Slice each section so we can assert membership without
-       * cross-talk between the two listings. */
-      const generatedSection = output.slice(generatedIdx, inheritedIdx);
-      const inheritedSection = output.slice(inheritedIdx);
-
-      expect(generatedSection).toContain('report.pdf');
-      expect(generatedSection).toContain('chart.png');
-      expect(generatedSection).not.toContain('SKILL.md');
-
-      expect(inheritedSection).toContain('pptx/SKILL.md');
-      expect(inheritedSection).toContain('pptx/scripts/clean.py');
-      expect(inheritedSection).toContain('Available as an input');
-
-      /* The artifact still carries every file so the host can still
-       * thread per-file ids through to subsequent calls. */
-      expect(artifact.files).toHaveLength(4);
-    });
-
-    it('omits the Generated files header when every entry is inherited', () => {
-      const response: t.ProgrammaticExecutionResponse = {
-        status: 'completed',
-        stdout: 'cat: ok\n',
-        stderr: '',
-        files: [
-          { id: 'i1', name: 'pptx/SKILL.md', inherited: true },
-          { id: 'i2', name: 'pptx/editing.md', inherited: true },
-        ],
-        session_id: 'sess_abc123',
-      };
-
-      const [output] = formatCompletedResponse(response);
-
-      expect(output).not.toContain('Generated files:');
-      expect(output).toContain('Available files (inputs');
-      expect(output).toContain('pptx/SKILL.md');
-      expect(output).toContain('pptx/editing.md');
-    });
   });
 
   describe('createProgrammaticToolCallingTool - Manual Invocation', () => {

package/src/tools/__tests__/SubagentExecutor.test.ts

@@ -546,6 +546,163 @@ describe('SubagentExecutor', () => {
     expect(observedChildInputs!.maxSubagentDepth).toBeUndefined();
   });
 
+  describe('parentConfigurable inheritance', () => {
+    /**
+     * Build a stub factory that captures the second argument to
+     * `workflow.invoke()` (the runnable config) so tests can assert on
+     * the `configurable` we forwarded to the child graph.
+     */
+    function makeCapturingGraphFactory(): {
+      factory: () => StandardGraph;
+      getInvokeConfig: () => Record<string, unknown> | undefined;
+    } {
+      let capturedConfig: Record<string, unknown> | undefined;
+      const factory = (): StandardGraph =>
+        ({
+          createWorkflow: (): { invoke: jest.Mock } => ({
+            invoke: jest
+              .fn()
+              .mockImplementation(
+                async (
+                  _input: unknown,
+                  config: Record<string, unknown>
+                ): Promise<{ messages: BaseMessage[] }> => {
+                  capturedConfig = config;
+                  return { messages: [new AIMessage('done')] };
+                }
+              ),
+          }),
+          clearHeavyState: jest.fn(),
+        }) as unknown as StandardGraph;
+      return { factory, getInvokeConfig: () => capturedConfig };
+    }
+
+    it('forwards parentConfigurable into the child workflow.invoke configurable', async () => {
+      const { factory, getInvokeConfig } = makeCapturingGraphFactory();
+      const executor = createExecutor({ createChildGraph: factory });
+
+      await executor.execute({
+        description: 'task',
+        subagentType: 'researcher',
+        parentConfigurable: {
+          requestBody: { messageId: 'msg-123', conversationId: 'conv-456' },
+          user: { id: 'user_abc' },
+          user_id: 'user_abc',
+          userMCPAuthMap: { 'mcp-github': { token: 'abc' } },
+        },
+      });
+
+      const invokeConfig = getInvokeConfig();
+      expect(invokeConfig).toBeDefined();
+      const configurable = invokeConfig!.configurable as Record<
+        string,
+        unknown
+      >;
+      expect(configurable.requestBody).toEqual({
+        messageId: 'msg-123',
+        conversationId: 'conv-456',
+      });
+      expect(configurable.user).toEqual({ id: 'user_abc' });
+      expect(configurable.user_id).toBe('user_abc');
+      expect(configurable.userMCPAuthMap).toEqual({
+        'mcp-github': { token: 'abc' },
+      });
+    });
+
+    it('inherits parent thread_id when supplied (subagent is part of same conversation)', async () => {
+      const { factory, getInvokeConfig } = makeCapturingGraphFactory();
+      const executor = createExecutor({
+        createChildGraph: factory,
+        parentRunId: 'parent-run-xyz',
+      });
+
+      await executor.execute({
+        description: 'task',
+        subagentType: 'researcher',
+        parentConfigurable: { thread_id: 'parent-thread-conv-abc' },
+      });
+
+      const configurable = getInvokeConfig()!.configurable as Record<
+        string,
+        unknown
+      >;
+      expect(configurable.thread_id).toBe('parent-thread-conv-abc');
+    });
+
+    it('falls back to childRunId for thread_id when parent did not supply one', async () => {
+      const { factory, getInvokeConfig } = makeCapturingGraphFactory();
+      const executor = createExecutor({
+        createChildGraph: factory,
+        parentRunId: 'parent-run-xyz',
+      });
+
+      await executor.execute({
+        description: 'task',
+        subagentType: 'researcher',
+        parentConfigurable: { user_id: 'user_abc' },
+      });
+
+      const configurable = getInvokeConfig()!.configurable as Record<
+        string,
+        unknown
+      >;
+      expect(configurable.thread_id as string).toMatch(/^parent-run-xyz_sub_/);
+      expect(configurable.user_id).toBe('user_abc');
+    });
+
+    it('forwards run-identity fields verbatim into the child invoke configurable', async () => {
+      const { factory, getInvokeConfig } = makeCapturingGraphFactory();
+      const executor = createExecutor({ createChildGraph: factory });
+
+      await executor.execute({
+        description: 'task',
+        subagentType: 'researcher',
+        parentConfigurable: {
+          run_id: 'parent-run-id',
+          parent_run_id: 'grandparent-run-id',
+          requestBody: { messageId: 'msg-1' },
+        },
+      });
+
+      const configurable = getInvokeConfig()!.configurable as Record<
+        string,
+        unknown
+      >;
+      // The SDK forwards these fields as part of its inheritance contract.
+      // NOTE: the LangGraph runtime overwrites `configurable.run_id` at
+      // actual child-invoke time (verified empirically); this unit test
+      // only asserts what the SDK forwards into `workflow.invoke` — not
+      // what tools downstream observe. `parent_run_id` and other
+      // host-set keys do survive the runtime pass-through.
+      expect(configurable.run_id).toBe('parent-run-id');
+      expect(configurable.parent_run_id).toBe('grandparent-run-id');
+      expect(configurable.requestBody).toEqual({ messageId: 'msg-1' });
+    });
+
+    it('does not require parentConfigurable (back-compat with hosts that omit it)', async () => {
+      const { factory, getInvokeConfig } = makeCapturingGraphFactory();
+      const executor = createExecutor({ createChildGraph: factory });
+
+      await executor.execute({
+        description: 'task',
+        subagentType: 'researcher',
+      });
+
+      const configurable = getInvokeConfig()!.configurable as Record<
+        string,
+        unknown
+      >;
+      // Only thread_id (childRunId fallback) and the host-attached
+      // parentToolCallId (used by ranger for attachment routing) are set
+      // when no parent context is supplied. parentToolCallId is undefined
+      // here because no tool_call_id was passed in the metadata.
+      expect(Object.keys(configurable).sort()).toEqual(
+        ['parentToolCallId', 'thread_id'].sort()
+      );
+      expect(configurable.parentToolCallId).toBeUndefined();
+    });
+  });
+
   describe('hooks', () => {
     let capturedStart: unknown;
     let capturedStop: unknown;

package/src/tools/search/search.ts

@@ -2,7 +2,6 @@ import axios from 'axios';
 import { RecursiveCharacterTextSplitter } from '@langchain/textsplitters';
 import type * as t from './types';
 import { getAttribution, createDefaultLogger } from './utils';
-import { createTavilyAPI } from './tavily-search';
 import { BaseReranker } from './rerankers';
 
 const chunker = {
@@ -439,9 +438,6 @@ export const createSearchAPI = (
     serperApiKey,
     searxngInstanceUrl,
     searxngApiKey,
-    tavilyApiKey,
-    tavilySearchUrl,
-    tavilySearchOptions,
     domainBlocklist,
     countryBlocklist,
   } = config;
@@ -450,11 +446,9 @@ export const createSearchAPI = (
     return createSerperAPI(serperApiKey, domainBlocklist, countryBlocklist);
   } else if (searchProvider.toLowerCase() === 'searxng') {
     return createSearXNGAPI(searxngInstanceUrl, searxngApiKey);
-  } else if (searchProvider.toLowerCase() === 'tavily') {
-    return createTavilyAPI(tavilyApiKey, tavilySearchUrl, tavilySearchOptions);
   } else {
     throw new Error(
-      `Invalid search provider: ${searchProvider}. Must be 'serper', 'searxng', or 'tavily'`
+      `Invalid search provider: ${searchProvider}. Must be 'serper' or 'searxng'`
     );
   }
 };
@@ -500,13 +494,9 @@ export const createSourceProcessor = (
           const promise: Promise<t.ScrapeResult> = scraper
             .scrapeUrl(currentLink, {})
             .then(([url, response]) => {
-              /* metadata exists on Firecrawl/Serper responses but not on
-               * Tavily's. Read it via the scraper's extractMetadata abstraction
-               * to stay polymorphic across all scraper providers. */
-              const rawMeta = scraper.extractMetadata(response);
               const attribution = getAttribution(
                 url,
-                Object.keys(rawMeta).length > 0 ? rawMeta : undefined,
+                response.data?.metadata,
                 logger_
               );
               if (response.success && response.data) {