@teleporthq/teleport-plugin-next-workflows 0.43.51 → 0.43.54

package/__tests__/ai-chat-rag-sql-parameterization.test.ts

@@ -0,0 +1,237 @@
+import { parameterizeAllWorkflowRawSql } from '../src/raw-sql-param-binding'
+import { generateSqlValidatorCode } from '../src/sql-validator'
+
+/**
+ * The AI Assistant Chat's RAG pipeline used to assemble its SQL inside
+ * `general-custom-js` nodes and bind the resulting string to a `data-raw-query`.
+ * Every node result in a server segment is relayed to the visitor's browser, so
+ * that published the database schema: on the shipped store the browser received
+ *
+ *   INSERT INTO teleport_ai_chat_conversations (id, user_id, username, title,
+ *   status, message_count, last_message_at, created_at, updated_at) VALUES
+ *   ('ddefa366-…', '16017882-…', 'test', …)
+ *
+ * table names, column list, join keys and the signed-in user's uuid included.
+ *
+ * The statements now ship as static `query` strings with `{{ name }}` variables.
+ * These fixtures are the exact shapes the chat builder emits (kept in
+ * `teleport-gui/.../process-chat-message-custom-node-builder.ts`); this suite is
+ * the PUBLISH-side half of the guarantee — the GUI has the same check against
+ * `workflow-schema`'s copy of the net, and the two copies must agree or a chat
+ * that passes in the editor fails to generate.
+ */
+
+const SEMANTIC_QUERY = [
+  'SELECT d.id, d.content, d.search_content, d.keywords,',
+  '       1 - (d.embedding_json::vector <=> q.query_vector) AS similarity',
+  'FROM teleport_ai_chat_documents d',
+  "CROSS JOIN (SELECT NULLIF({{ queryEmbedding }}::text, '')::vector AS query_vector) q",
+  'WHERE d.embedding_json IS NOT NULL',
+  '  AND q.query_vector IS NOT NULL',
+  'ORDER BY d.embedding_json::vector <=> q.query_vector ASC',
+  'LIMIT 6',
+].join('\n')
+
+const LEXICAL_QUERY = [
+  'WITH search_query AS (',
+  '  SELECT (',
+  "    SELECT string_agg(quote_literal(lexeme), ' | ')",
+  '    FROM (',
+  '      SELECT lexeme',
+  "      FROM unnest(tsvector_to_array(to_tsvector('english', {{ question }}::text))) AS lexeme",
+  '      LIMIT 12',
+  '    ) capped',
+  '  )::tsquery AS tsq',
+  ')',
+  'SELECT ranked.id, ranked.content, ranked.rank',
+  'FROM (',
+  '  SELECT d.id, d.content,',
+  "         ts_rank_cd(to_tsvector('english', COALESCE(d.content, '')), sq.tsq, 1) AS rank,",
+  '         row_number() OVER (',
+  '           PARTITION BY s.source_type',
+  "           ORDER BY ts_rank_cd(to_tsvector('english', COALESCE(d.content, '')), sq.tsq, 1) DESC",
+  '         ) AS rn',
+  '  FROM teleport_ai_chat_documents d',
+  '  JOIN teleport_ai_chat_knowledge_sources s ON s.id = d.knowledge_source_id',
+  '  CROSS JOIN search_query sq',
+  "  WHERE to_tsvector('english', COALESCE(d.content, '')) @@ sq.tsq",
+  ') ranked',
+  'WHERE ranked.rn <= 2',
+  'ORDER BY ranked.rank DESC',
+  'LIMIT 4',
+].join('\n')
+
+const UPSERT_QUERY = [
+  'WITH conversation_input AS (',
+  '  SELECT',
+  "    NULLIF({{ conversationId }}::text, '')::uuid AS conversation_id,",
+  "    NULLIF({{ userId }}::text, '')::uuid AS user_id,",
+  '    {{ username }}::text AS username,',
+  '    LEFT({{ title }}::text, 80) AS title,',
+  "    NULLIF({{ timestamp }}::text, '')::timestamp AS occurred_at",
+  ')',
+  'INSERT INTO teleport_ai_chat_conversations',
+  '  (id, user_id, username, title, status, message_count,',
+  '   last_message_at, created_at, updated_at)',
+  'SELECT conversation_id, user_id, username, title,',
+  "       'active', 1, occurred_at, occurred_at, occurred_at",
+  'FROM conversation_input',
+  'WHERE conversation_id IS NOT NULL AND occurred_at IS NOT NULL',
+  'ON CONFLICT (id) DO UPDATE SET',
+  '  message_count = teleport_ai_chat_conversations.message_count + 1,',
+  '  last_message_at = EXCLUDED.last_message_at,',
+  '  updated_at = EXCLUDED.updated_at',
+].join('\n')
+
+const BUMP_QUERY = [
+  'UPDATE teleport_ai_chat_conversations',
+  'SET message_count = message_count + 1,',
+  '    last_message_at = NOW(),',
+  '    updated_at = NOW()',
+  "WHERE id = NULLIF({{ conversationId }}::text, '')::uuid",
+].join('\n')
+
+const contextRef = (nodeId: string, field: string) => ({
+  type: 'workflowContext',
+  nodeId,
+  path: [nodeId, field],
+})
+
+interface ChatQueryFixture {
+  label: string
+  query: string
+  variables: Array<{ name: string; value: unknown }>
+  expectedParams: number
+}
+
+const FIXTURES: ChatQueryFixture[] = [
+  {
+    label: 'Search Knowledge by Embedding Similarity',
+    query: SEMANTIC_QUERY,
+    variables: [{ name: 'queryEmbedding', value: contextRef('embed-1', 'vectorLiteral') }],
+    expectedParams: 1,
+  },
+  {
+    label: 'Search Knowledge by Keywords',
+    query: LEXICAL_QUERY,
+    variables: [{ name: 'question', value: contextRef('rephrase-1', 'response') }],
+    expectedParams: 1,
+  },
+  {
+    label: 'Upsert Conversation Row',
+    query: UPSERT_QUERY,
+    variables: [
+      { name: 'conversationId', value: contextRef('init-1', 'conversationId') },
+      { name: 'userId', value: contextRef('user-1', 'userId') },
+      { name: 'username', value: contextRef('user-1', 'username') },
+      { name: 'title', value: contextRef('init-1', 'userMessageText') },
+      { name: 'timestamp', value: contextRef('init-1', 'timestamp') },
+    ],
+    expectedParams: 5,
+  },
+  {
+    label: 'Bump Conversation After Reply',
+    query: BUMP_QUERY,
+    variables: [{ name: 'conversationId', value: contextRef('init-1', 'conversationId') }],
+    expectedParams: 1,
+  },
+]
+
+function buildCustomNode() {
+  return {
+    customNodes: {
+      'process-chat-message': {
+        nodes: FIXTURES.map((fixture, index) => ({
+          id: `node-${index}`,
+          data: {
+            nodeType: 'data-raw-query',
+            label: fixture.label,
+            config: {
+              dataSourceId: 'ds-1',
+              query: fixture.query,
+              queryVariables: fixture.variables,
+            },
+          },
+        })),
+      },
+    },
+  }
+}
+
+describe('the chat RAG statements survive the publish-time parameterization net', () => {
+  it('binds every interpolation without a single residual', () => {
+    // A residual makes parameterizeAllWorkflowRawSql throw and refuse to
+    // generate the project, so this is also the "the chat still publishes" test.
+    const uidl = buildCustomNode()
+    expect(() => parameterizeAllWorkflowRawSql(uidl)).not.toThrow()
+  })
+
+  it.each(FIXTURES.map((f, i) => [f.label, i] as const))(
+    '"%s" ends up fully parameterized',
+    (_label, index) => {
+      const uidl = buildCustomNode()
+      parameterizeAllWorkflowRawSql(uidl)
+      const config = uidl.customNodes['process-chat-message'].nodes[index].data.config as Record<
+        string,
+        unknown
+      >
+
+      expect(String(config.query)).not.toContain('{{')
+      expect(config.queryVariables).toBeUndefined()
+      expect((config.params as unknown[]).length).toBe(FIXTURES[index].expectedParams)
+    }
+  )
+
+  it('keeps the table and column names out of the bound values', () => {
+    // The bound params are what a value-injection attempt could reach; the SQL
+    // structure must stay in the query text, server-side.
+    const uidl = buildCustomNode()
+    parameterizeAllWorkflowRawSql(uidl)
+    for (const node of uidl.customNodes['process-chat-message'].nodes) {
+      const params = (node.data.config as { params: unknown[] }).params
+      for (const param of params) {
+        expect(JSON.stringify(param)).not.toContain('teleport_ai_chat')
+      }
+    }
+  })
+
+  it('numbers the placeholders from $1 upward in declaration order', () => {
+    const uidl = buildCustomNode()
+    parameterizeAllWorkflowRawSql(uidl)
+    const upsert = uidl.customNodes['process-chat-message'].nodes[2].data.config as {
+      query: string
+      params: Array<{ path?: string[] }>
+    }
+    expect(upsert.query).toContain('NULLIF($1::text')
+    expect(upsert.query).toContain('LEFT($4::text, 80)')
+    expect(upsert.params[0].path?.[1]).toBe('conversationId')
+    expect(upsert.params[3].path?.[1]).toBe('userMessageText')
+  })
+})
+
+describe('the chat RAG statements pass the guard the generated app runs', () => {
+  // The generated /api/data route calls assertQuerySafe on every raw query
+  // before executing it. A statement that trips it fails at request time, which
+  // for the chat means a silent empty retrieval rather than a build error — so
+  // the check has to run against the RUNTIME validator, the one baked into the
+  // route, not the design-time `sql-query-validator` (which has no call sites
+  // and rejects any `UPDATE … SET`).
+  const assertQuerySafe = new Function(
+    `${generateSqlValidatorCode()}\nreturn assertQuerySafe;`
+  )() as (sql: string) => void
+
+  it.each(FIXTURES.map((f) => [f.label] as const))('"%s" is allowed', (label) => {
+    const uidl = buildCustomNode()
+    parameterizeAllWorkflowRawSql(uidl)
+    const node = uidl.customNodes['process-chat-message'].nodes.find(
+      (entry) => entry.data.label === label
+    )
+    const { query } = node?.data.config as { query: string }
+    expect(() => assertQuerySafe(query)).not.toThrow()
+  })
+
+  it('still rejects the operations the guard exists for', () => {
+    expect(() => assertQuerySafe('DROP TABLE teleport_ai_chat_documents')).toThrow()
+    expect(() => assertQuerySafe('SET ROLE postgres')).toThrow()
+  })
+})

