The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
import dayjs from 'dayjs'
import { z, type SafeParseReturnType } from 'zod'
import { DEFAULT_ASSISTANT_LOGS_QUERY_TITLE } from './AssistantQueryCell.utils'
import { type QueryResult } from '@/components/interfaces/Explorer/types'
import { type TimeRange } from '@/data/content/notebooks/notebook-schema'
import { isoDateTimeString } from '@/lib/iso-datetime'
const UNTRUSTED_DATA_CLOSE_RE = /<\/untrusted-data-([^>]+)>/g
const unknownRecordSchema = z.record(z.string(), z.unknown())
/** Matches the MCP `query_logs` window when the model omits timestamps. */
export const DEFAULT_ASSISTANT_LOGS_TIME_RANGE: TimeRange = {
_tag: 'relative_time_range',
unit: 'day',
amount: 1,
}
const queryLogsInputSchema = z.object({
sql: z.string().min(1),
iso_timestamp_start: z.string().optional(),
iso_timestamp_end: z.string().optional(),
})
export function parseQueryLogsInput(
input: unknown
): SafeParseReturnType<unknown, z.infer<typeof queryLogsInputSchema>> {
return queryLogsInputSchema.safeParse(input)
}
export function getAssistantLogsQueryTitle(sql: string): string {
const title = sql
.trim()
.match(/^--[ \t]*([^\r\n]+)/)?.[1]
?.trim()
return title || DEFAULT_ASSISTANT_LOGS_QUERY_TITLE
}
export function getAssistantLogsTimeRange(start?: string, end?: string): TimeRange {
const parsedStart = start ? isoDateTimeString(start) : null
const parsedEnd = end ? isoDateTimeString(end) : null
if (parsedStart && parsedEnd && dayjs(parsedEnd).isAfter(parsedStart)) {
return { _tag: 'absolute_time_range', start: parsedStart, end: parsedEnd }
}
return DEFAULT_ASSISTANT_LOGS_TIME_RANGE
}
export function toQueryLogsResult(output: unknown): QueryResult | undefined {
return parseQueryResult(output)
}
function parseQueryResult(output: unknown, depth = 0): QueryResult | undefined {
if (depth > 6 || output == null) return undefined
if (Array.isArray(output)) return toRowResult(output)
if (typeof output === 'string') {
const extracted = extractUntrustedDataJson(output) ?? tryParseJson(output)
return extracted !== undefined ? parseQueryResult(extracted, depth + 1) : undefined
}
const parsedRecord = unknownRecordSchema.safeParse(output)
if (!parsedRecord.success) return undefined
const record = parsedRecord.data
const mcpError = readMcpToolError(record)
if (mcpError) return { rows: [], error: { message: mcpError } }
const error = readErrorMessage(record.error)
const rows = Array.isArray(record.rows)
? toRowResult(record.rows)
: Array.isArray(record.result)
? toRowResult(record.result)
: undefined
if (rows) return error ? { ...rows, error } : rows
if ('result' in record) {
const result = parseQueryResult(record.result, depth + 1)
const mergedResult = mergeParentError(result, error)
if (mergedResult) return mergedResult
}
if (record.structuredContent != null) {
const result = parseQueryResult(record.structuredContent, depth + 1)
const mergedResult = mergeParentError(result, error)
if (mergedResult) return mergedResult
}
if (Array.isArray(record.content)) {
const result = parseQueryResult(textFromMcpContent(record.content), depth + 1)
return mergeParentError(result, error)
}
return error ? { rows: [], error } : undefined
}
function mergeParentError(
result: QueryResult | undefined,
error: QueryResult['error']
): QueryResult | undefined {
return error ? { ...(result ?? { rows: [] }), error } : result
}
function toRowResult(rows: unknown[]): QueryResult {
return {
rows: rows.filter(
(row): row is Record<string, unknown> =>
row !== null && typeof row === 'object' && !Array.isArray(row)
),
}
}
function textFromMcpContent(content: unknown[]): string | undefined {
const texts = content.flatMap((part) => {
if (typeof part === 'string' && part.length > 0) return [part]
const parsedPart = unknownRecordSchema.safeParse(part)
if (!parsedPart.success) return []
if (typeof parsedPart.data.text === 'string') return [parsedPart.data.text]
if (typeof parsedPart.data.value === 'string') return [parsedPart.data.value]
return []
})
return texts.length > 0 ? texts.join('\n') : undefined
}
function readMcpToolError(record: Record<string, unknown>): string | undefined {
if (record.isError !== true) return undefined
const text = Array.isArray(record.content) ? textFromMcpContent(record.content) : undefined
return text?.trim() || 'Failed to query logs'
}
function readErrorMessage(error: unknown): { message: string } | undefined {
if (typeof error === 'string' && error.length > 0) return { message: error }
const parsedError = unknownRecordSchema.safeParse(error)
const message = parsedError.success ? parsedError.data.message : undefined
if (typeof message === 'string' && message.length > 0) return { message }
return undefined
}
function extractUntrustedDataJson(value: string): unknown {
for (const match of value.matchAll(UNTRUSTED_DATA_CLOSE_RE)) {
const boundaryId = match[1]
const closingIndex = match.index
if (!boundaryId || closingIndex === undefined) continue
const openingTag = `<untrusted-data-${boundaryId}>`
// The MCP wrapper mentions the tag in its explanatory prose before opening
// the real JSON boundary, so select the final opening tag before the close.
const openingIndex = value.lastIndexOf(openingTag, closingIndex)
if (openingIndex === -1) continue
const parsed = tryParseJson(value.slice(openingIndex + openingTag.length, closingIndex).trim())
if (parsed !== undefined) return parsed
}
return undefined
}
function tryParseJson(value: string): unknown {
try {
return JSON.parse(value)
} catch {
return undefined
}
}