Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
import { randomBytes, randomUUID } from 'node:crypto'
import { Pool } from 'pg'
import { initDb } from '../src/db.js'
import { deriveOAuthEncryptionKey } from '../src/oauth/encryption.js'
import { evaluateBudgetCheck } from '../src/services/budgets/check.js'
import { getActiveReservation } from '../src/services/budgets/reservations.js'
import { getCodexCatalogModelState } from '../src/services/codexSubscriptionCatalog.js'
import {
getSafeCodexSubscriptionConnection,
insertInitialCodexSubscriptionConnection,
recordCodexCatalogOutcome,
} from '../src/services/codexSubscriptionConnection.js'
import {
LlmProviderAttemptAuthorizeError,
type LlmProviderAttemptAuthorizerDeps,
authorizeLlmProviderAttempt,
computeCodexPolicyHash,
} from '../src/services/llmProviderAttemptAuthorizer.js'
import {
type LlmProviderAttemptInsert,
getMaxLlmProviderAttemptGeneration,
insertLlmProviderAttempt,
loadLlmProviderAttemptBySdkAttemptId,
} from '../src/services/llmProviderAttemptStore.js'
import { issueRegisteredCodexExecutionTicket } from '../src/services/llmProviderAttemptTicket.js'
import { prunePluginWorkloadSdkExpiredIdempotencyInTransaction } from '../src/services/pluginWorkloadSdkDb.js'
import { finalizePromptBridgeInTransaction } from '../src/services/pluginWorkloadSdkFinalization.js'
import type { McpHostAccessClaims } from '../src/utils/auth/mcpHostJwtToken.js'
import './realPostgres.requirement.ts'
const adminUrl = process.env.CONTROL_API_REAL_PG_ADMIN_URL
const describeRealPostgres = adminUrl ? describe : describe.skip
const KEY = deriveOAuthEncryptionKey('ab'.repeat(32))
const NS = 'sandbox-recipes'
const RECIPE = 'prompt-notify'
const MODEL = 'gpt-5.1'
function databaseUrl(baseUrl: string, database: string): string {
const url = new URL(baseUrl)
url.pathname = `/${database}`
return url.toString()
}
function quoteIdent(value: string): string {
return `"${value.replace(/"/g, '""')}"`
}
const REQUEST = {
schemaVersion: 'codex-completion-request.v1' as const,
requestId: 'req-sdk-dual-ledger',
idempotencyKey: 'idem-sdk-dual-ledger',
provider: 'codex-subscription' as const,
model: MODEL,
messages: [{ role: 'user' as const, content: 'sdk dual ledger' }],
}
function recipeClaims(): McpHostAccessClaims {
return {
sub: `${NS}/${RECIPE}`,
recipeNamespace: NS,
recipeName: RECIPE,
hostRefs: [`${NS}/${RECIPE}`],
scope: 'workflow:approval:request',
workflowControlScopes: ['llm:codex:execute'],
iss: 'control-api',
aud: 'workflow-approvals',
jti: randomUUID(),
exp: Math.floor(Date.now() / 1000) + 60,
}
}
function hostClaims(): McpHostAccessClaims {
return {
sub: 'default/research-host',
recipeNamespace: 'default',
recipeName: 'research-host',
hostRefs: ['research-host'],
scope: 'workflow:approval:request',
workflowControlScopes: ['llm:codex:execute'],
iss: 'control-api',
aud: 'workflow-approvals',
jti: randomUUID(),
exp: Math.floor(Date.now() / 1000) + 60,
}
}
function attemptInput(overrides: Partial<LlmProviderAttemptInsert> = {}): LlmProviderAttemptInsert {
return {
callerKind: 'recipe',
hostRef: `${NS}/${RECIPE}`,
recipeNamespace: NS,
recipeName: RECIPE,
invocationId: `invocation-${randomUUID()}`,
attemptGeneration: 1,
providerAttemptIndex: 1,
model: MODEL,
requestHash: 'c'.repeat(64),
policyRevision: 1,
policyHash: 'd'.repeat(64),
budgetReservationId: 'reservation-1',
connectionRevision: 1,
...overrides,
}
}
describeRealPostgres('Plugin Workload SDK Codex dual ledger on real PostgreSQL', () => {
const database = `sdk_codex_dual_${randomBytes(6).toString('hex')}`
const connectionString = databaseUrl(
adminUrl ?? `postgresql://postgres@${['127', '0', '0', '1'].join('.')}/postgres`,
database
)
let adminPool: Pool
let pool: Pool
function dbClient() {
return { query: (text: string, values?: unknown[]) => pool.query(text, values) }
}
function testDeps(
overrides: Partial<LlmProviderAttemptAuthorizerDeps> = {}
): LlmProviderAttemptAuthorizerDeps {
const db = dbClient()
return {
enabled: true,
db,
withTransaction: async work => {
const client = await pool.connect()
try {
await client.query('BEGIN')
const result = await work(client as never)
await client.query('COMMIT')
return result
} catch (error) {
try {
await client.query('ROLLBACK')
} catch {
// keep the original error
}
throw error
} finally {
client.release()
}
},
getConnection: getSafeCodexSubscriptionConnection,
getModelState: getCodexCatalogModelState,
resolveAssignment: async () => ({
liveBrokerProviders: ['codex-subscription'],
liveConnectionRef: 'deployment-default',
}),
evaluateBudget: evaluateBudgetCheck,
getActiveReservation,
getMaxGeneration: getMaxLlmProviderAttemptGeneration,
insertAttempt: insertLlmProviderAttempt,
issueTicket: issueRegisteredCodexExecutionTicket,
...overrides,
}
}
async function seedSdkAttempt(
input: {
invocationId?: string
status?: string
provider?: string
model?: string
credentialSlot?: string
targetRef?: string
} = {}
): Promise<{ invocationId: string; sdkAttemptId: string }> {
const invocationId = input.invocationId ?? randomUUID()
await pool.query(
`INSERT INTO plugin_workload_sdk_invocations (
id, recipe_namespace, recipe_name, caller_ref, method, detail,
idempotency_key_hash, status, authorization_decision, contract_version,
attempt_generation, lease_expires_at
) VALUES ($1, $2, $3, 'api', 'promptBridge', 'prompt', $4, 'in_progress',
'allow', 2, 1, now() + interval '5 minutes')`,
[invocationId, NS, RECIPE, randomBytes(32).toString('hex')]
)
await pool.query(
`INSERT INTO plugin_workload_sdk_invocation_attempts (
invocation_id, recipe_namespace, recipe_name, attempt_generation,
method, status, lease_expires_at
) VALUES ($1, $2, $3, 1, 'promptBridge', 'in_progress',
now() + interval '5 minutes')`,
[invocationId, NS, RECIPE]
)
const inserted = await pool.query<{ id: string }>(
`INSERT INTO plugin_workload_sdk_provider_attempts (
invocation_id, recipe_namespace, recipe_name, attempt_generation,
attempt_index, target_ref, provider, model, credential_slot, status,
lease_expires_at
) VALUES ($1, $2, $3, 1, 1, $4, $5, $6, $7, $8, now() + interval '5 minutes')
RETURNING id::text AS id`,
[
invocationId,
NS,
RECIPE,
input.targetRef ?? 'codex-primary',
input.provider ?? 'codex-subscription',
input.model ?? MODEL,
input.credentialSlot ?? '',
input.status ?? 'reserved',
]
)
return { invocationId, sdkAttemptId: inserted.rows[0]!.id }
}
beforeAll(async () => {
adminPool = new Pool({ connectionString: adminUrl })
await adminPool.query(`CREATE DATABASE ${quoteIdent(database)}`)
pool = new Pool({ connectionString })
await initDb({ connect: () => pool.connect() })
const created = await insertInitialCodexSubscriptionConnection(pool, KEY, {
refreshToken: 'refresh-sdk-dual',
accountFingerprint: 'fp-sdk-dual',
})
await recordCodexCatalogOutcome(pool, {
catalogStatus: 'ready',
expectedCredentialRevision: 1,
expectedCatalogRevision: 0,
})
await pool.query(
`INSERT INTO codex_catalog_models
(connection_id, model, enabled, source, discovered_at, last_seen_at, stale)
VALUES ($1, $2, true, 'discovery', NOW(), NOW(), false)`,
[created.id, MODEL]
)
}, 60_000)
afterAll(async () => {
try {
await pool?.end()
if (adminPool) {
await adminPool
.query(`DROP DATABASE IF EXISTS ${quoteIdent(database)}`)
.catch(() => undefined)
}
} finally {
await adminPool?.end()
}
})
it('adds a unique nullable FK from Codex attempts onto reserved SDK attempts', async () => {
const columns = await pool.query<{ column_name: string }>(
`SELECT column_name
FROM information_schema.columns
WHERE table_schema = 'public'
AND table_name = 'llm_provider_attempts'
AND column_name = 'plugin_workload_sdk_provider_attempt_id'`
)
expect(columns.rows).toHaveLength(1)
const { sdkAttemptId } = await seedSdkAttempt()
const first = await insertLlmProviderAttempt(
pool,
attemptInput({ pluginWorkloadSdkProviderAttemptId: sdkAttemptId })
)
expect(first.pluginWorkloadSdkProviderAttemptId).toBe(sdkAttemptId)
await expect(
insertLlmProviderAttempt(
pool,
attemptInput({
invocationId: `invocation-${randomUUID()}`,
providerAttemptIndex: 2,
pluginWorkloadSdkProviderAttemptId: sdkAttemptId,
})
)
).rejects.toThrow(/duplicate|unique/i)
const host = await insertLlmProviderAttempt(
pool,
attemptInput({
callerKind: 'host',
hostRef: 'research-host',
recipeNamespace: null,
recipeName: null,
invocationId: `host-${randomUUID()}`,
})
)
expect(host.pluginWorkloadSdkProviderAttemptId ?? null).toBeNull()
})
it('authorizes a recipe Codex attempt bound to a reserved SDK attempt id', async () => {
const current = await getSafeCodexSubscriptionConnection(pool)
expect(current?.status).toBe('connected')
const { invocationId, sdkAttemptId } = await seedSdkAttempt()
const authorized = await authorizeLlmProviderAttempt(
recipeClaims(),
{
request: {
...REQUEST,
requestId: `req-${invocationId}`,
idempotencyKey: `idem-${invocationId}`,
},
invocationId,
attemptGeneration: 1,
providerAttemptIndex: 1,
policyRevision: current!.catalogRevision,
policyHash: computeCodexPolicyHash({
model: MODEL,
catalogRevision: current!.catalogRevision,
credentialRevision: current!.credentialRevision,
connectionKey: current!.connectionKey,
}),
pluginWorkloadSdkProviderAttemptId: sdkAttemptId,
},
testDeps()
)
const linked = await loadLlmProviderAttemptBySdkAttemptId(pool, sdkAttemptId)
expect(linked?.id).toBe(authorized.providerAttemptId)
expect(linked?.pluginWorkloadSdkProviderAttemptId).toBe(sdkAttemptId)
expect(linked?.invocationId).toBe(invocationId)
const promoted = await pool.query<{ status: string; credential_jti: string | null }>(
`SELECT status, credential_jti
FROM plugin_workload_sdk_provider_attempts
WHERE id = $1`,
[sdkAttemptId]
)
expect(promoted.rows[0]).toEqual({ status: 'in_progress', credential_jti: null })
expect(JSON.stringify(authorized)).not.toContain('refresh-sdk-dual')
})
it('authorizes a host Codex attempt without an SDK FK', async () => {
const current = await getSafeCodexSubscriptionConnection(pool)
const invocationId = `host-invocation-${randomUUID()}`
const authorized = await authorizeLlmProviderAttempt(
hostClaims(),
{
request: {
...REQUEST,
requestId: `req-${invocationId}`,
idempotencyKey: `idem-${invocationId}`,
},
invocationId,
attemptGeneration: 1,
providerAttemptIndex: 1,
policyRevision: current!.catalogRevision,
policyHash: computeCodexPolicyHash({
model: MODEL,
catalogRevision: current!.catalogRevision,
credentialRevision: current!.credentialRevision,
connectionKey: current!.connectionKey,
}),
},
testDeps()
)
const stored = await pool.query<{ plugin_workload_sdk_provider_attempt_id: string | null }>(
`SELECT plugin_workload_sdk_provider_attempt_id
FROM llm_provider_attempts
WHERE id = $1`,
[authorized.providerAttemptId]
)
expect(stored.rows[0]?.plugin_workload_sdk_provider_attempt_id).toBeNull()
})
it('rejects Codex complete while the reserved SDK attempt has not been authorized', async () => {
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'reserved' })
await expect(
finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'complete',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'provider_completed',
usage: {
llmSecretName: '',
callerRef: 'scanner',
fallbackUsed: false,
attemptCount: 1,
inputTokens: 0,
outputTokens: 0,
},
},
pool
)
).rejects.toMatchObject({
name: 'PromptBridgeFinalizationError',
code: 'conflict',
httpStatus: 409,
})
})
it('refuses Codex complete while the linked attempt is still in flight', async () => {
const current = await getSafeCodexSubscriptionConnection(pool)
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'reserved' })
await authorizeLlmProviderAttempt(
recipeClaims(),
{
request: {
...REQUEST,
requestId: `req-pending-${invocationId}`,
idempotencyKey: `idem-pending-${invocationId}`,
},
invocationId,
attemptGeneration: 1,
providerAttemptIndex: 1,
policyRevision: current!.catalogRevision,
policyHash: computeCodexPolicyHash({
model: MODEL,
catalogRevision: current!.catalogRevision,
credentialRevision: current!.credentialRevision,
connectionKey: current!.connectionKey,
}),
pluginWorkloadSdkProviderAttemptId: sdkAttemptId,
targetRef: 'codex-primary',
},
testDeps()
)
const linked = await loadLlmProviderAttemptBySdkAttemptId(pool, sdkAttemptId)
expect(linked?.status).toBe('authorized')
expect(linked?.usageInputTokens ?? null).toBeNull()
await expect(
finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'complete',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'provider_completed',
usage: {
llmSecretName: '',
callerRef: 'scanner',
fallbackUsed: false,
attemptCount: 1,
inputTokens: 0,
outputTokens: 0,
},
},
pool
)
).rejects.toMatchObject({
name: 'PromptBridgeFinalizationError',
code: 'ledger_pending',
httpStatus: 409,
retryable: true,
})
const spend = await pool.query(
`SELECT provider_attempt_id
FROM plugin_workload_sdk_spend_outcomes
WHERE provider_attempt_id = $1`,
[sdkAttemptId]
)
expect(spend.rows).toHaveLength(0)
})
it('finalizes complete plus linked Codex success as exact using Codex usage', async () => {
const current = await getSafeCodexSubscriptionConnection(pool)
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'reserved' })
const authorized = await authorizeLlmProviderAttempt(
recipeClaims(),
{
request: {
...REQUEST,
requestId: `req-exact-${invocationId}`,
idempotencyKey: `idem-exact-${invocationId}`,
},
invocationId,
attemptGeneration: 1,
providerAttemptIndex: 1,
policyRevision: current!.catalogRevision,
policyHash: computeCodexPolicyHash({
model: MODEL,
catalogRevision: current!.catalogRevision,
credentialRevision: current!.credentialRevision,
connectionKey: current!.connectionKey,
}),
pluginWorkloadSdkProviderAttemptId: sdkAttemptId,
targetRef: 'codex-primary',
},
testDeps()
)
await pool.query(
`UPDATE llm_provider_attempts
SET status = 'finalized',
outcome = 'success',
usage_input_tokens = 12,
usage_output_tokens = 7,
finalized_at = now()
WHERE id = $1`,
[authorized.providerAttemptId]
)
const result = await finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'complete',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'provider_completed',
usage: {
llmSecretName: '',
callerRef: 'scanner',
fallbackUsed: false,
attemptCount: 1,
inputTokens: 0,
outputTokens: 0,
},
},
pool
)
expect(result).toMatchObject({
status: 'complete',
outcome: 'exact',
usageAccepted: false,
})
const spend = await pool.query<{
outcome: string
input_tokens: number
output_tokens: number
credential_slot: string
}>(
`SELECT outcome, input_tokens, output_tokens, credential_slot
FROM plugin_workload_sdk_spend_outcomes
WHERE provider_attempt_id = $1`,
[sdkAttemptId]
)
expect(spend.rows[0]).toEqual({
outcome: 'exact',
input_tokens: 12,
output_tokens: 7,
credential_slot: '',
})
// Addendum A.4.3: the host is not the source of truth for oauth-broker
// spend, so a later `failed` report cannot contradict an exact floor that
// Codex itself proved. It used to 409, which made the host's retry of a
// lost response look like an accounting conflict.
await expect(
finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'failed',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'provider_stream_failed',
},
pool
)
).resolves.toMatchObject({
status: 'failed',
outcome: 'exact',
idempotent: true,
usageAccepted: false,
})
const unchanged = await pool.query(
`SELECT outcome, input_tokens, output_tokens, reason
FROM plugin_workload_sdk_spend_outcomes
WHERE provider_attempt_id = $1`,
[sdkAttemptId]
)
expect(unchanged.rows[0]).toEqual({
outcome: 'exact',
input_tokens: 12,
output_tokens: 7,
reason: 'provider_completed',
})
})
it('finalizes a pre-dispatch Codex miss as not_executed', async () => {
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'reserved' })
const result = await finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'failed',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'codex_execution_binding_missing',
},
pool
)
expect(result).toMatchObject({
status: 'failed',
outcome: 'not_executed',
usageAccepted: false,
})
const spend = await pool.query<{
outcome: string
input_tokens: number | null
output_tokens: number | null
}>(
`SELECT outcome, input_tokens, output_tokens
FROM plugin_workload_sdk_spend_outcomes
WHERE provider_attempt_id = $1`,
[sdkAttemptId]
)
expect(spend.rows[0]).toEqual({
outcome: 'not_executed',
input_tokens: null,
output_tokens: null,
})
expect(await loadLlmProviderAttemptBySdkAttemptId(pool, sdkAttemptId)).toBeNull()
})
it('finalizes complete without a linked Codex success as unknown', async () => {
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'in_progress' })
const result = await finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'complete',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'provider_completed',
usage: {
llmSecretName: '',
callerRef: 'scanner',
fallbackUsed: false,
attemptCount: 1,
inputTokens: 4,
outputTokens: 2,
},
},
pool
)
expect(result).toMatchObject({
status: 'complete',
outcome: 'unknown',
usageAccepted: false,
})
const spend = await pool.query<{
outcome: string
input_tokens: number | null
output_tokens: number | null
}>(
`SELECT outcome, input_tokens, output_tokens
FROM plugin_workload_sdk_spend_outcomes
WHERE provider_attempt_id = $1`,
[sdkAttemptId]
)
expect(spend.rows[0]).toEqual({
outcome: 'unknown',
input_tokens: null,
output_tokens: null,
})
await expect(
finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'complete',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'provider_completed',
usage: {
llmSecretName: '',
callerRef: 'scanner',
fallbackUsed: false,
attemptCount: 1,
inputTokens: 4,
outputTokens: 2,
},
},
pool
)
).resolves.toMatchObject({ idempotent: true, outcome: 'unknown', usageAccepted: false })
})
it('refuses authorize-link after finalize failed already wrote spend', async () => {
const current = await getSafeCodexSubscriptionConnection(pool)
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'reserved' })
await finalizePromptBridgeInTransaction(
{
invocationId,
recipeNamespace: NS,
recipeName: RECIPE,
hostRef: `${NS}/${RECIPE}`,
attemptGeneration: 1,
providerAttemptId: sdkAttemptId,
providerAttemptIndex: 1,
status: 'failed',
target: {
targetRef: 'codex-primary',
provider: 'codex-subscription',
model: MODEL,
credentialSlot: '',
},
reason: 'codex_execution_binding_missing',
},
pool
)
await expect(
authorizeLlmProviderAttempt(
recipeClaims(),
{
request: {
...REQUEST,
requestId: `req-race-${invocationId}`,
idempotencyKey: `idem-race-${invocationId}`,
},
invocationId,
attemptGeneration: 1,
providerAttemptIndex: 1,
policyRevision: current!.catalogRevision,
policyHash: computeCodexPolicyHash({
model: MODEL,
catalogRevision: current!.catalogRevision,
credentialRevision: current!.credentialRevision,
connectionKey: current!.connectionKey,
}),
pluginWorkloadSdkProviderAttemptId: sdkAttemptId,
targetRef: 'codex-primary',
},
testDeps()
)
).rejects.toBeInstanceOf(LlmProviderAttemptAuthorizeError)
expect(await loadLlmProviderAttemptBySdkAttemptId(pool, sdkAttemptId)).toBeNull()
})
it('prunes a linked terminal SDK attempt without deleting the Codex ledger row', async () => {
const { invocationId, sdkAttemptId } = await seedSdkAttempt({ status: 'reserved' })
const current = await getSafeCodexSubscriptionConnection(pool)
const authorized = await authorizeLlmProviderAttempt(
recipeClaims(),
{
request: {
...REQUEST,
requestId: `req-prune-${invocationId}`,
idempotencyKey: `idem-prune-${invocationId}`,
},
invocationId,
attemptGeneration: 1,
providerAttemptIndex: 1,
policyRevision: current!.catalogRevision,
policyHash: computeCodexPolicyHash({
model: MODEL,
catalogRevision: current!.catalogRevision,
credentialRevision: current!.credentialRevision,
connectionKey: current!.connectionKey,
}),
pluginWorkloadSdkProviderAttemptId: sdkAttemptId,
targetRef: 'codex-primary',
},
testDeps()
)
await pool.query(
`UPDATE plugin_workload_sdk_invocations
SET status = 'complete', created_at = now() - interval '25 hours'
WHERE id = $1`,
[invocationId]
)
const deleteRule = await pool.query<{ delete_rule: string }>(
`SELECT rc.delete_rule
FROM information_schema.referential_constraints rc
JOIN information_schema.key_column_usage kcu
ON rc.constraint_name = kcu.constraint_name
WHERE kcu.table_name = 'llm_provider_attempts'
AND kcu.column_name = 'plugin_workload_sdk_provider_attempt_id'`
)
expect(deleteRule.rows[0]?.delete_rule).toBe('SET NULL')
const pruned = await prunePluginWorkloadSdkExpiredIdempotencyInTransaction(pool)
expect(pruned).toBeGreaterThan(0)
const leftoverSdk = await pool.query(
`SELECT id FROM plugin_workload_sdk_provider_attempts WHERE id = $1`,
[sdkAttemptId]
)
expect(leftoverSdk.rows).toHaveLength(0)
const ledger = await pool.query<{
id: string
plugin_workload_sdk_provider_attempt_id: string | null
}>(
`SELECT id, plugin_workload_sdk_provider_attempt_id
FROM llm_provider_attempts
WHERE id = $1`,
[authorized.providerAttemptId]
)
expect(ledger.rows[0]).toEqual({
id: authorized.providerAttemptId,
plugin_workload_sdk_provider_attempt_id: null,
})
})
})