fix(langsmith,firecrawl): reverse two changes that made things worse

langsmith value: widening the param to 'json' made buildParameterSchema
advertise {"type":"object"} to every model, so an agent could no longer send
the ordinary scalar case the spec union exists for. Reverted to string.
The real bug was elsewhere: parseLangsmithFeedbackValue ran only in the block's
param mapper, so the LLM and direct-tool paths got no coercion at all. It now
runs in request.body. Also closed three parser gaps -- the literal text 'null'
was posting JSON null, and '1.0', '007' and long numeric ids lost their form.
The round-trip guard is scoped to numbers so objects still parse.

langsmith sessionId: the description invented a deprecation date. POST
/api/v1/feedback is not deprecated and returns no sunset header; the 31 Jan
2027 date belongs to the run-read endpoint. Now quotes only the migration doc
and the spec field description, and tells the caller never to guess the UUID,
naming the two places it actually comes from.

firecrawl search: flattening the source-keyed response into one array was the
wrong call. news items carry snippet not description, images' url is the
containing page while imageUrl is the image, position is per-source, and
metadata is absent for images -- so the flattened array silently mislabelled or
dropped every non-web field. The declared output is now the envelope Firecrawl
documents, with three separately typed optional arrays. limit is per-source, so
three sources at limit 100 returns up to 300 results; the description says so.

Also: ignoreInvalidURLs was declared for search but its subBlock condition
listed only batch_scrape.

Author: waleedlatif1

apps/sim/blocks/blocks/firecrawl.ts

@@ -300,7 +300,7 @@ Example 2 - Product Data:
       title: 'Ignore Invalid URLs',
       type: 'switch',
       mode: 'advanced',
