fix(embeddings): override stale block params instead of omitting them

Review round 3.

The generic handler merges the params() result over the original inputs
(`{ ...inputs, ...transformedParams }`), so omitting a key leaves the stale
value in place. The previous round dropped an unsupported taskType or
dimensions by omission, which was therefore a no-op through the executor
path: a reduction or task type chosen for one model still reached the tool
after a model switch.

Rewrite each stale field to an explicit `undefined`, which does override in a
spread.

Same class of bug for `model` itself, which was forwarded whenever present
without checking it belongs to the selected provider. Every provider's model
dropdown shares the `model` id, so switching provider kept the previous
provider's model and failed at the route as a mismatch. It now falls back to
the provider's default unless the saved model actually belongs to it.

Tests assert the merged result rather than the returned object, since the
return shape alone cannot distinguish an omitted key from an overridden one —
which is exactly why the previous fix looked correct and was not.

Author: mzxchandra

apps/sim/blocks/blocks/embeddings.test.ts

@@ -149,6 +149,67 @@ describe('Embeddings block', () => {
    * clears a stored subblock value when its `dependsOn` fields change, so a
    * reduction chosen for one model outlives a switch to another.
    */
+  /**
+   * The generic handler merges this result over the original inputs
+   * (`{ ...inputs, ...transformedParams }`), so omitting a stale key leaves the
+   * old value in place. Only an explicit `undefined` overrides it — asserting
+   * the merged result is what actually pins the behavior.
+   */
+  describe('stale values are overridden, not merely omitted', () => {
+    const mergeLikeExecutor = (inputs: Record<string, unknown>) => ({
+      ...inputs,
+      ...EmbeddingsBlock.tools.config?.params?.(inputs),
+    })
+
+    it('overrides a dimension the selected model does not offer', () => {
+      const merged = mergeLikeExecutor({
+        provider: 'openai',
+        model: 'text-embedding-3-small',
+        input: 'hello',
+        apiKey: 'k',
+        dimensions: '3072',
+      })
+
+      expect(merged.dimensions).toBeUndefined()
+    })
+
+    it('overrides a task type the selected model does not offer', () => {
+      const merged = mergeLikeExecutor({
+        provider: 'openai',
+        model: 'text-embedding-3-small',
+        input: 'hello',
+        apiKey: 'k',
+        taskType: 'similarity',
+      })
+
+      expect(merged.taskType).toBeUndefined()
+    })
+
+    it('replaces a model left over from a previous provider', () => {
+      // Selecting Cohere with OpenAI's model still stored must not reach the
+      // route, which rejects it as a provider mismatch.
+      const merged = mergeLikeExecutor({
+        provider: 'cohere',
+        model: 'text-embedding-3-large',
+        input: 'hello',
+        apiKey: 'k',
+      })
+
+      expect(merged.model).toBe('embed-v4.0')
+    })
+
+    it('keeps a model that does belong to the selected provider', () => {
+      const merged = mergeLikeExecutor({
+        provider: 'openai',
+        model: 'text-embedding-3-large',
+        input: 'hello',
+        apiKey: 'k',
+      })
+
+      expect(merged.model).toBe('text-embedding-3-large')
+    })
+  })
+
   it('drops a dimension the newly selected model no longer offers', () => {
     const params = EmbeddingsBlock.tools.config?.params
 

apps/sim/blocks/blocks/embeddings.ts

@@ -273,38 +273,54 @@ export const EmbeddingsBlock: BlockConfig<EmbeddingsResponse> = {
         const provider = params.provider as EmbeddingCatalogProvider
         return TOOL_ID_BY_PROVIDER[provider] ?? TOOL_ID_BY_PROVIDER.openai
       },
+      /**
+       * Every per-provider dropdown shares one subblock id (`model`,
+       * `taskType`, `dimensions`) and nothing clears a stored value when its
+       * `dependsOn` fields change, so a choice made for one provider or model
+       * outlives a switch away from it.
+       *
+       * Each stale field is therefore rewritten to an explicit `undefined`
+       * rather than omitted. The generic handler merges this result over the
+       * original inputs (`{ ...inputs, ...transformedParams }`), so an omitted
+       * key leaves the stale value untouched — only an explicit `undefined`
+       * overrides it.
+       */
       params: (params) => {
         const provider = (params.provider as EmbeddingCatalogProvider) || 'openai'
         if (!params.input) {
           throw new Error('Input text is required')
         }
-        const model = params.model || DEFAULT_MODEL_BY_PROVIDER[provider]
+
+        /** A model saved under a previous provider must not survive the switch. */
+        const savedModel = params.model as string | undefined
+        const model =
+          savedModel && EMBEDDING_MODELS[savedModel]?.provider === provider
+            ? savedModel
+            : DEFAULT_MODEL_BY_PROVIDER[provider]
+
         const info = EMBEDDING_MODELS[model]
-        const dimensions =
+        const requested =
           params.dimensions !== undefined && params.dimensions !== ''
             ? Number(params.dimensions)
             : undefined
+        const dimensions =
+          requested !== undefined &&
+          !Number.isNaN(requested) &&
+          info?.supportedDimensions?.includes(requested)
+            ? requested
+            : undefined
+        const taskType =
+          params.taskType &&
+          info?.supportedTaskTypes?.includes(params.taskType as EmbeddingTaskType)
+            ? (params.taskType as EmbeddingTaskType)
+            : undefined
 
         return {
           apiKey: params.apiKey,
           input: params.input,
           model,
-          /** Only send capabilities the selected model actually declares. */
-          ...(info?.supportedTaskTypes &&
-            params.taskType &&
-            info.supportedTaskTypes.includes(params.taskType as EmbeddingTaskType) && {
-              taskType: params.taskType,
-            }),
-          /**
-           * Every per-model Dimensions dropdown shares the `dimensions` id, and
-           * switching models does not clear the stored value — so a reduction
-           * picked for one model can outlive it. Drop anything the current model
-           * no longer offers and fall back to its native size, rather than
-           * sending a value the dropdown stopped presenting.
-           */
-          ...(dimensions !== undefined &&
-            !Number.isNaN(dimensions) &&
-            info?.supportedDimensions?.includes(dimensions) && { dimensions }),
+          taskType,
+          dimensions,
         }
       },
     },