package/__tests__/ai-embedding-optional.test.ts

@@ -0,0 +1,77 @@
+import { aiGenerateTextEmbedding } from '../src/nodes/ai/ai-generate-text-embedding'
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
+
+/**
+ * `{ error: true }` is a FATAL node result — the generated executor throws on
+ * it and the whole workflow stops. The AI Assistant Chat's embedding step must
+ * not be fatal: its retrieval is a hybrid of a vector search and a keyword
+ * search, and a project whose chat runs on Anthropic/Google/Mistral may
+ * legitimately have no OpenAI key (embeddings are OpenAI-only because that is
+ * what the knowledge base was indexed with). That has to degrade to
+ * keyword-only search, not break every message.
+ */
+/** The real executor gate, loaded exactly as the generated app defines it. */
+function loadIsFatalNodeResult(): (result: unknown) => boolean {
+  const utilsModule = { exports: {} as { isFatalNodeResult: (result: unknown) => boolean } }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', generateSharedRuntimeUtilsCode())(
+    utilsModule,
+    utilsModule.exports,
+    () => ({})
+  )
+  return utilsModule.exports.isFatalNodeResult
+}
+
+function loadHandler() {
+  const source = aiGenerateTextEmbedding.generateHandler()
+  // eslint-disable-next-line no-new-func
+  return new Function(`${source}\nreturn ai_generate_text_embedding;`)() as (
+    config: any,
+    context: Record<string, unknown>
+  ) => Promise<any>
+}
+
+describe('ai-generate-text-embedding failure contract', () => {
+  const handler = loadHandler()
+
+  it('is fatal by default, so a pipeline that needs the vector stops', async () => {
+    const result = await handler({ text: 'hello', token: '' }, {})
+    expect(result.error).toBe(true)
+    expect(result.code).toBe('authentication_error')
+  })
+
+  it('reports failure as data when optional, so the workflow keeps running', async () => {
+    const result = await handler({ text: 'hello', token: '', optional: true }, {})
+    expect(result.error).toBeUndefined()
+    expect(result.skipped).toBe(true)
+    expect(result.skipReason).toBeTruthy()
+    expect(result.code).toBe('authentication_error')
+  })
+
+  it('returns an empty embedding when skipped, which is what hasEmbedding checks', async () => {
+    const result = await handler({ text: 'hello', token: '', optional: true }, {})
+    expect(Array.isArray(result.embedding)).toBe(true)
+    expect(result.embedding).toHaveLength(0)
+    expect(result.dimensions).toBe(0)
+  })
+
+  it('is non-fatal for missing text too, not just auth', async () => {
+    const result = await handler({ text: '', token: 'sk-test', optional: true }, {})
+    expect(result.error).toBeUndefined()
+    expect(result.skipped).toBe(true)
+    expect(result.code).toBe('missing_text')
+  })
+})
+
+describe('the executor agrees about what is fatal', () => {
+  const handler = loadHandler()
+  const isFatalNodeResult = loadIsFatalNodeResult()
+
+  it('treats the default failure as fatal and the optional one as success', async () => {
+    const fatal = await handler({ text: 'hello', token: '' }, {})
+    const optional = await handler({ text: 'hello', token: '', optional: true }, {})
+
+    expect(isFatalNodeResult(fatal)).toBe(true)
+    expect(isFatalNodeResult(optional)).toBe(false)
+  })
+})