-      condition: { field: 'operation', value: 'batch_scrape' },
+      condition: { field: 'operation', value: ['batch_scrape', 'search'] },
     },
     {
       id: 'waitFor',
@@ -554,6 +554,9 @@ Example 2 - Product Data:
             if (query) result.query = query
             if (timeout) result.timeout = Number.parseInt(timeout)
             if (limit) result.limit = Number.parseInt(limit)
+            if (params.ignoreInvalidURLs != null) {
+              result.ignoreInvalidURLs = params.ignoreInvalidURLs
+            }
             break
 
           case 'crawl':

apps/sim/blocks/blocks/langsmith.ts

@@ -178,7 +178,7 @@ export const LangsmithBlock: BlockConfig<LangsmithResponse> = {
       id: 'session_id',
       title: 'Session ID',
       type: 'short-input',
-      placeholder: 'Session identifier',
+      placeholder: 'Tracing project (session) UUID, e.g. 018e4c7e-a9fb-7ef0-a5b6-6ea3a82e9327',
       condition: {
         field: 'operation',
         value: ['langsmith_create_run', 'langsmith_create_feedback'],
@@ -456,7 +456,8 @@ Common patch fields: outputs, end_time, status, error`,
     trace_id: { type: 'string', description: 'Trace ID' },
     session_id: {
       type: 'string',
-      description: 'Tracing project (session) ID for the run or the feedback',
+      description:
+        'UUID of the tracing project (session) the run or the feedback belongs to. Required by LangSmith when creating feedback.',
     },
     session_name: { type: 'string', description: 'Session name' },
     status: { type: 'string', description: 'Run status' },

apps/sim/tools/firecrawl/search.test.ts

@@ -2,16 +2,9 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { flattenFirecrawlSearchResults, searchTool } from '@/tools/firecrawl/search'
+import { searchTool } from '@/tools/firecrawl/search'
 import type { SearchParams } from '@/tools/firecrawl/types'
 
-const result = (url: string) => ({
-  title: url,
-  description: 'd',
-  url,
-  metadata: { sourceURL: url },
-})
-
 const jsonOk = (body: unknown) =>
   new Response(JSON.stringify(body), {
     status: 200,
@@ -23,56 +16,91 @@ const searchParams: SearchParams = { apiKey: 'test-key', query: 'sim' }
 const resolveBody = (params: SearchParams): Record<string, unknown> =>
   searchTool.request.body!(params) as Record<string, unknown>
 
-describe('firecrawl search result flattening', () => {
-  it('flattens the default web-only envelope into the declared array', async () => {
+const dataOutputProperties = (): Record<string, any> =>
+  (searchTool.outputs.data as { properties: Record<string, any> }).properties
+
+describe('firecrawl search response shape', () => {
+  it('keeps the source-keyed envelope Firecrawl returns', async () => {
     const response = await searchTool.transformResponse!(
-      jsonOk({ data: { web: [result('https://a'), result('https://b')] }, creditsUsed: 2 }),
+      jsonOk({
+        success: true,
+        data: {
+          web: [{ title: 'w', description: 'd', url: 'https://web' }],
+          news: [{ title: 'n', snippet: 's', url: 'https://news', position: 1 }],
+          images: [{ title: 'i', imageUrl: 'https://img.png', url: 'https://page', position: 1 }],
+        },
+        creditsUsed: 3,
+        id: 'job-1',
+        warning: 'partial',
+      }),
       searchParams
     )
 
-    expect(Array.isArray(response.output.data)).toBe(true)
-    expect(response.output.data.map((item) => item.url)).toEqual(['https://a', 'https://b'])
-    expect(response.output.creditsUsed).toBe(2)
+    expect(response.output.data.web?.[0]?.url).toBe('https://web')
+    expect(response.output.data.news?.[0]?.snippet).toBe('s')
+    expect(response.output.data.images?.[0]?.imageUrl).toBe('https://img.png')
+    expect(response.output.creditsUsed).toBe(3)
+    expect(response.output.id).toBe('job-1')
+    expect(response.output.warning).toBe('partial')
   })
 
-  it('concatenates multiple sources in web, news, images order', () => {
-    const flattened = flattenFirecrawlSearchResults({
-      images: [result('https://image')],
-      news: [result('https://news')],
-      web: [result('https://web')],
-    })
+  it('leaves unrequested source arrays absent rather than inventing empties', async () => {
+    const response = await searchTool.transformResponse!(
+      jsonOk({ success: true, data: { web: [] }, creditsUsed: 1 }),
+      searchParams
+    )
 
-    expect(flattened.map((item) => item.url)).toEqual([
-      'https://web',
-      'https://news',
-      'https://image',
-    ])
+    expect(response.output.data.web).toEqual([])
+    expect(response.output.data.news).toBeUndefined()
+    expect(response.output.data.images).toBeUndefined()
   })
 
-  it('appends unknown future source keys alphabetically after the known ones', () => {
-    const flattened = flattenFirecrawlSearchResults({
-      web: [result('https://web')],
-      videos: [result('https://video')],
-      podcasts: [result('https://podcast')],
-    })
+  it('yields an empty envelope when the payload carries no data object', async () => {
+    const response = await searchTool.transformResponse!(jsonOk({ success: true }), searchParams)
+
+    expect(response.output.data).toEqual({})
+  })
+})
+
+describe('firecrawl search declared outputs', () => {
+  it('declares data as a source-keyed object, not a flat array', () => {
+    expect(searchTool.outputs.data.type).toBe('object')
+    expect(Object.keys(dataOutputProperties()).sort()).toEqual(['images', 'news', 'web'])
+  })
+
+  it('makes every source array optional, since which appear depends on sources', () => {
+    for (const source of ['web', 'news', 'images']) {
+      expect(dataOutputProperties()[source].optional, `${source} must be optional`).toBe(true)
+      expect(dataOutputProperties()[source].type).toBe('array')
+    }
+  })
 
-    expect(flattened.map((item) => item.url)).toEqual([
-      'https://web',
-      'https://podcast',
-      'https://video',
-    ])
+  it('declares news items with snippet, the field news actually carries', () => {
+    const news = dataOutputProperties().news.items.properties
+    expect(news.snippet).toBeDefined()
+    expect(news.description).toBeUndefined()
+    expect(news.date).toBeDefined()
   })
 
-  it('passes a plain array through unchanged', () => {
-    const flattened = flattenFirecrawlSearchResults([result('https://a')])
-    expect(flattened.map((item) => item.url)).toEqual(['https://a'])
+  it('declares imageUrl on image items and does not claim they carry metadata', () => {
+    const images = dataOutputProperties().images.items.properties
+    expect(images.imageUrl).toBeDefined()
+    expect(images.imageWidth).toBeDefined()
+    expect(images.metadata).toBeUndefined()
+    expect(images.markdown).toBeUndefined()
   })
 
-  it('yields an empty array for a missing or non-object payload', () => {
-    expect(flattenFirecrawlSearchResults(undefined)).toEqual([])
-    expect(flattenFirecrawlSearchResults(null)).toEqual([])
-    expect(flattenFirecrawlSearchResults('nope')).toEqual([])
-    expect(flattenFirecrawlSearchResults({ web: 'not-an-array' })).toEqual([])
+  it('declares web items with description and optional scraped metadata', () => {
+    const web = dataOutputProperties().web.items.properties
+    expect(web.description).toBeDefined()
+    expect(web.snippet).toBeUndefined()
+    expect(web.metadata.optional).toBe(true)
+  })
+
+  it('declares the envelope fields the endpoint actually returns', () => {
+    expect(searchTool.outputs.creditsUsed).toBeDefined()
+    expect(searchTool.outputs.warning).toBeDefined()
+    expect(searchTool.outputs.id).toBeDefined()
   })
 })
 
@@ -96,6 +124,14 @@ describe('firecrawl search request params', () => {
     }
   })
 
+  it('documents limit as per-source, since it is not a total across sources', () => {
+    expect(searchTool.params.limit.description).toMatch(/per source/i)
+  })
+
+  it('does not promise that results are flattened into one array', () => {
+    expect(searchTool.params.sources.description).not.toMatch(/flatten/i)
+  })
+
   it('sends the declared optional params on the wire', () => {
     const body = resolveBody({
       apiKey: 'test-key',
@@ -123,3 +159,25 @@ describe('firecrawl search request params', () => {
     })
   })
 })
+
+describe('firecrawl block search wiring', () => {
+  it('exposes ignoreInvalidURLs on search, which also accepts it', async () => {
+    const { FirecrawlBlock } = await import('@/blocks/blocks/firecrawl')
+    const subBlock = FirecrawlBlock.subBlocks.find((block) => block.id === 'ignoreInvalidURLs')
+
+    expect(subBlock?.condition).toMatchObject({ field: 'operation' })
+    expect((subBlock?.condition as { value: string[] }).value).toContain('search')
+  })
+
+  it('maps ignoreInvalidURLs into the search request params', async () => {
+    const { FirecrawlBlock } = await import('@/blocks/blocks/firecrawl')
+    const params = FirecrawlBlock.tools.config!.params!({
+      operation: 'search',
+      apiKey: 'k',
+      query: 'sim',
+      ignoreInvalidURLs: true,
+    })
+
+    expect(params.ignoreInvalidURLs).toBe(true)
+  })
+})

apps/sim/tools/firecrawl/search.ts

@@ -3,48 +3,10 @@ import {
   applyFirecrawlScrapeOptionsModelInput,
   selectFirecrawlScrapeOptionsModelInput,
 } from '@/tools/firecrawl/model-input'
-import type { SearchParams, SearchResponse, SearchResultItem } from '@/tools/firecrawl/types'
-import { SEARCH_RESULT_OUTPUT_PROPERTIES } from '@/tools/firecrawl/types'
+import type { FirecrawlSearchData, SearchParams, SearchResponse } from '@/tools/firecrawl/types'
+import { SEARCH_DATA_OUTPUT } from '@/tools/firecrawl/types'
 import type { ToolConfig } from '@/tools/types'
 
-/**
- * Source keys Firecrawl documents for `POST /v2/search`, in the order their
- * results are concatenated. Listing them explicitly — rather than relying on
- * object key order — keeps the flattened output stable no matter what order
- * the API happens to serialize the envelope in.
- */
-const FIRECRAWL_SEARCH_SOURCE_ORDER = ['web', 'news', 'images'] as const
-
-/**
- * Flattens the source-keyed search envelope into the single result array this
- * tool declares.
- *
- * Firecrawl returns `data` keyed by source ("The arrays available will depend
- * on the sources you specified in the request. By default, the `web` array
- * will be returned."), so `data.data` is `{ web: [...], news: [...], images:
- * [...] }` — not the array `outputs.data` advertises. Known sources come first
- * in {@link FIRECRAWL_SEARCH_SOURCE_ORDER}, then any future source key in
- * alphabetical order; a plain array is passed through unchanged, and anything
- * else yields `[]`.
- */
-export const flattenFirecrawlSearchResults = (data: unknown): SearchResultItem[] => {
-  if (Array.isArray(data)) return data as SearchResultItem[]
-  if (data === null || typeof data !== 'object') return []
-
-  const envelope = data as Record<string, unknown>
-  const knownKeys = FIRECRAWL_SEARCH_SOURCE_ORDER as readonly string[]
-  const extraKeys = Object.keys(envelope)
-    .filter((key) => !knownKeys.includes(key))
-    .sort()
-
-  const flattened: SearchResultItem[] = []
-  for (const key of [...knownKeys, ...extraKeys]) {
-    const results = envelope[key]
-    if (Array.isArray(results)) flattened.push(...(results as SearchResultItem[]))
-  }
-  return flattened
-}
-
 export const searchTool: ToolConfig<SearchParams, SearchResponse> = {
   id: 'firecrawl_search',
   name: 'Firecrawl Search',
@@ -62,14 +24,15 @@ export const searchTool: ToolConfig<SearchParams, SearchResponse> = {
       type: 'number',
       required: false,
       visibility: 'user-or-llm',
-      description: 'Maximum number of results to return (Firecrawl default: 10)',
+      description:
+        'Maximum number of results to return per source type, not in total (Firecrawl default: 10, maximum: 100). Requesting three sources at limit 100 can return up to 300 results.',
     },
     sources: {
       type: 'array',
       required: false,
       visibility: 'user-or-llm',
       description:
-        'Result sources to search. Defaults to ["web"]. Results from every requested source are flattened into `data` in web, news, images order.',
+        'Result sources to search: "web", "news", and/or "images". Defaults to ["web"]. Each requested source is returned as its own array under `data` — `data.web`, `data.news`, `data.images` — with its own item fields.',
       items: { type: 'string' },
     },
     categories: {
@@ -167,25 +130,35 @@ export const searchTool: ToolConfig<SearchParams, SearchResponse> = {
   },
 
   transformResponse: async (response: Response) => {
-    const data = await response.json()
+    const payload = await response.json()
+    const data = payload?.data
 
     return {
       success: true,
       output: {
-        data: flattenFirecrawlSearchResults(data?.data),
-        creditsUsed: data?.creditsUsed,
+        data:
+          data && typeof data === 'object' && !Array.isArray(data)
+            ? (data as FirecrawlSearchData)
+            : {},
+        warning: payload?.warning ?? undefined,
+        id: payload?.id,
+        creditsUsed: payload?.creditsUsed,
       },
     }
   },
 
   outputs: {
-    data: {
-      type: 'array',
-      description: 'Search results data with scraped content and metadata',
-      items: {
-        type: 'object',
-        properties: SEARCH_RESULT_OUTPUT_PROPERTIES,
-      },
+    data: SEARCH_DATA_OUTPUT,
+    warning: {
+      type: 'string',
+      description: 'Warning message if any issues occurred during the search',
+      optional: true,
+    },
+    id: { type: 'string', description: 'ID of the search job', optional: true },
+    creditsUsed: {
+      type: 'number',
+      description: 'Number of credits the search consumed',
+      optional: true,
     },
   },
 }