Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

fix(canvas): share one connector access prompt across parallel calls (#130335)

posthog[bot]5b14ca5e8659
diff --git a/products/canvas/frontend/host/canvasDataBridge.test.ts b/products/canvas/frontend/host/canvasDataBridge.test.ts
index a134b2008af4..e9855a4642de 100644
--- a/products/canvas/frontend/host/canvasDataBridge.test.ts
+++ b/products/canvas/frontend/host/canvasDataBridge.test.ts
@@ -1,6 +1,11 @@
import api from 'lib/api'
-import { canvasesActionsInvoke, canvasesActionsRetrieve, canvasesToolsInvoke } from '../generated/api'
+import {
+ canvasesActionsInvoke,
+ canvasesActionsRetrieve,
+ canvasesConnectorsCall,
+ canvasesToolsInvoke,
+} from '../generated/api'
import { CanvasDataBridge } from './canvasDataBridge'
jest.mock('../generated/api')
@@ -169,3 +174,66 @@ describe('CanvasDataBridge action confirmation', () => {
expect(confirmAction).toHaveBeenCalledTimes(method === 'toolCall' && !tool.read_only ? 1 : 0)
})
})
+
+describe('CanvasDataBridge connector consent', () => {
+ test.each([
+ {
+ allowed: true,
+ outcome: { status: 'fulfilled', value: expect.objectContaining({ status: 'ok' }) },
+ apiCalls: 4,
+ },
+ {
+ allowed: false,
+ outcome: {
+ status: 'rejected',
+ reason: expect.objectContaining({ message: expect.stringContaining('not granted') }),
+ },
+ apiCalls: 0,
+ },
+ ])('parallel calls for one tool share one prompt, allowed: $allowed', async ({ allowed, outcome, apiCalls }) => {
+ jest.mocked(canvasesConnectorsCall)
+ .mockReset()
+ .mockResolvedValue({
+ status: 'ok',
+ result: { items: [] },
+ detail: '',
+ truncated: false,
+ connect_path: null,
+ approval_token: null,
+ })
+ let answer!: (allowed: boolean) => void
+ const requestConnectorPermission = jest.fn(
+ () =>
+ new Promise<boolean>((resolve) => {
+ answer = resolve
+ })
+ )
+ const bridge = new CanvasDataBridge(
+ () => ({
+ projectId: '1',
+ canvasId: 'canvas-1',
+ sourceVersionId: 'v1',
+ captureToken: null,
+ distinctId: null,
+ }),
+ {
+ confirmAction: jest.fn(),
+ confirmAgentRequest: jest.fn(),
+ requestConnectorPermission,
+ hasUserActivation: () => false,
+ }
+ )
+ const call = (page: number): Promise<unknown> =>
+ bridge.handle('connectorCall', { provider: 'github', tool: 'list_pull_requests', arguments: { page } })
+
+ const parallel = Promise.allSettled([1, 2, 3].map(call))
+ answer(allowed)
+ // The fourth call starts after the answer, so it reads the stored answer and neither
+ // asks again nor reopens a denied prompt without a click.
+ const outcomes = [...(await parallel), ...(await Promise.allSettled([call(4)]))]
+
+ expect(outcomes).toEqual(Array(4).fill(outcome))
+ expect(requestConnectorPermission).toHaveBeenCalledTimes(1)
+ expect(canvasesConnectorsCall).toHaveBeenCalledTimes(apiCalls)
+ })
+})
diff --git a/products/canvas/frontend/host/canvasDataBridge.ts b/products/canvas/frontend/host/canvasDataBridge.ts
index b760ce838df5..f7f7596d777e 100644
--- a/products/canvas/frontend/host/canvasDataBridge.ts
+++ b/products/canvas/frontend/host/canvasDataBridge.ts
@@ -165,6 +165,7 @@ function assertVariablesApplied(
export class CanvasDataBridge {
private readonly cache = new CanvasReadCache()
private readonly connectorConsent = new Map<string, boolean>()
+ private readonly pendingConnectorConsent = new Map<string, Promise<boolean>>()
private toolRegistry: Promise<CanvasToolDefinitionApi[]> | null = null
constructor(
@@ -474,7 +475,7 @@ export class CanvasDataBridge {
private async requireConnectorConsent(sourceVersionId: string, input: CanvasConnectorCallInput): Promise<void> {
const key = `${sourceVersionId}:${input.provider}:${input.tool}`
- const known = this.connectorConsent.get(key)
+ const known = this.pendingConnectorConsent.has(key) ? undefined : this.connectorConsent.get(key)
// A denial sticks until the viewer interacts with the canvas again, so a render
// loop cannot reopen the dialog.
if (known === true || (known === false && !this.prompts.hasUserActivation())) {
@@ -483,14 +484,25 @@ export class CanvasDataBridge {
}
throw new Error('Connector access was not granted. Click in the canvas to try again.')
}
- const allowed = await this.prompts.requestConnectorPermission({
- provider: input.provider,
- tool: input.tool,
- reason: 'canvas',
- })
- this.connectorConsent.set(key, allowed)
- if (!allowed) {
+ if (!(await this.connectorConsentPrompt(key, input))) {
throw new Error('Connector access was not granted. Click in the canvas to try again.')
}
}
+
+ // A canvas often starts several connector reads at once. Each call for the same key
+ // awaits the one open prompt, so the viewer answers once instead of once per call.
+ private connectorConsentPrompt(key: string, input: CanvasConnectorCallInput): Promise<boolean> {
+ let pending = this.pendingConnectorConsent.get(key)
+ if (!pending) {
+ pending = this.prompts
+ .requestConnectorPermission({ provider: input.provider, tool: input.tool, reason: 'canvas' })
+ .then((allowed) => {
+ this.connectorConsent.set(key, allowed)
+ return allowed
+ })
+ .finally(() => this.pendingConnectorConsent.delete(key))
+ this.pendingConnectorConsent.set(key, pending)
+ }
+ return pending
+ }
}