fix(deps): preserve runtime compatibility

Author: waleedlatif1

apps/sim/blocks/pi-model-options.test.ts

@@ -13,7 +13,15 @@ const originalOpenRouterModels = useProvidersStore.getState().providers.openrout
 describe('Pi model options', () => {
   beforeAll(() => {
     const store = useProvidersStore.getState()
-    store.setProviderModels('base', ['claude-sonnet-4-6', 'claude-sonnet-4-0', 'gpt-5.4'])
+    store.setProviderModels('base', [
+      'claude-sonnet-4-6',
+      'claude-opus-4-1',
+      'claude-sonnet-4-0',
+      'gpt-5.4',
+      'cerebras/zai-glm-4.7',
+      'glm-5.1',
+      'glm-4.5-air',
+    ])
     store.setProviderModels('openrouter', [
       'openrouter/openai/gpt-5',
       'openrouter/openrouter/fusion',
@@ -43,6 +51,15 @@ describe('Pi model options', () => {
     expect(modelIds).not.toContain('claude-sonnet-4-0')
   })
 
+  it('keeps persisted and selectable models available', () => {
+    const modelIds = getPiModelOptions().map(({ id }) => id)
+
+    expect(modelIds).toContain('claude-opus-4-1')
+    expect(modelIds).toContain('cerebras/zai-glm-4.7')
+    expect(modelIds).toContain('glm-5.1')
+    expect(modelIds).toContain('glm-4.5-air')
+  })
+
   it("does not apply OpenRouter capability filters beyond Pi's catalog", () => {
     const modelIds = getPiModelOptions().map(({ id }) => id)
 

apps/sim/executor/handlers/pi/core/pi-sdk.test.ts

@@ -21,9 +21,7 @@ describe('createSealedPiResourceLoader', () => {
     })
     expect(loader.getAgentsFiles()).toEqual({ agentsFiles: [] })
     expect(loader.getSystemPrompt()).toBe('sealed system prompt')
-    expect(loader.getSystemPromptSource()).toBeUndefined()
     expect(loader.getAppendSystemPrompt()).toEqual([])
-    expect(loader.getAppendSystemPromptSources()).toEqual([])
     await expect(loader.reload()).resolves.toBeUndefined()
   })
 })

apps/sim/executor/handlers/pi/core/pi-sdk.ts

@@ -90,9 +90,7 @@ export function createSealedPiResourceLoader(sdk: PiSdk, systemPrompt: string):
     getThemes: () => ({ themes: [], diagnostics: [] }),
     getAgentsFiles: () => ({ agentsFiles: [] }),
     getSystemPrompt: () => systemPrompt,
-    getSystemPromptSource: () => undefined,
     getAppendSystemPrompt: () => [],
-    getAppendSystemPromptSources: () => [],
     extendResources: () => {},
     reload: async () => {},
   }

apps/sim/executor/handlers/pi/pi-handler.test.ts

@@ -267,6 +267,19 @@ describe('PiBlockHandler', () => {
     expect(mockResolveKey).not.toHaveBeenCalled()
   })
 
+  it('passes a persisted catalog model to the backend', async () => {
+    mockGetProviderFromModel.mockReturnValue('cerebras')
+    mockResolvePiModelId.mockReturnValue('zai-glm-4.7')
+
+    await handler.execute(ctx(), block, localInputs({ model: 'cerebras/zai-glm-4.7' }))
+
+    expect(mockRunLocal.mock.calls[0][0]).toMatchObject({
+      model: 'cerebras/zai-glm-4.7',
+      piModel: 'zai-glm-4.7',
+      providerId: 'cerebras',
+    })
+  })
+
   it('routes Local Dev to the local backend with SSH params', async () => {
     const output = await handler.execute(ctx(), block, localInputs())
     expect(mockRunLocal).toHaveBeenCalledTimes(1)

apps/sim/lib/internal/file/parser.test.ts

@@ -3,6 +3,8 @@
  *
  * @vitest-environment node
  */
+
+import { Readable } from 'node:stream'
 import {
   authMockFns,
   createMockRequest,
@@ -24,15 +26,15 @@ const {
   mockGetStorageProvider,
   mockIsUsingCloudStorage,
   mockIsSupportedFileType,
-  mockParseFile,
   mockParseBuffer,
   mockPdfParseBuffer,
+  mockCreateReadStream,
   mockFsAccess,
   mockFsStat,
-  mockFsReadFile,
   mockFsWriteFile,
   mockJoin,
   actualPath,
+  mockUploadExecutionFile,
   mockUploadWorkspaceFile,
   mockReadWorkspaceFileNameByKey,
 } = vi.hoisted(() => {
@@ -44,10 +46,6 @@ const {
     mockGetStorageProvider: vi.fn().mockReturnValue('s3'),
     mockIsUsingCloudStorage: vi.fn().mockReturnValue(true),
     mockIsSupportedFileType: vi.fn().mockReturnValue(true),
-    mockParseFile: vi.fn().mockResolvedValue({
-      content: 'parsed content',
-      metadata: { pageCount: 1 },
-    }),
     mockParseBuffer: vi.fn().mockResolvedValue({
       content: 'parsed buffer content',
       metadata: { pageCount: 1 },
@@ -56,9 +54,9 @@ const {
       content: 'parsed PDF content',
       metadata: { pageCount: 1 },
     }),
+    mockCreateReadStream: vi.fn(),
     mockFsAccess: vi.fn().mockResolvedValue(undefined),
     mockFsStat: vi.fn().mockImplementation(() => ({ isFile: () => true, size: 17 })),
-    mockFsReadFile: vi.fn().mockResolvedValue(Buffer.from('test file content')),
     mockFsWriteFile: vi.fn().mockResolvedValue(undefined),
     mockJoin: vi.fn((...args: string[]): string => {
       if (args[0] === '/test/uploads') {
@@ -67,6 +65,7 @@ const {
       return actualPath.join(...args)
     }),
     actualPath,
+    mockUploadExecutionFile: vi.fn(),
     mockUploadWorkspaceFile: vi
       .fn()
       .mockImplementation(
@@ -98,10 +97,13 @@ vi.mock('@/lib/uploads', () => ({
 
 vi.mock('@/lib/file-parsers', () => ({
   isSupportedFileType: mockIsSupportedFileType,
-  parseFile: mockParseFile,
   parseBuffer: mockParseBuffer,
 }))
 
+vi.mock('node:fs', () => ({
+  createReadStream: mockCreateReadStream,
+}))
+
 vi.mock('@/lib/file-parsers/pdf-parser', () => ({
   PdfParser: class {
     parseBuffer(...args: Parameters<typeof mockPdfParseBuffer>) {
@@ -131,7 +133,7 @@ vi.mock('@/lib/core/utils/logging', () => ({
 }))
 
 vi.mock('@/lib/uploads/contexts/execution', () => ({
-  uploadExecutionFile: vi.fn(),
+  uploadExecutionFile: mockUploadExecutionFile,
 }))
 
 vi.mock('@/lib/uploads/contexts/workspace/workspace-file-manager', () => ({
@@ -152,12 +154,10 @@ vi.mock('fs/promises', () => ({
   default: {
     access: mockFsAccess,
     stat: mockFsStat,
-    readFile: mockFsReadFile,
     writeFile: mockFsWriteFile,
   },
   access: mockFsAccess,
   stat: mockFsStat,
-  readFile: mockFsReadFile,
   writeFile: mockFsWriteFile,
 }))
 
@@ -241,14 +241,19 @@ describe('file parser operation', () => {
     storageServiceMockFns.mockHasCloudStorage.mockReturnValue(true)
     storageServiceMockFns.mockDownloadFile.mockResolvedValue(Buffer.from('test file content'))
     mockFsStat.mockResolvedValue({ isFile: () => true, size: 17 })
-    mockFsReadFile.mockResolvedValue(Buffer.from('test file content'))
+    mockCreateReadStream.mockImplementation(() => Readable.from([Buffer.from('test file content')]))
     mockIsSupportedFileType.mockReturnValue(true)
+    mockUploadExecutionFile.mockResolvedValue({
+      id: 'file_test',
+      name: 'report.pdf',
+      url: '/api/files/serve/execution/report.pdf',
+      size: 17,
+      type: 'application/pdf',
+      key: 'execution/report.pdf',
+      context: 'execution',
+    })
     mockUploadWorkspaceFile.mockClear()
     mockReadWorkspaceFileNameByKey.mockResolvedValue({ name: null })
-    mockParseFile.mockResolvedValue({
-      content: 'parsed content',
-      metadata: { pageCount: 1 },
-    })
     mockParseBuffer.mockResolvedValue({
       content: 'parsed buffer content',
       metadata: { pageCount: 1 },
@@ -422,21 +427,39 @@ describe('file parser operation', () => {
     })
   })
 
-  it('forwards request cancellation to local file parsing and reads', async () => {
+  it('parses and uploads one bounded local-file snapshot', async () => {
     setupFileApiMocks({
       cloudEnabled: false,
       storageProvider: 'local',
       authenticated: true,
     })
+    mockFsStat.mockResolvedValue({ isFile: () => true, size: 3 })
     const req = createMockRequest('POST', {
       filePath: 'workspace/report.pdf',
     })
 
     const response = await POST(req)
 
+    const data = await response.json()
+    const parsedBuffer = mockParseBuffer.mock.calls[0][0]
+
     expect(response.status).toBe(200)
-    expect(mockParseFile).toHaveBeenCalledWith(expect.any(String), { signal: req.signal })
-    expect(mockFsReadFile).toHaveBeenCalledWith(expect.any(String), { signal: req.signal })
+    expect(data.output).toMatchObject({
+      content: 'parsed buffer content',
+      fileType: 'application/pdf',
+      size: 17,
+    })
+    expect(mockCreateReadStream).toHaveBeenCalledWith('/test/uploads/workspace/report.pdf')
+    expect(mockCreateReadStream).toHaveBeenCalledOnce()
+    expect(mockParseBuffer).toHaveBeenCalledWith(parsedBuffer, 'pdf', { signal: req.signal })
+    expect(mockParseBuffer).toHaveBeenCalledOnce()
+    expect(mockUploadExecutionFile).toHaveBeenCalledWith(
+      expect.any(Object),
+      parsedBuffer,
+      'report.pdf',
+      'application/pdf',
+      'test-user-id'
+    )
   })
 
   it('should reject parser complexity limits instead of returning raw text', async () => {
@@ -740,7 +763,9 @@ describe('file parser operation', () => {
     expect(response.status).toBe(200)
     expect(data.success).toBe(false)
     expect(data.error).toContain('too large')
-    expect(mockFsReadFile).not.toHaveBeenCalled()
+    expect(mockCreateReadStream).not.toHaveBeenCalled()
+    expect(mockParseBuffer).not.toHaveBeenCalled()
+    expect(mockUploadExecutionFile).not.toHaveBeenCalled()
   })
 
   it('should process execution file URLs with context query param', async () => {

apps/sim/lib/internal/file/parser.ts

@@ -1,3 +1,4 @@
+import { createReadStream } from 'node:fs'
 import { Buffer, isUtf8 } from 'buffer'
 import { createHash } from 'crypto'
 import fsPromises from 'fs/promises'
@@ -10,12 +11,16 @@ import binaryExtensionsList from 'binary-extensions'
 import type { ContractBody } from '@/lib/api/contracts'
 import type { fileParseContract } from '@/lib/api/contracts/storage-transfer'
 import { sanitizeUrlForLog } from '@/lib/core/utils/logging'
-import { assertKnownSizeWithinLimit, isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
+import {
+  assertKnownSizeWithinLimit,
+  isPayloadSizeLimitError,
+  readNodeStreamToBufferWithLimit,
+} from '@/lib/core/utils/stream-limits'
 import {
   assertUserFileContentAccess,
   type ExecutionMaterializationContext,
 } from '@/lib/execution/payloads/materialization.server'
-import { isSupportedFileType, parseFile } from '@/lib/file-parsers'
+import { isSupportedFileType, parseBuffer } from '@/lib/file-parsers'
 import { isFileParserError } from '@/lib/file-parsers/errors'
 import { isUsingCloudStorage, StorageService } from '@/lib/uploads'
 import { uploadExecutionFile } from '@/lib/uploads/contexts/execution'
@@ -881,13 +886,17 @@ async function handleLocalFile(
     const stats = await fsPromises.stat(fullPath)
     assertKnownSizeWithinLimit(stats.size, maxDownloadBytes, 'local file')
 
-    const result = await parseFile(fullPath, { signal })
+    const fileBuffer = await readNodeStreamToBufferWithLimit(createReadStream(fullPath), {
+      maxBytes: maxDownloadBytes,
+      label: 'local file',
+      signal,
+    })
+    const extension = path.extname(filename).toLowerCase().substring(1)
+    const result = await parseBuffer(fileBuffer, extension, { signal })
     const content = assertParsedContentWithinLimit(result.content, maxParsedOutputBytes)
-    const fileBuffer = await fsPromises.readFile(fullPath, { signal })
     signal?.throwIfAborted()
     const hash = createHash('md5').update(fileBuffer).digest('hex')
 
-    const extension = path.extname(filename).toLowerCase().substring(1)
     const mimeType = fileType || getMimeTypeFromExtension(extension)
 
     // Store file in execution storage if executionContext is provided
@@ -916,7 +925,7 @@ async function handleLocalFile(
       userFile,
       metadata: {
         fileType: mimeType,
-        size: stats.size,
+        size: fileBuffer.length,
         hash,
         processingTime: 0,
       },

apps/sim/lib/internal/mysql/client.test.ts

@@ -3,18 +3,26 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { mockCreateConnection, mockNetConnect, mockValidateDatabaseHost } = vi.hoisted(() => ({
-  mockCreateConnection: vi.fn(),
-  mockNetConnect: vi.fn(),
-  mockValidateDatabaseHost: vi.fn(),
-}))
+const { mockCreateConnection, mockNetConnect, mockTypedParameterNull, mockValidateDatabaseHost } =
+  vi.hoisted(() => {
+    class MockTypedParameter {}
+    return {
+      mockCreateConnection: vi.fn(),
+      mockNetConnect: vi.fn(),
+      mockTypedParameterNull: vi.fn(() => new MockTypedParameter()),
+      mockValidateDatabaseHost: vi.fn(),
+    }
+  })
 
 vi.mock('node:net', () => ({
   default: { connect: mockNetConnect },
 }))
 
 vi.mock('mysql2/promise', () => ({
-  default: { createConnection: mockCreateConnection },
+  default: {
+    createConnection: mockCreateConnection,
+    TypedParameter: { NULL: mockTypedParameterNull },
+  },
 }))
 
 vi.mock('@/lib/core/security/input-validation.server', () => ({
@@ -123,4 +131,44 @@ describe('MySQL client', () => {
     )
     expect(connection.execute).not.toHaveBeenCalled()
   })
+
+  it.each([
+    new Map([['key', 'value']]),
+    new Set(['value']),
+    /value/,
+    Object.assign(Object.create(null) as Record<string, unknown>, { key: 'value' }),
+  ])('rejects non-plain structured bind values: %s', async (value) => {
+    const connection = { execute: vi.fn(), destroy: vi.fn() }
+
+    await expect(executeMysqlCommand(connection as never, 'SELECT ?', [value])).rejects.toThrow(
+      'MySQL bind values must contain only supported scalar or structured values'
+    )
+    expect(connection.execute).not.toHaveBeenCalled()
+  })
+
+  it('accepts nested plain structured bind values', async () => {
+    const result = { affectedRows: 1 }
+    const values = [{ nested: ['value', 1, true, null] }]
+    const connection = {
+      execute: vi.fn().mockResolvedValue([result]),
+      destroy: vi.fn(),
+    }
+
+    await expect(executeMysqlCommand(connection as never, 'SELECT ?', values)).resolves.toBe(result)
+    expect(connection.execute).toHaveBeenCalledWith('SELECT ?', values)
+  })
+
+  it('accepts mysql2 typed parameters', async () => {
+    const result = { affectedRows: 1 }
+    const typedParameter = mockTypedParameterNull()
+    const connection = {
+      execute: vi.fn().mockResolvedValue([result]),
+      destroy: vi.fn(),
+    }
+
+    await expect(
+      executeMysqlCommand(connection as never, 'SELECT ?', [typedParameter])
+    ).resolves.toBe(result)
+    expect(connection.execute).toHaveBeenCalledWith('SELECT ?', [typedParameter])
+  })
 })

apps/sim/lib/internal/mysql/client.ts

@@ -11,6 +11,8 @@ export interface MysqlConnectionConfig {
   ssl: 'disabled' | 'required' | 'preferred'
 }
 
+const MYSQL_TYPED_PARAMETER_PROTOTYPE = Object.getPrototypeOf(mysql.TypedParameter.NULL())
+
 function isMysqlExecuteValue(value: unknown): value is mysql.ExecuteValues {
   if (
     value === null ||
@@ -24,6 +26,9 @@ function isMysqlExecuteValue(value: unknown): value is mysql.ExecuteValues {
 
   if (Array.isArray(value)) return value.every(isMysqlExecuteValue)
   if (typeof value !== 'object') return false
+  const prototype = Object.getPrototypeOf(value)
+  if (prototype === MYSQL_TYPED_PARAMETER_PROTOTYPE) return true
+  if (prototype !== Object.prototype) return false
   return Object.values(value).every(isMysqlExecuteValue)
 }