Function createFunctionRuntimeBrokers

apps/sim/app/api/function/execute/route.ts:789–867

(
  context: FunctionRouteExecutionContext
)

}

function createFunctionRuntimeBrokers(
  context: FunctionRouteExecutionContext
): Record<string, IsolatedVMBrokerHandler> {
  context.largeValueKeys ??= []
  context.fileKeys ??= []
  const largeValueKeys = context.largeValueKeys
  const fileKeys = context.fileKeys
  const base = {
    requestId: context.requestId,
    workflowId: context.workflowId,
    workspaceId: context.workspaceId,
    executionId: context.executionId,
    largeValueExecutionIds: context.largeValueExecutionIds,
    largeValueKeys,
    fileKeys,
    allowLargeValueWorkflowScope: context.allowLargeValueWorkflowScope,
    userId: context.userId,
    logger,
  }

  const recordMaterializedKeys = (value: unknown) =>
    recordMaterializedAccessKeys({ largeValueKeys, fileKeys }, value)

  const readFile = async (args: unknown, encoding: 'base64' | 'text', chunked = false) => {
    const fileArgs = getBrokerFileArgs(args)
    return readUserFileContent(fileArgs.file, {
      ...base,
      encoding,
      maxBytes: fileArgs.maxBytes,
      chunked,
      offset: chunked ? fileArgs.offset : undefined,
      length: chunked ? fileArgs.length : undefined,
    })
  }

  return {
    'sim.files.readBase64': (args) => readFile(args, 'base64'),
    'sim.files.readText': (args) => readFile(args, 'text'),
    'sim.files.readBase64Chunk': (args) => readFile(args, 'base64', true),
    'sim.files.readTextChunk': (args) => readFile(args, 'text', true),
    'sim.values.read': async (args) => {
      const record = asRecord(args)
      const options = asRecord(record.options)
      const ref = record.ref
      if (!isLargeValueRef(ref)) {
        throw new Error('Expected a large execution value reference.')
      }
      if (!context.executionId) {
        throw new Error('Large execution values require an execution context.')
      }
      const value = await materializeLargeValueRef(ref, {
        ...base,
        maxBytes: clampInlineBytes(options.maxBytes, MAX_INLINE_MATERIALIZATION_BYTES),
      })
      if (value === undefined) {
        throw unavailableLargeValueError(ref)
      }
      recordMaterializedKeys(value)