The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
feat(studio): switch dashboard assistant to remote MCP server (#47479)
Pedro Rodriguesc4c213ce3d6d
diff --git a/.github/workflows/braintrust-evals.yml b/.github/workflows/braintrust-evals.ymlindex a2f9075f913..d05093acd61 100644--- a/.github/workflows/braintrust-evals.yml+++ b/.github/workflows/braintrust-evals.yml@@ -15,8 +15,42 @@ permissions:contents: readjobs:+ # Cheap, always-on gate: verifies the eval harness can reach the MCP server+ # (its one real tool, search_docs). Runs on every push/PR — no OpenAI, no full+ # eval suite — so a broken MCP connection is caught early with an actionable+ # message. The eval job depends on this, so evals never run against a broken+ # MCP connection.+ preflight:+ name: Eval MCP preflight+ runs-on: ubuntu-latest+ timeout-minutes: 10++ steps:+ - name: Checkout+ uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0+ with:+ persist-credentials: false++ - name: Install pnpm+ uses: pnpm/action-setup@41ff72655975bd51cab0327fa583b6e92b6d3061 # v4.2.0+ with:+ run_install: false++ - name: Use Node.js+ uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0+ with:+ node-version-file: '.nvmrc'+ cache: 'pnpm'++ - name: Install Dependencies+ run: pnpm install --frozen-lockfile++ - name: Preflight — MCP connectivity+ run: cd apps/studio && pnpm evals:preflight+eval:name: Run evals+ needs: preflightif: github.event_name == 'push' || (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'run-evals') && github.event.pull_request.head.repo.full_name == github.repository)runs-on: ubuntu-latesttimeout-minutes: 20@@ -43,8 +77,8 @@ jobs:- name: Use Node.jsuses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0with:- node-version-file: ".nvmrc"- cache: "pnpm"+ node-version-file: '.nvmrc'+ cache: 'pnpm'- name: Install Dependenciesrun: pnpm install --frozen-lockfilediff --git a/apps/studio/evals/assistant.eval.ts b/apps/studio/evals/assistant.eval.tsindex 207594cb24a..b540b630720 100644--- a/apps/studio/evals/assistant.eval.ts+++ b/apps/studio/evals/assistant.eval.ts@@ -31,20 +31,30 @@ Eval('Assistant', {const modelResponse = await getModel({ provider: 'openai', modelEntry })if (modelResponse.error) throw modelResponse.error- const result = await generateAssistantResponse({- ...modelResponse.modelParams,- messages: [- {- id: '1',- role: 'user',- parts: [{ type: 'text', text: input.prompt }],- },- ],- tools: await getMockTools(input.mockTables ? { list_tables: input.mockTables } : undefined),- })+ // Owns the lifecycle of the remote MCP client opened inside getMockTools:+ // aborting once generation is done closes that connection.+ const toolsAbortController = new AbortController()+ try {+ const result = await generateAssistantResponse({+ ...modelResponse.modelParams,+ messages: [+ {+ id: '1',+ role: 'user',+ parts: [{ type: 'text', text: input.prompt }],+ },+ ],+ tools: await getMockTools(+ input.mockTables ? { list_tables: input.mockTables } : undefined,+ toolsAbortController.signal+ ),+ })- const finishReason = await result.finishReason- return { finishReason }+ const finishReason = await result.finishReason+ return { finishReason }+ } finally {+ toolsAbortController.abort()+ }},scores: [toolUsageScorer,diff --git a/apps/studio/evals/preflight.ts b/apps/studio/evals/preflight.tsnew file mode 100644index 00000000000..a8889540e2c--- /dev/null+++ b/apps/studio/evals/preflight.ts@@ -0,0 +1,49 @@+/**+ * Eval preflight — MCP connectivity check.+ *+ * The assistant eval harness (`getMockTools`) mocks every tool except+ * `search_docs`, which it sources from a real MCP server. If that connection is+ * broken (endpoint down, bad/expired token, contract drift, missing package),+ * evals fail deep inside a Braintrust run with an opaque per-case error.+ *+ * This preflight exercises the exact same path and fails fast with an+ * actionable message, so a broken MCP connection is caught up front when the+ * eval job runs (e.g. on push). Keep it in lockstep with how `getMockTools`+ * obtains `search_docs` — if that switches to the remote client (see AI-897),+ * switch this too.+ */+import { createInProcessSupabaseMCPClient } from '@/lib/ai/supabase-mcp'++async function runPreflight() {+ let client: Awaited<ReturnType<typeof createInProcessSupabaseMCPClient>> | undefined++ try {+ client = await createInProcessSupabaseMCPClient({+ accessToken: 'mock-access-token',+ projectRef: 'mock-project-ref',+ })++ const tools = await client.tools()++ if (!tools || !('search_docs' in tools)) {+ throw new Error(+ 'Connected to the MCP server but `search_docs` was not returned. ' ++ 'The tool contract may have drifted, or the server is misconfigured.'+ )+ }++ console.log('✅ Eval MCP preflight OK — connected and `search_docs` is available.')+ } finally {+ await client?.close().catch(() => {})+ }+}++runPreflight().catch((error) => {+ console.error(+ '❌ Eval MCP preflight failed — the eval harness cannot reach the MCP server, ' ++ 'so evals would fail. Check NEXT_PUBLIC_MCP_URL, the access token, and the ' ++ '@supabase/mcp-server-supabase dependency.'+ )+ console.error(error instanceof Error ? error.message : error)+ process.exit(1)+})diff --git a/apps/studio/lib/ai/supabase-mcp.test.ts b/apps/studio/lib/ai/supabase-mcp.test.tsnew file mode 100644index 00000000000..eae88b4186e--- /dev/null+++ b/apps/studio/lib/ai/supabase-mcp.test.ts@@ -0,0 +1,139 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'++import { createSupabaseMCPClient } from './supabase-mcp'++const createMCPClientMock = vi.fn()++vi.mock('@ai-sdk/mcp', () => ({+ createMCPClient: (...args: any[]) => createMCPClientMock(...args),+}))++const ACCESS_TOKEN = 'test-access-token'+const PROJECT_REF = 'abcdefghijklmnopqrst'++function getTransportConfig() {+ expect(createMCPClientMock).toHaveBeenCalledTimes(1)+ return createMCPClientMock.mock.calls[0][0]+}++describe('createSupabaseMCPClient', () => {+ const originalMcpUrl = process.env.NEXT_PUBLIC_MCP_URL+ const originalSha = process.env.VERCEL_GIT_COMMIT_SHA++ beforeEach(() => {+ vi.clearAllMocks()+ createMCPClientMock.mockResolvedValue({ tools: vi.fn() })+ delete process.env.VERCEL_GIT_COMMIT_SHA+ })++ afterEach(() => {+ if (originalMcpUrl === undefined) delete process.env.NEXT_PUBLIC_MCP_URL+ else process.env.NEXT_PUBLIC_MCP_URL = originalMcpUrl+ if (originalSha === undefined) delete process.env.VERCEL_GIT_COMMIT_SHA+ else process.env.VERCEL_GIT_COMMIT_SHA = originalSha+ })++ it('connects over the HTTP transport with the supabase-studio client name', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ const config = getTransportConfig()+ expect(config.name).toBe('supabase-studio')+ expect(config.transport.type).toBe('http')+ })++ it('targets the URL from NEXT_PUBLIC_MCP_URL with project_ref and read_only', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ const url = new URL(getTransportConfig().transport.url)+ expect(url.origin + url.pathname).toBe('https://mcp.supabase.com/mcp')+ expect(url.searchParams.get('project_ref')).toBe(PROJECT_REF)+ expect(url.searchParams.get('read_only')).toBe('true')+ })++ it('forwards the dashboard access token as a bearer header', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ expect(getTransportConfig().transport.headers.Authorization).toBe(`Bearer ${ACCESS_TOKEN}`)+ })++ it('identifies assistant traffic with the x-source-name header', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ expect(getTransportConfig().transport.headers['x-source-name']).toBe('supabase-studio')+ })++ it('sends x-source-version from VERCEL_GIT_COMMIT_SHA when available', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'+ process.env.VERCEL_GIT_COMMIT_SHA = 'abc1234'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ expect(getTransportConfig().transport.headers['x-source-version']).toBe('abc1234')+ })++ it('omits x-source-version when VERCEL_GIT_COMMIT_SHA is not set', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'+ delete process.env.VERCEL_GIT_COMMIT_SHA++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ expect(getTransportConfig().transport.headers).not.toHaveProperty('x-source-version')+ })++ it('never leaks the access token into the URL', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ expect(getTransportConfig().transport.url).not.toContain(ACCESS_TOKEN)+ })++ it('always requests read-only mode', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ const url = new URL(getTransportConfig().transport.url)+ expect(url.searchParams.get('read_only')).toBe('true')+ })++ it('falls back to the default local URL when NEXT_PUBLIC_MCP_URL is unset', async () => {+ delete process.env.NEXT_PUBLIC_MCP_URL++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ const url = new URL(getTransportConfig().transport.url)+ expect(url.origin + url.pathname).toBe('http://localhost:8080/mcp')+ expect(url.searchParams.get('project_ref')).toBe(PROJECT_REF)+ })++ it('falls back to the default local URL when NEXT_PUBLIC_MCP_URL is an empty string', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = ''++ await createSupabaseMCPClient({ accessToken: ACCESS_TOKEN, projectRef: PROJECT_REF })++ const url = new URL(getTransportConfig().transport.url)+ expect(url.origin + url.pathname).toBe('http://localhost:8080/mcp')+ })++ it('returns the client created by createMCPClient', async () => {+ process.env.NEXT_PUBLIC_MCP_URL = 'https://mcp.supabase.com/mcp'+ const fakeClient = { tools: vi.fn() }+ createMCPClientMock.mockResolvedValueOnce(fakeClient)++ const client = await createSupabaseMCPClient({+ accessToken: ACCESS_TOKEN,+ projectRef: PROJECT_REF,+ })++ expect(client).toBe(fakeClient)+ })+})diff --git a/apps/studio/lib/ai/supabase-mcp.ts b/apps/studio/lib/ai/supabase-mcp.tsindex a508ad94a94..bbc65500f7b 100644--- a/apps/studio/lib/ai/supabase-mcp.ts+++ b/apps/studio/lib/ai/supabase-mcp.ts@@ -1,17 +1,113 @@import { createMCPClient } from '@ai-sdk/mcp'-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js' // .js required for esbuild ESM resolution-import { createSupabaseMcpServer } from '@supabase/mcp-server-supabase'-import { createSupabaseApiPlatform } from '@supabase/mcp-server-supabase/platform/api'-import { API_URL } from '@/lib/constants'+/**+ * Default MCP server URL used when `NEXT_PUBLIC_MCP_URL` is not configured (local+ * development). Mirrors `DEFAULT_MCP_URL_PLATFORM` in `ui-patterns/McpUrlBuilder`+ * so the assistant resolves the same endpoint as the Connect sheet. It's+ * duplicated here (rather than imported) to keep+ * `ui-patterns/McpUrlBuilder/constants` — which pulls in `next/image` and image+ * assets — out of this server-side bundle.+ */+const DEFAULT_MCP_URL = 'http://localhost:8080/mcp'+/**+ * Identifies assistant traffic to the remote MCP server. Sent both as the MCP+ * client name (logged as `client_name`) and via the `x-source-name` header+ * (logged as `source_name`) by the mgmt-api McpLogger, so assistant requests are+ * attributable in the MCP server's logs.+ */+const SOURCE_NAME = 'supabase-studio'++/**+ * Builds the remote MCP endpoint URL for the dashboard assistant.+ *+ * Points at the remote MCP server configured via `NEXT_PUBLIC_MCP_URL` (e.g.+ * https://mcp.supabase.com/mcp), falling back to a local default for development.+ * The query parameters (`project_ref`, `read_only`) mirror `getMcpUrl` in+ * `ui-patterns/McpUrlBuilder/utils/getMcpUrl` so the assistant and the Connect sheet stay in+ * sync. The assistant only performs read operations, so `read_only` is always+ * set.+ *+ * Note: the assistant only talks to the remote MCP server on the hosted platform+ * (see `getTools` / `getMcpTools`), so no self-hosted branch is needed here.+ */+function getRemoteMcpUrl(projectRef: string) {+ // `||` (not `??`) so an empty-string env var falls back instead of producing+ // an invalid `new URL('')`.+ const url = new URL(process.env.NEXT_PUBLIC_MCP_URL || DEFAULT_MCP_URL)+ if (projectRef) {+ url.searchParams.set('project_ref', projectRef)+ }+ url.searchParams.set('read_only', 'true')++ return url.toString()+}++/**+ * Creates an MCP client connected to the remote Supabase MCP server over HTTP.+ *+ * Previously the assistant instantiated the MCP server in-process and connected+ * to it via an in-memory transport. It now connects to the remote MCP server so+ * the dashboard assistant shares the same MCP surface as external clients.+ *+ * The dashboard session `accessToken` is forwarded as a bearer token. The remote+ * MCP server is responsible for validating it and scoping access to the project.+ */export async function createSupabaseMCPClient({accessToken,- projectId,+ projectRef,+}: {+ accessToken: string+ projectRef: string+}) {+ // Identifies the deployed build in the MCP server's `source_version` log field.+ const sourceVersion = process.env.VERCEL_GIT_COMMIT_SHA++ const client = await createMCPClient({+ name: SOURCE_NAME,+ transport: {+ type: 'http',+ url: getRemoteMcpUrl(projectRef),+ headers: {+ Authorization: `Bearer ${accessToken}`,+ // Identify assistant traffic in the remote MCP server's logs+ 'x-source-name': SOURCE_NAME,+ ...(sourceVersion ? { 'x-source-version': sourceVersion } : {}),+ },+ },+ })++ return client+}++/**+ * Legacy in-process MCP client — the pre-migration behavior, kept as a fallback+ * behind the `USE_REMOTE_MCP` gate (see `tools/mcp-tools.ts`).+ *+ * Instantiates `@supabase/mcp-server-supabase` in-process and connects to it over+ * an in-memory transport. The heavy server package is imported dynamically so it+ * is code-split into its own chunk and stays out of the (default, post-migration)+ * remote path's bundle.+ *+ * TODO(AI-897): remove in process mcp — delete this once every environment has+ * been flipped to the remote MCP server and has been stable. Tracked alongside+ * the `USE_REMOTE_MCP` rollout.+ */+export async function createInProcessSupabaseMCPClient({+ accessToken,+ projectRef,}: {accessToken: string- projectId: string+ projectRef: string}) {+ // Dynamic imports keep the in-process server + its transport out of the remote+ // path's bundle (loaded only when this fallback is actually taken).+ // `.js` is required for esbuild ESM resolution.+ const { InMemoryTransport } = await import('@modelcontextprotocol/sdk/inMemory.js')+ const { createSupabaseMcpServer } = await import('@supabase/mcp-server-supabase')+ const { createSupabaseApiPlatform } = await import('@supabase/mcp-server-supabase/platform/api')+ const { API_URL } = await import('@/lib/constants')+const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()// Instantiate the MCP server and connect to its transport@@ -22,14 +118,13 @@ export async function createSupabaseMCPClient({apiUrl,}),contentApiUrl: process.env.NEXT_PUBLIC_CONTENT_API_URL,- projectId,+ projectId: projectRef,readOnly: true,})await server.connect(serverTransport)- // Create the MCP client and connect to its transportconst client = await createMCPClient({- name: 'supabase-studio',+ name: SOURCE_NAME,transport: clientTransport,})diff --git a/apps/studio/lib/ai/tools/index.test.ts b/apps/studio/lib/ai/tools/index.test.tsnew file mode 100644index 00000000000..fb927e1bb29--- /dev/null+++ b/apps/studio/lib/ai/tools/index.test.ts@@ -0,0 +1,86 @@+import { beforeEach, describe, expect, it, vi } from 'vitest'++import { getTools } from './index'+import { getMcpTools } from './mcp-tools'++vi.mock('common', () => ({ IS_PLATFORM: true }))++vi.mock('./mcp-tools', () => ({ getMcpTools: vi.fn() }))+vi.mock('./studio-tools', () => ({ getStudioTools: vi.fn(() => ({ studio_tool: {} })) }))+vi.mock('./schema-tools', () => ({ getSchemaTools: vi.fn(() => ({ schema_tool: {} })) }))+vi.mock('./incident-tools', () => ({ getIncidentTools: vi.fn(() => ({ incident_tool: {} })) }))+vi.mock('./fallback-tools', () => ({ getFallbackTools: vi.fn(() => ({ fallback_tool: {} })) }))+// Identity filter so assertions can check the raw merged tool set+vi.mock('../tool-filter', () => ({ filterToolsByOptInLevel: vi.fn((tools) => tools) }))++const BASE_PARAMS = {+ projectRef: 'abcdefghijklmnopqrst',+ connectionString: 'postgresql://localhost',+ authorization: 'Bearer token',+ aiOptInLevel: 'schema_and_log_and_data' as const,+ accessToken: 'access-token',+ baseUrl: 'https://supabase.com/dashboard',+ signal: new AbortController().signal,+}++describe('ai/tools getTools', () => {+ beforeEach(async () => {+ vi.clearAllMocks()+ vi.mocked(getMcpTools).mockResolvedValue({ list_tables: {} } as any)+ // Reset to platform each test; the self-hosted test overrides to false.+ // Done here (not afterEach) so the spy can't leak across tests via order.+ const common = await import('common')+ vi.spyOn(common, 'IS_PLATFORM', 'get').mockReturnValue(true)+ })++ it('includes studio, MCP, schema and incident tools on platform', async () => {+ const tools = await getTools(BASE_PARAMS)++ expect(getMcpTools).toHaveBeenCalledWith({+ accessToken: BASE_PARAMS.accessToken,+ projectRef: BASE_PARAMS.projectRef,+ aiOptInLevel: BASE_PARAMS.aiOptInLevel,+ signal: BASE_PARAMS.signal,+ })+ expect(tools).toHaveProperty('studio_tool')+ expect(tools).toHaveProperty('list_tables')+ expect(tools).toHaveProperty('schema_tool')+ expect(tools).toHaveProperty('incident_tool')+ })++ it('degrades gracefully to the remaining tools when remote MCP fetch fails', async () => {+ const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})+ vi.mocked(getMcpTools).mockRejectedValueOnce(new Error('remote MCP unreachable'))++ const tools = await getTools(BASE_PARAMS)++ // The assistant still works with the non-MCP tools instead of throwing+ expect(tools).toHaveProperty('studio_tool')+ expect(tools).toHaveProperty('schema_tool')+ expect(tools).toHaveProperty('incident_tool')+ expect(tools).not.toHaveProperty('list_tables')+ expect(consoleSpy).toHaveBeenCalled()++ consoleSpy.mockRestore()+ })++ it('does not fetch MCP tools when no access token is provided', async () => {+ const tools = await getTools({ ...BASE_PARAMS, accessToken: undefined })++ expect(getMcpTools).not.toHaveBeenCalled()+ expect(tools).toHaveProperty('studio_tool')+ expect(tools).not.toHaveProperty('list_tables')+ })++ it('uses fallback tools and skips MCP when self-hosted', async () => {+ const common = await import('common')+ vi.spyOn(common, 'IS_PLATFORM', 'get').mockReturnValue(false)++ const tools = await getTools(BASE_PARAMS)++ expect(getMcpTools).not.toHaveBeenCalled()+ expect(tools).toHaveProperty('studio_tool')+ expect(tools).toHaveProperty('fallback_tool')+ expect(tools).not.toHaveProperty('list_tables')+ })+})diff --git a/apps/studio/lib/ai/tools/index.ts b/apps/studio/lib/ai/tools/index.tsindex 56102becf92..295921d1c70 100644--- a/apps/studio/lib/ai/tools/index.ts+++ b/apps/studio/lib/ai/tools/index.ts@@ -16,6 +16,7 @@ export const getTools = async ({aiOptInLevel,accessToken,baseUrl,+ signal,}: {projectRef: stringconnectionString: string@@ -23,6 +24,9 @@ export const getTools = async ({aiOptInLevel: AiOptInLevelaccessToken?: stringbaseUrl?: string+ // Required: tools fetched from the remote MCP server hold an HTTP connection+ // that is closed when this signal aborts (i.e. when the request ends).+ signal: AbortSignal}) => {// Always include studio toolslet tools: ToolSet = getStudioTools({ projectRef, connectionString, authorization, aiOptInLevel })@@ -39,12 +43,22 @@ export const getTools = async ({}),}} else if (accessToken) {- // If platform, fetch MCP and other platform specific tools- const mcpTools = await getMcpTools({- accessToken,- projectRef,- aiOptInLevel,- })+ // If platform, fetch MCP and other platform specific tools. The MCP tools+ // may be fetched from the remote MCP server over the network (see+ // `USE_REMOTE_MCP`), so a failure there (outage, timeout, auth) should+ // degrade gracefully to the remaining tools rather than break the entire+ // assistant.+ let mcpTools: ToolSet = {}+ try {+ mcpTools = await getMcpTools({+ accessToken,+ projectRef,+ aiOptInLevel,+ signal,+ })+ } catch (error) {+ console.error('Failed to fetch MCP tools:', error)+ }tools = {...tools,diff --git a/apps/studio/lib/ai/tools/mcp-tools.test.ts b/apps/studio/lib/ai/tools/mcp-tools.test.tsnew file mode 100644index 00000000000..5290cd99b01--- /dev/null+++ b/apps/studio/lib/ai/tools/mcp-tools.test.ts@@ -0,0 +1,172 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'++import { createInProcessSupabaseMCPClient, createSupabaseMCPClient } from '../supabase-mcp'+import { getMcpTools } from './mcp-tools'++vi.mock('../supabase-mcp', () => ({+ createSupabaseMCPClient: vi.fn(),+ createInProcessSupabaseMCPClient: vi.fn(),+}))++const BASE_PARAMS = {+ accessToken: 'token',+ projectRef: 'abcdefghijklmnopqrst',+ aiOptInLevel: 'schema_and_log_and_data' as const,+ // A fresh, non-aborted signal by default; lifecycle tests override it+ signal: new AbortController().signal,+}++// A realistic remote tool set: all expected read tools plus the UI-executed ones+const FULL_REMOTE_TOOLS = {+ search_docs: { description: 'docs' },+ list_tables: { description: 'list tables' },+ list_extensions: { description: 'extensions' },+ list_edge_functions: { description: 'edge functions' },+ list_branches: { description: 'branches' },+ get_advisors: { description: 'advisors' },+ get_logs: { description: 'get logs' },+ execute_sql: { description: 'execute sql' },+ deploy_edge_function: { description: 'deploy' },+}++describe('ai/tools/mcp-tools getMcpTools', () => {+ let close: ReturnType<typeof vi.fn>+ let tools: ReturnType<typeof vi.fn>+ let consoleErrorSpy: ReturnType<typeof vi.spyOn>++ beforeEach(() => {+ vi.clearAllMocks()+ // These tests exercise the remote transport; pin the migration gate to it.+ process.env.USE_REMOTE_MCP = 'true'+ consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})+ close = vi.fn().mockResolvedValue(undefined)+ tools = vi.fn().mockResolvedValue({ ...FULL_REMOTE_TOOLS })+ vi.mocked(createSupabaseMCPClient).mockResolvedValue({ tools, close } as any)+ })++ afterEach(() => {+ delete process.env.USE_REMOTE_MCP+ consoleErrorSpy.mockRestore()+ })++ it('returns MCP tools and strips UI-executed tools handled locally', async () => {+ const result = await getMcpTools(BASE_PARAMS)++ expect(result).toHaveProperty('list_tables')+ expect(result).toHaveProperty('get_logs')+ expect(result).not.toHaveProperty('execute_sql')+ expect(result).not.toHaveProperty('deploy_edge_function')+ })++ it('warns when the remote server is missing an expected tool (contract drift)', async () => {+ const { list_branches, ...withoutBranches } = FULL_REMOTE_TOOLS+ tools.mockResolvedValueOnce(withoutBranches)++ await getMcpTools(BASE_PARAMS)++ expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('list_branches'))+ })++ it('does not warn about drift when all expected tools are present', async () => {+ await getMcpTools(BASE_PARAMS)++ const driftWarnings = consoleErrorSpy.mock.calls.filter(+ ([msg]: unknown[]) => typeof msg === 'string' && msg.includes('missing expected tools')+ )+ expect(driftWarnings).toHaveLength(0)+ })++ it('keeps the connection open until the request signal aborts', async () => {+ const controller = new AbortController()++ await getMcpTools({ ...BASE_PARAMS, signal: controller.signal })+ // Tools execute later during streaming, so the client must stay open+ expect(close).not.toHaveBeenCalled()++ controller.abort()+ await Promise.resolve()+ expect(close).toHaveBeenCalledTimes(1)+ })++ it('closes the client and skips fetching tools when the signal is already aborted', async () => {+ const controller = new AbortController()+ controller.abort()++ const result = await getMcpTools({ ...BASE_PARAMS, signal: controller.signal })++ expect(close).toHaveBeenCalledTimes(1)+ expect(tools).not.toHaveBeenCalled()+ expect(result).toEqual({})+ })++ it('closes the client and rethrows when fetching tools fails, without double-closing on later abort', async () => {+ tools.mockRejectedValueOnce(new Error('network unreachable'))+ const controller = new AbortController()++ await expect(getMcpTools({ ...BASE_PARAMS, signal: controller.signal })).rejects.toThrow(+ 'network unreachable'+ )+ expect(close).toHaveBeenCalledTimes(1)++ // A subsequent abort must not close the (already closed) client again+ controller.abort()+ await Promise.resolve()+ expect(close).toHaveBeenCalledTimes(1)+ })++ it('closes the client and rethrows when tool validation fails', async () => {+ // A known tool name with a non-object value passes the opt-in filter but+ // fails schema validation+ tools.mockResolvedValueOnce({ ...FULL_REMOTE_TOOLS, list_tables: 'not-an-object' })++ await expect(getMcpTools(BASE_PARAMS)).rejects.toThrow('MCP tools validation failed')+ expect(close).toHaveBeenCalledTimes(1)+ })+})++describe('ai/tools/mcp-tools getMcpTools transport selection', () => {+ let close: ReturnType<typeof vi.fn>+ let tools: ReturnType<typeof vi.fn>+ let consoleErrorSpy: ReturnType<typeof vi.spyOn>++ beforeEach(() => {+ vi.clearAllMocks()+ consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})+ close = vi.fn().mockResolvedValue(undefined)+ tools = vi.fn().mockResolvedValue({ ...FULL_REMOTE_TOOLS })+ vi.mocked(createSupabaseMCPClient).mockResolvedValue({ tools, close } as any)+ vi.mocked(createInProcessSupabaseMCPClient).mockResolvedValue({ tools, close } as any)+ })++ afterEach(() => {+ delete process.env.USE_REMOTE_MCP+ consoleErrorSpy.mockRestore()+ })++ it('uses the remote client when USE_REMOTE_MCP is "true"', async () => {+ process.env.USE_REMOTE_MCP = 'true'++ await getMcpTools(BASE_PARAMS)++ expect(createSupabaseMCPClient).toHaveBeenCalledTimes(1)+ expect(createInProcessSupabaseMCPClient).not.toHaveBeenCalled()+ })++ it('falls back to the in-process client when USE_REMOTE_MCP is unset (default)', async () => {+ delete process.env.USE_REMOTE_MCP++ await getMcpTools(BASE_PARAMS)++ expect(createInProcessSupabaseMCPClient).toHaveBeenCalledTimes(1)+ expect(createSupabaseMCPClient).not.toHaveBeenCalled()+ })++ it('uses the in-process client for any non-"true" value', async () => {+ process.env.USE_REMOTE_MCP = 'false'++ await getMcpTools(BASE_PARAMS)++ expect(createInProcessSupabaseMCPClient).toHaveBeenCalledTimes(1)+ expect(createSupabaseMCPClient).not.toHaveBeenCalled()+ })+})diff --git a/apps/studio/lib/ai/tools/mcp-tools.ts b/apps/studio/lib/ai/tools/mcp-tools.tsindex 3ccfcc9c992..f895f6d90b9 100644--- a/apps/studio/lib/ai/tools/mcp-tools.ts+++ b/apps/studio/lib/ai/tools/mcp-tools.ts@@ -1,42 +1,135 @@+// Type-only import (erased at build time — pulls no runtime code into this route).+import type * as SupabaseMcp from '@supabase/mcp-server-supabase'import type { ToolSet } from 'ai'-import { createSupabaseMCPClient } from '../supabase-mcp'+import { createInProcessSupabaseMCPClient, createSupabaseMCPClient } from '../supabase-mcp'import { filterToolsByOptInLevel, toolSetValidationSchema } from '../tool-filter'import type { AiOptInLevel } from '@/hooks/misc/useOrgOptedIntoAi'-const UI_EXECUTED_TOOLS = ['execute_sql', 'deploy_edge_function']+/**+ * Union of the tool names exposed by the pinned `@supabase/mcp-server-supabase`+ * version. Studio's dependency is bumped in lockstep with the remote MCP server+ * (via automated bump PRs), so typing our tool-name lists against this makes an+ * upstream rename/removal a **compile-time** failure (`pnpm typecheck`) in that+ * PR, instead of a silent capability loss at runtime.+ */+type SupabaseMcpToolName = keyof typeof SupabaseMcp.supabaseMcpToolSchemas++// UI-executed tools handled locally by Studio (see getStudioTools); the remote+// MCP server's versions are removed so the UI-controlled Studio versions win.+const UI_EXECUTED_TOOLS = [+ 'execute_sql',+ 'deploy_edge_function',+] as const satisfies readonly SupabaseMcpToolName[]++// Read-only tools the assistant relies on from the remote MCP server — the+// MCP-sourced subset of the allowlist in tool-filter.ts (TOOL_CATEGORY_MAP).+// `satisfies` gives the compile-time drift guard; the runtime check below also+// catches a deployed server that returns fewer tools (feature flags / version+// skew). The allowlist remains the source of truth for what is allowed.+const EXPECTED_MCP_TOOLS = [+ 'search_docs',+ 'list_tables',+ 'list_extensions',+ 'list_edge_functions',+ 'list_branches',+ 'get_advisors',+ 'get_logs',+] as const satisfies readonly SupabaseMcpToolName[]export const getMcpTools = async ({accessToken,projectRef,aiOptInLevel,+ signal,}: {accessToken: stringprojectRef: stringaiOptInLevel: AiOptInLevel+ // Required: the remote client holds an HTTP connection that must be torn down+ // when the request ends. The caller owns that lifecycle via this signal.+ signal: AbortSignal}) => {- // If platform, fetch MCP client and tools which replace old local tools- const mcpClient = await createSupabaseMCPClient({+ // Connect to the MCP server and fetch its tools, which replace the old local+ // tools. `USE_REMOTE_MCP` gates the transport: the remote HTTP server (target+ // state) or the legacy in-process server (fallback during the migration),+ // defaulting to in-process until an environment opts in. Flip it per+ // environment (staging → prod → Nimbus) once each one's prerequisites are met+ // (dashboard-token support on the MCP API, remote MCP enabled for Nimbus);+ // unset to roll back on the next deploy. Both transports expose the same tool+ // surface, so the filtering, drift detection, and lifecycle handling below are+ // transport-agnostic.+ //+ // TODO(AI-897): remove in process mcp — once every environment has been+ // flipped and is stable, delete `createInProcessSupabaseMCPClient` and this+ // fallback branch.+ const useRemoteMcp = process.env.USE_REMOTE_MCP === 'true'+ const createClient = useRemoteMcp ? createSupabaseMCPClient : createInProcessSupabaseMCPClient+ const mcpClient = await createClient({accessToken,- projectId: projectRef,+ projectRef,})- const availableMcpTools = (await mcpClient.tools()) as ToolSet- // Filter tools based on the (potentially modified) AI opt-in level- const allowedMcpTools = filterToolsByOptInLevel(availableMcpTools, aiOptInLevel)-- // Remove UI-executed tools handled locally- const filteredMcpTools: ToolSet = { ...allowedMcpTools }- UI_EXECUTED_TOOLS.forEach((toolName) => {- delete filteredMcpTools[toolName]- })+ // The remote client keeps an HTTP connection open. The tools' `execute`+ // functions are invoked later, while the response is streaming, so the+ // connection must stay open until the request ends. Close it exactly once when+ // the request is done (normal completion or abort) to avoid leaking a+ // connection per request.+ let closed = false+ const closeClient = () => {+ if (closed) return+ closed = true+ void mcpClient.close().catch(() => {})+ }- // Validate that only known tools are provided- const validation = toolSetValidationSchema.safeParse(filteredMcpTools)- if (!validation.success) {- console.error('MCP tools validation error:', validation.error)- throw new Error('Internal error: MCP tools validation failed')+ // The request already ended before we could fetch tools; don't bother.+ if (signal.aborted) {+ closeClient()+ return {} as ToolSet}+ signal.addEventListener('abort', closeClient, { once: true })++ try {+ const availableMcpTools = (await mcpClient.tools()) as ToolSet- return validation.data+ // Runtime drift detection: `EXPECTED_MCP_TOOLS` is compile-time-checked+ // against the pinned package (see its declaration), but the *deployed* remote+ // server can still return fewer tools than the pinned types — feature flags,+ // killswitches, or version skew during a bump. `filterToolsByOptInLevel`+ // drops missing tools silently, so warn to make that observable.+ const missingExpectedTools = EXPECTED_MCP_TOOLS.filter((name) => !(name in availableMcpTools))+ if (missingExpectedTools.length > 0) {+ console.error(+ `Remote MCP server is missing expected tools: ${missingExpectedTools.join(', ')}. ` ++ 'The tool contract may have drifted; the assistant will operate without them.'+ )+ }++ // Safety gate: `filterToolsByOptInLevel` keeps only tools in the allowlist+ // (tool-filter.ts TOOL_CATEGORY_MAP) and drops everything else. This — not+ // the `read_only` query param — is what prevents the remote server's+ // write/destructive tools (apply_migration, create_branch, ...) from reaching+ // the assistant. `read_only` is defense-in-depth (those tools throw at+ // runtime). Do not remove this filter on the assumption `read_only` suffices.+ const allowedMcpTools = filterToolsByOptInLevel(availableMcpTools, aiOptInLevel)++ // Remove UI-executed tools handled locally+ const filteredMcpTools: ToolSet = { ...allowedMcpTools }+ UI_EXECUTED_TOOLS.forEach((toolName) => {+ delete filteredMcpTools[toolName]+ })++ // Validate that only known tools are provided+ const validation = toolSetValidationSchema.safeParse(filteredMcpTools)+ if (!validation.success) {+ console.error('MCP tools validation error:', validation.error)+ throw new Error('Internal error: MCP tools validation failed')+ }++ return validation.data+ } catch (error) {+ // Don't leak the connection if fetching or validating tools fails+ closeClient()+ throw error+ }}diff --git a/apps/studio/lib/ai/tools/mock-tools.test.ts b/apps/studio/lib/ai/tools/mock-tools.test.tsnew file mode 100644index 00000000000..d696d2d762d--- /dev/null+++ b/apps/studio/lib/ai/tools/mock-tools.test.ts@@ -0,0 +1,64 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'++import { getMockTools } from './mock-tools'+import { createInProcessSupabaseMCPClient } from '@/lib/ai/supabase-mcp'++// The one real tool in the eval harness (search_docs) is sourced from an+// in-process MCP client. Mock that client so this test stays hermetic and+// guards the wiring, not a live connection.+vi.mock('@/lib/ai/supabase-mcp', () => ({+ createInProcessSupabaseMCPClient: vi.fn(),+}))++const SEARCH_DOCS = { description: 'search the docs' }++describe('ai/tools/mock-tools getMockTools', () => {+ let close: ReturnType<typeof vi.fn>+ let tools: ReturnType<typeof vi.fn>++ beforeEach(() => {+ vi.clearAllMocks()+ close = vi.fn().mockResolvedValue(undefined)+ tools = vi.fn().mockResolvedValue({ search_docs: SEARCH_DOCS })+ vi.mocked(createInProcessSupabaseMCPClient).mockResolvedValue({ tools, close } as any)+ })++ it('sources the real search_docs from the in-process MCP server alongside the deterministic mocks', async () => {+ const result = await getMockTools(undefined, new AbortController().signal)++ expect(createInProcessSupabaseMCPClient).toHaveBeenCalledTimes(1)+ // The real tool, wired through from the MCP client+ expect(result).toHaveProperty('search_docs', SEARCH_DOCS)+ // A couple of the deterministic mocks, to confirm the merge+ expect(result).toHaveProperty('list_tables')+ expect(result).toHaveProperty('get_logs')+ })++ // This is the regression guard: if the eval's MCP wiring breaks (contract+ // drift, or a refactor that stops sourcing search_docs — e.g. the future+ // AI-897 removal of the in-process client), fail loudly in normal CI instead+ // of only surfacing during an opt-in Braintrust eval run.+ it('throws a clear error when the MCP server does not expose search_docs', async () => {+ tools.mockResolvedValueOnce({})++ await expect(getMockTools(undefined, new AbortController().signal)).rejects.toThrow(+ 'search_docs tool not available from MCP server'+ )+ })++ it('closes the MCP client when the caller aborts the signal', async () => {+ const controller = new AbortController()++ await getMockTools(undefined, controller.signal)+ // Connection stays open until generation ends (search_docs runs during it)+ expect(close).not.toHaveBeenCalled()++ controller.abort()+ await Promise.resolve()+ expect(close).toHaveBeenCalledTimes(1)+ })++ afterEach(() => {+ vi.clearAllMocks()+ })+})diff --git a/apps/studio/lib/ai/tools/mock-tools.ts b/apps/studio/lib/ai/tools/mock-tools.tsindex 8465459d3d3..f12d9b0e55e 100644--- a/apps/studio/lib/ai/tools/mock-tools.ts+++ b/apps/studio/lib/ai/tools/mock-tools.ts@@ -1,9 +1,9 @@import assert from 'node:assert'-import { tool } from 'ai'+import { tool, type ToolSet } from 'ai'import { z } from 'zod'import { getStudioTools } from '../tools/studio-tools'-import { getMcpTools } from '@/lib/ai/tools/mcp-tools'+import { createInProcessSupabaseMCPClient } from '@/lib/ai/supabase-mcp'const listTablesInputSchema = z.object({schemas: z.array(z.string()).describe('The schema names to list.'),@@ -306,14 +306,25 @@ export type MockToolOverrides = {** Note: search_docs uses the real implementation*/-export async function getMockTools(overrides?: MockToolOverrides) {+export async function getMockTools(overrides: MockToolOverrides | undefined, signal: AbortSignal) {const mockedStudioTools = createMockedStudioTools()- const { search_docs } = await getMcpTools({+ // Every tool here is a deterministic mock except `search_docs`, which uses the+ // real implementation. We source it from an in-process MCP server directly+ // (rather than `getMcpTools`) so the eval harness stays hermetic and decoupled+ // from the assistant's transport gate (`USE_REMOTE_MCP`): the in-process server+ // needs no live remote endpoint or real access token. See AI-897 for how to+ // point evals at the remote MCP server instead.+ const mcpClient = await createInProcessSupabaseMCPClient({accessToken: 'mock-access-token',projectRef: 'mock-project-ref',- aiOptInLevel: 'schema_and_log_and_data',})+ // The caller owns this signal and aborts it once generation is done, which+ // closes the client opened here (search_docs executes during generation, so+ // the connection must stay open until then).+ signal.addEventListener('abort', () => void mcpClient.close().catch(() => {}), { once: true })++ const { search_docs } = (await mcpClient.tools()) as ToolSetassert(search_docs, 'search_docs tool not available from MCP server')diff --git a/apps/studio/lib/api/generate-v4.test.ts b/apps/studio/lib/api/generate-v4.test.tsindex 7a064364246..5110d04fe8a 100644--- a/apps/studio/lib/api/generate-v4.test.ts+++ b/apps/studio/lib/api/generate-v4.test.ts@@ -42,6 +42,7 @@ test('generateV4 calls the tool sanitizer', async () => {status: vi.fn(() => mockRes),json: vi.fn(() => mockRes),setHeader: vi.fn(() => mockRes),+ on: vi.fn(),}vi.mock('@/lib/ai/ai-details', () => ({@@ -83,4 +84,7 @@ test('generateV4 calls the tool sanitizer', async () => {await generateV4(mockReq as any, mockRes as any)expect(sanitizeMessagePart).toHaveBeenCalled()+ // The response 'close' event must be wired up so the remote MCP connection+ // opened in getTools is torn down when the stream finishes or the client drops+ expect(mockRes.on).toHaveBeenCalledWith('close', expect.any(Function))})diff --git a/apps/studio/package.json b/apps/studio/package.jsonindex 7da743e96fe..6eaf32965b7 100644--- a/apps/studio/package.json+++ b/apps/studio/package.json@@ -33,6 +33,7 @@"build:graphql-types": "tsx scripts/download-graphql-schema.mts && pnpm graphql-codegen --config scripts/codegen.ts","build:graphql-types:watch": "pnpm graphql-codegen --config scripts/codegen.ts --watch","evals:setup": "cp node_modules/libpg-query/wasm/libpg-query.wasm evals/libpg-query.wasm",+ "evals:preflight": "tsx evals/preflight.ts","evals:run": "braintrust eval --no-send-logs evals/assistant.eval.ts","evals:upload": "braintrust eval evals/assistant.eval.ts","scorers:deploy": "IS_BRAINTRUST_PUSH=true braintrust push evals/scorer-online.ts"diff --git a/apps/studio/pages/api/ai/sql/generate-v4.ts b/apps/studio/pages/api/ai/sql/generate-v4.tsindex 457881205c7..1bbc78aa29b 100644--- a/apps/studio/pages/api/ai/sql/generate-v4.ts+++ b/apps/studio/pages/api/ai/sql/generate-v4.ts@@ -165,6 +165,9 @@ async function handlePost(req: NextApiRequest, res: NextApiResponse, claims?: Jwconst abortController = new AbortController()req.on('close', () => abortController.abort())req.on('aborted', () => abortController.abort())+ // Fires when the response finishes streaming or the connection drops, which+ // is what tears down the remote MCP connection opened in getTools.+ res.on('close', () => abortController.abort())const tools = await getTools({projectRef,@@ -173,6 +176,7 @@ async function handlePost(req: NextApiRequest, res: NextApiResponse, claims?: JwaiOptInLevel,accessToken,baseUrl: getURL(),+ signal: abortController.signal,})// Get a list of all schemas to add to contextdiff --git a/apps/studio/pages/api/ai/sql/policy.ts b/apps/studio/pages/api/ai/sql/policy.tsindex a6c30ebd76f..8cb27ed7061 100644--- a/apps/studio/pages/api/ai/sql/policy.ts+++ b/apps/studio/pages/api/ai/sql/policy.ts@@ -100,53 +100,67 @@ export async function handlePost(req: NextApiRequest, res: NextApiResponse) {return res.status(500).json({ error: modelError.message })}- const tools = await getTools({- projectRef,- connectionString,- authorization,- aiOptInLevel,- accessToken,- })+ // Closes the remote MCP connection opened in getTools when generation is done,+ // if anything below throws, or if the client disconnects mid-generation so the+ // connection isn't held until generateText resolves on its own (mirrors the+ // request-scoped cleanup in generate-v4.ts).+ const toolsAbortController = new AbortController()+ req.on('close', () => toolsAbortController.abort())+ req.on('aborted', () => toolsAbortController.abort())+ // Fires when the response finishes or the connection drops.+ res.on('close', () => toolsAbortController.abort())+ try {+ const tools = await getTools({+ projectRef,+ connectionString,+ authorization,+ aiOptInLevel,+ accessToken,+ signal: toolsAbortController.signal,+ })- const { experimental_output } = await generateText({- ...modelParams,- stopWhen: stepCountIs(5),- prompt: source`- You are a Postgres RLS (Row Level Security) expert.- Determine the most appropriate policies for the "${schema}"."${tableName}" table within a Supabase project.-- ${columns.length > 0 ? `Table columns: ${columns.join(', ')}` : 'No column metadata provided.'}-- ${message ? `User request: ${message}` : ''}-- RLS Guide: ${RLS_PROMPT}-- Requirements:- - Use the available planning and schema tools (like "list_policies" or "list_tables") to inspect the "${schema}" schema and existing policies before generating new ones.- - Ensure policies strictly adhere to the existing schema- - Return a curated list of recommended CREATE POLICY statements as JSON.- - Each policy must include: name, sql, command (SELECT/INSERT/UPDATE/DELETE/ALL), action (PERMISSIVE/RESTRICTIVE), roles (array of role names).- - Include "definition" (USING clause expression without the USING keyword) for SELECT, UPDATE, DELETE policies.- - Include "check" (WITH CHECK clause expression without the WITH CHECK keywords) for INSERT, UPDATE policies.- - Avoid duplicating existing policies and reference the public schema and typical Supabase best practices when deciding the coverage.- - Prefer PERMISSIVE policies unless a RESTRICTIVE policy is explicitly required- `,- tools,- experimental_output: Output.object({- schema: z.object({- policies: z.array(policySchema),+ const { experimental_output } = await generateText({+ ...modelParams,+ stopWhen: stepCountIs(5),+ prompt: source`+ You are a Postgres RLS (Row Level Security) expert.+ Determine the most appropriate policies for the "${schema}"."${tableName}" table within a Supabase project.++ ${columns.length > 0 ? `Table columns: ${columns.join(', ')}` : 'No column metadata provided.'}++ ${message ? `User request: ${message}` : ''}++ RLS Guide: ${RLS_PROMPT}++ Requirements:+ - Use the available planning and schema tools (like "list_policies" or "list_tables") to inspect the "${schema}" schema and existing policies before generating new ones.+ - Ensure policies strictly adhere to the existing schema+ - Return a curated list of recommended CREATE POLICY statements as JSON.+ - Each policy must include: name, sql, command (SELECT/INSERT/UPDATE/DELETE/ALL), action (PERMISSIVE/RESTRICTIVE), roles (array of role names).+ - Include "definition" (USING clause expression without the USING keyword) for SELECT, UPDATE, DELETE policies.+ - Include "check" (WITH CHECK clause expression without the WITH CHECK keywords) for INSERT, UPDATE policies.+ - Avoid duplicating existing policies and reference the public schema and typical Supabase best practices when deciding the coverage.+ - Prefer PERMISSIVE policies unless a RESTRICTIVE policy is explicitly required+ `,+ tools,+ experimental_output: Output.object({+ schema: z.object({+ policies: z.array(policySchema),+ }),}),- }),- })+ })- // Add table and schema to each policy from the request- const policies = (experimental_output?.policies ?? []).map((policy) => ({- ...policy,- table: tableName,- schema,- }))+ // Add table and schema to each policy from the request+ const policies = (experimental_output?.policies ?? []).map((policy) => ({+ ...policy,+ table: tableName,+ schema,+ }))- return res.json(policies)+ return res.json(policies)+ } finally {+ toolsAbortController.abort()+ }} catch (error) {if (error instanceof Error) {console.error(`AI policy generation failed: ${error.message}`)diff --git a/apps/studio/turbo.jsonc b/apps/studio/turbo.jsoncindex d47f1beea95..08a66e00023 100644--- a/apps/studio/turbo.jsonc+++ b/apps/studio/turbo.jsonc@@ -71,6 +71,9 @@"OPENAI_API_KEY","BRAINTRUST_API_KEY","BRAINTRUST_PROJECT_ID",+ // Gates the dashboard assistant between the remote MCP server and the+ // legacy in-process one (see lib/ai/tools/mcp-tools.ts).+ "USE_REMOTE_MCP","AUTH_JWT_SECRET","LOGFLARE_API_KEY","LOGFLARE_PUBLIC_ACCESS_TOKEN",