fix(custom-tools): skip title conflicts when persisting inline tools from a workflow save

Author: waleedlatif1

apps/sim/lib/workflows/custom-tools/operations.ts

@@ -22,6 +22,13 @@ const logger = createLogger('CustomToolsOperations')
 
 export type CustomToolSortBy = 'title' | 'createdAt' | 'updatedAt'
 
+/**
+ * What `upsertCustomTools` does with a tool it would insert under a title the
+ * workspace already holds: `'error'` throws and rolls back the whole batch,
+ * `'skip'` leaves the existing row untouched and persists the rest.
+ */
+type CustomToolTitleConflictPolicy = 'error' | 'skip'
+
 /**
  * Internal function to create/update custom tools
  * Can be called from API routes or internal services
@@ -36,8 +43,15 @@ export async function upsertCustomTools(params: {
   workspaceId: string
   userId: string
   requestId?: string
+  onTitleConflict?: CustomToolTitleConflictPolicy
 }) {
-  const { tools, workspaceId, userId, requestId = generateRequestId() } = params
+  const {
+    tools,
+    workspaceId,
+    userId,
+    requestId = generateRequestId(),
+    onTitleConflict = 'error',
+  } = params
 
   /**
    * Ahead of the transaction so a batch is rejected whole rather than landing
@@ -106,6 +120,10 @@ export async function upsertCustomTools(params: {
         .limit(1)
 
       if (duplicateTitle.length > 0) {
+        if (onTitleConflict === 'skip') {
+          logger.info(`[${requestId}] Skipped custom tool "${tool.title}": title already exists`)
+          continue
+        }
         throw new Error(`A tool with the title "${tool.title}" already exists in this workspace`)
       }
 

apps/sim/lib/workflows/persistence/custom-tools-persistence.integration.ts

@@ -0,0 +1,142 @@
+/** Workflow-save persistence of inline custom tools, against real PostgreSQL. */
+import { db } from '@sim/db'
+import { customTools, user, workspace } from '@sim/db/schema'
+import { deleteWorkspaceFixture, insertWorkspaceFixture } from '@sim/db/testing/workspace-fixtures'
+import { generateId } from '@sim/utils/id'
+import { asc, eq } from 'drizzle-orm'
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest'
+import { upsertCustomTools } from '@/lib/workflows/custom-tools/operations'
+import { extractAndPersistCustomTools } from '@/lib/workflows/persistence/custom-tools-persistence'
+
+const owner = `custom-tools-owner-${generateId()}`
+const workspaceId = generateId()
+
+function declaration(name: string) {
+  return {
+    type: 'function' as const,
+    function: {
+      name,
+      description: `Runs ${name}`,
+      parameters: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] },
+    },
+  }
+}
+
+/** An agent block carrying inline custom tools with no `toolId`, as an imported graph does. */
+function workflowStateWithInlineTools(tools: Array<{ title: string; code: string }>) {
+  return {
+    blocks: {
+      agent: {
+        type: 'agent',
+        subBlocks: {
+          tools: {
+            value: tools.map((tool) => ({
+              type: 'custom-tool',
+              title: tool.title,
+              schema: declaration(tool.title.toLowerCase().replace(/\W+/g, '_')),
+              code: tool.code,
+            })),
+          },
+        },
+      },
+    },
+  }
+}
+
+async function workspaceTools() {
+  return db
+    .select({ title: customTools.title, code: customTools.code })
+    .from(customTools)
+    .where(eq(customTools.workspaceId, workspaceId))
+    .orderBy(asc(customTools.title))
+}
+
+beforeAll(async () => {
+  const now = new Date()
+  await db.insert(user).values({
+    id: owner,
+    name: 'Custom Tools',
+    email: `${owner}@custom-tools.test`,
+    emailVerified: true,
+    createdAt: now,
+    updatedAt: now,
+  })
+  await insertWorkspaceFixture(db, [
+    { id: workspaceId, name: 'Custom Tools', ownerId: owner, billedAccountUserId: owner },
+  ])
+})
+
+beforeEach(async () => {
+  await db.delete(customTools).where(eq(customTools.workspaceId, workspaceId))
+})
+
+afterAll(async () => {
+  await db.delete(customTools).where(eq(customTools.workspaceId, workspaceId))
+  await deleteWorkspaceFixture(db, eq(workspace.id, workspaceId))
+  await db.delete(user).where(eq(user.id, owner))
+})
+
+describe('extractAndPersistCustomTools', () => {
+  it('re-saves a graph whose inline tool has no id and still persists the new tools beside it', async () => {
+    const first = await extractAndPersistCustomTools(
+      workflowStateWithInlineTools([{ title: 'Lookup order', code: 'return 1' }]),
+      workspaceId,
+      owner
+    )
+    expect(first.errors).toEqual([])
+
+    const second = await extractAndPersistCustomTools(
+      workflowStateWithInlineTools([
+        { title: 'Lookup order', code: 'return 1' },
+        { title: 'Refund order', code: 'return 2' },
+      ]),
+      workspaceId,
+      owner
+    )
+
+    expect(second.errors).toEqual([])
+    expect(await workspaceTools()).toEqual([
+      { title: 'Lookup order', code: 'return 1' },
+      { title: 'Refund order', code: 'return 2' },
+    ])
+  })
+
+  it('leaves an existing workspace tool with the same title untouched', async () => {
+    await upsertCustomTools({
+      tools: [{ title: 'Lookup order', schema: declaration('lookup'), code: 'return "library"' }],
+      workspaceId,
+      userId: owner,
+    })
+
+    const result = await extractAndPersistCustomTools(
+      workflowStateWithInlineTools([{ title: 'Lookup order', code: 'return "inline"' }]),
+      workspaceId,
+      owner
+    )
+
+    expect(result.errors).toEqual([])
+    expect(await workspaceTools()).toEqual([{ title: 'Lookup order', code: 'return "library"' }])
+  })
+})
+
+describe('upsertCustomTools', () => {
+  it('rejects a create under a taken title and rolls back the rest of the batch', async () => {
+    await upsertCustomTools({
+      tools: [{ title: 'Lookup order', schema: declaration('lookup'), code: 'return 1' }],
+      workspaceId,
+      userId: owner,
+    })
+
+    await expect(
+      upsertCustomTools({
+        tools: [
+          { title: 'Refund order', schema: declaration('refund'), code: 'return 2' },
+          { title: 'Lookup order', schema: declaration('lookup'), code: 'return 3' },
+        ],
+        workspaceId,
+        userId: owner,
+      })
+    ).rejects.toThrow('A tool with the title "Lookup order" already exists in this workspace')
+    expect(await workspaceTools()).toEqual([{ title: 'Lookup order', code: 'return 1' }])
+  })
+})

apps/sim/lib/workflows/persistence/custom-tools-persistence.ts

@@ -116,6 +116,12 @@ export function extractCustomToolsFromWorkflowState(workflowState: any): CustomT
 /**
  * Persist custom tools to the database using the upsert function
  * Creates new tools or updates existing ones
+ *
+ * @remarks
+ * An inline tool carries no `toolId` until the block is re-saved with one, so
+ * every save of the same graph re-offers it under a title its first save
+ * already inserted. A title conflict therefore skips that tool, leaving the
+ * existing row untouched, instead of rolling back the rest of the batch.
  */
 export async function persistCustomToolsToDatabase(
   customToolsList: CustomTool[],
@@ -167,6 +173,7 @@ export async function persistCustomToolsToDatabase(
       })),
       workspaceId,
       userId,
+      onTitleConflict: 'skip',
     })
 
     saved = validTools.length