package/__tests__/ai-model-capabilities.test.ts

@@ -0,0 +1,234 @@
+import {
+  generateAIProviderUtils,
+  generateAIStreamingProviderUtils,
+} from '../src/nodes/ai/ai-provider-utils'
+import { aiCustomPrompt } from '../src/nodes/ai/ai-custom-prompt'
+
+/**
+ * The AI utils are emitted by serialising real functions into the generated
+ * handler file, so the only way to test them is to evaluate the emitted source
+ * exactly as the generated app would.
+ */
+function loadUtils() {
+  const source = generateAIProviderUtils()
+  // eslint-disable-next-line no-new-func
+  return new Function(
+    `${source}
+    return {
+      detectProvider: __ai_detectProvider,
+      resolveProvider: __ai_resolveProvider,
+      modelCapabilities: __ai_modelCapabilities,
+      providerBaseURL: __ai_providerBaseURL,
+      openAICompatibleBody: __ai_openAICompatibleBody,
+      clampTemperature: __ai_clampTemperature,
+    };`
+  )() as {
+    detectProvider: (modelId: string) => string
+    resolveProvider: (config: unknown) => string
+    modelCapabilities: (provider: string, model: string, maxTokens?: number) => any
+    providerBaseURL: (provider: string) => string | undefined
+    openAICompatibleBody: (
+      caps: any,
+      model: string,
+      systemMessage: string | undefined,
+      userMessage: string,
+      temperature: number,
+      jsonMode: boolean
+    ) => any
+    clampTemperature: (temp: unknown, provider: string) => number
+  }
+}
+
+describe('__ai_resolveProvider', () => {
+  const utils = loadUtils()
+
+  it('prefers the explicit provider over the model id', () => {
+    expect(utils.resolveProvider({ provider: 'anthropic', model: 'gpt-4o' })).toBe('anthropic')
+  })
+
+  it('falls back to inference for legacy nodes with no provider', () => {
+    expect(utils.resolveProvider({ model: 'claude-opus-5' })).toBe('anthropic')
+  })
+
+  it('ignores a blank provider', () => {
+    expect(utils.resolveProvider({ provider: '  ', model: 'gemini-2.5-flash' })).toBe('google')
+  })
+})
+
+describe('__ai_detectProvider covers the shipped catalogue', () => {
+  const utils = loadUtils()
+
+  const CASES: Array<[string, string]> = [
+    ['gpt-4o-mini', 'openai'],
+    ['gpt-5.1', 'openai'],
+    ['o3', 'openai'],
+    ['o4-mini', 'openai'],
+    ['claude-opus-5', 'anthropic'],
+    ['claude-3-5-sonnet-20241022', 'anthropic'],
+    ['gemini-2.5-flash', 'google'],
+    ['command-a-03-2025', 'cohere'],
+    ['command-r-plus-08-2024', 'cohere'],
+    ['mistral-large-latest', 'mistral'],
+    ['magistral-medium-latest', 'mistral'],
+    ['ministral-8b-latest', 'mistral'],
+    ['pixtral-large-latest', 'mistral'],
+    ['open-mixtral-8x7b', 'mistral'],
+    ['open-mistral-nemo', 'mistral'],
+    ['meta-llama/Llama-3.3-70B-Instruct-Turbo', 'meta'],
+    ['llama-3.1-405b', 'meta'],
+    ['sonar-pro', 'perplexity'],
+    ['sonar-deep-research', 'perplexity'],
+    // Perplexity's retired ids begin with `llama-`; they must not be claimed by
+    // the Meta branch, which would send them to Together with a Perplexity key.
+    ['llama-3.1-sonar-large-128k-online', 'perplexity'],
+  ]
+
+  it.each(CASES)('%s -> %s', (modelId, provider) => {
+    expect(utils.detectProvider(modelId)).toBe(provider)
+  })
+
+  it('defaults to openai for an unknown id', () => {
+    expect(utils.detectProvider('something-new')).toBe('openai')
+    expect(utils.detectProvider('')).toBe('openai')
+  })
+})
+
+describe('__ai_modelCapabilities', () => {
+  const utils = loadUtils()
+
+  it('drops temperature for Anthropic models that reject it', () => {
+    for (const model of [
+      'claude-fable-5',
+      'claude-mythos-5',
+      'claude-opus-5',
+      'claude-opus-4-8',
+      'claude-opus-4-7',
+      'claude-sonnet-5',
+    ]) {
+      expect(utils.modelCapabilities('anthropic', model, 500).supportsTemperature).toBe(false)
+    }
+  })
+
+  it('keeps temperature for Anthropic models that still accept it', () => {
+    for (const model of [
+      'claude-opus-4-6',
+      'claude-sonnet-4-6',
+      'claude-haiku-4-5',
+      'claude-3-opus-20240229',
+    ]) {
+      expect(utils.modelCapabilities('anthropic', model, 500).supportsTemperature).toBe(true)
+    }
+  })
+
+  it('switches OpenAI reasoning models to max_completion_tokens', () => {
+    const caps = utils.modelCapabilities('openai', 'o3', 500)
+    expect(caps.maxTokensParam).toBe('max_completion_tokens')
+    expect(caps.supportsTemperature).toBe(false)
+  })
+
+  it('raises a too-small budget on reasoning models so the answer is not empty', () => {
+    // The budget also pays for hidden reasoning tokens: at 200 the model can
+    // spend the whole allowance thinking and return an empty string with a 200.
+    expect(utils.modelCapabilities('openai', 'o3', 200).maxTokens).toBe(2000)
+    expect(utils.modelCapabilities('openai', 'gpt-5', 200).maxTokens).toBe(2000)
+    // A generous budget is left alone.
+    expect(utils.modelCapabilities('openai', 'o3', 8000).maxTokens).toBe(8000)
+  })
+
+  it('always yields a positive max_tokens, which Anthropic requires', () => {
+    expect(utils.modelCapabilities('anthropic', 'claude-opus-5', undefined).maxTokens).toBe(1024)
+    expect(utils.modelCapabilities('anthropic', 'claude-opus-5', 0).maxTokens).toBe(1024)
+  })
+
+  it('leaves ordinary chat models untouched', () => {
+    const caps = utils.modelCapabilities('openai', 'gpt-4o-mini', 500)
+    expect(caps).toMatchObject({
+      supportsTemperature: true,
+      maxTokensParam: 'max_tokens',
+      maxTokens: 500,
+    })
+  })
+})
+
+describe('__ai_openAICompatibleBody', () => {
+  const utils = loadUtils()
+
+  it('omits temperature and uses max_completion_tokens for reasoning models', () => {
+    const caps = utils.modelCapabilities('openai', 'gpt-5', 4000)
+    const body = utils.openAICompatibleBody(caps, 'gpt-5', 'sys', 'hi', 0.7, false)
+    expect(body.temperature).toBeUndefined()
+    expect(body.max_tokens).toBeUndefined()
+    expect(body.max_completion_tokens).toBe(4000)
+    expect(body.messages).toEqual([
+      { role: 'system', content: 'sys' },
+      { role: 'user', content: 'hi' },
+    ])
+  })
+
+  it('sends temperature and max_tokens for an ordinary model', () => {
+    const caps = utils.modelCapabilities('openai', 'gpt-4o', 500)
+    const body = utils.openAICompatibleBody(caps, 'gpt-4o', undefined, 'hi', 0.2, true)
+    expect(body.temperature).toBe(0.2)
+    expect(body.max_tokens).toBe(500)
+    expect(body.response_format).toEqual({ type: 'json_object' })
+    expect(body.messages).toEqual([{ role: 'user', content: 'hi' }])
+  })
+})
+
+describe('__ai_providerBaseURL', () => {
+  const utils = loadUtils()
+
+  it('routes Meta through Together and Perplexity through its own host', () => {
+    expect(utils.providerBaseURL('meta')).toBe('https://api.together.xyz/v1')
+    expect(utils.providerBaseURL('perplexity')).toBe('https://api.perplexity.ai')
+  })
+
+  it('leaves first-party OpenAI on the default host', () => {
+    expect(utils.providerBaseURL('openai')).toBeUndefined()
+  })
+})
+
+describe('__ai_clampTemperature', () => {
+  const utils = loadUtils()
+
+  it('clamps to the provider range', () => {
+    expect(utils.clampTemperature(1.8, 'anthropic')).toBe(1)
+    expect(utils.clampTemperature(1.8, 'openai')).toBe(1.8)
+    expect(utils.clampTemperature(-1, 'openai')).toBe(0)
+  })
+
+  it('falls back to 0.7 for a non-numeric value', () => {
+    expect(utils.clampTemperature('hot', 'openai')).toBe(0.7)
+    expect(utils.clampTemperature(NaN, 'openai')).toBe(0.7)
+  })
+})
+
+describe('generated handlers reference the provider resolver', () => {
+  it('emits __ai_resolveProvider in the custom-prompt handler', () => {
+    const handler = aiCustomPrompt.generateHandler()
+    expect(handler).toContain('__ai_resolveProvider(config)')
+    expect(handler).not.toContain('__ai_detectProvider(model)')
+  })
+
+  it('defines every helper the streaming path calls', () => {
+    const streaming = generateAIStreamingProviderUtils()
+    for (const symbol of [
+      '__ai_modelCapabilities',
+      '__ai_providerBaseURL',
+      '__ai_openAICompatibleBody',
+      '__ai_callProviderStreaming',
+      '__ai_handleStreamingCall',
+    ]) {
+      expect(streaming).toContain(symbol)
+    }
+  })
+
+  it('evaluates the streaming bundle without a reference error', () => {
+    // eslint-disable-next-line no-new-func
+    const load = new Function(
+      `${generateAIStreamingProviderUtils()}
+      return typeof __ai_callProviderStreaming === 'function' && typeof __ai_handleStreamingCall === 'function';`
+    )
+    expect(load()).toBe(true)
+  })
+})