diff --git a/server/src/index.ts b/server/src/index.ts index af3393d0076..ad8fde47768 100644 --- a/server/src/index.ts +++ b/server/src/index.ts @@ -4,6 +4,7 @@ import { closeProcessRunAdmission, isProcessRunAdmissionClosed } from "./service import { registerReattachPhaseWork } from "./services/heartbeat/reattach-phase.js"; import { createRunStartHandover, registerRunStartHandover } from "./services/run-start-handover.js"; import { registerOwnershipReconciliationWork } from "./services/native-runtime/native-finalization-reconciler.js"; +import { registerPersonCommentWaitWork } from "./services/native-runtime/native-provider-turn-wait.js"; import { bindIdleDeadlineOwner } from "./services/idle-deadline-owner.js"; import { readIdleRetrySchedule } from "./services/heartbeat/idle-retry-schedule.js"; import { readIdleQuotaSchedule } from "./services/heartbeat/idle-quota-schedule.js"; @@ -1500,6 +1501,8 @@ async function startServerWithDatabaseTeardown( server.on("close", () => { void budgetEnforcementWorker.stop(); }); const accountingWorker = registerCostAccountingWork(db, deliveryWork, accountingHeartbeat.reconcileCostAccounting); server.on("close", accountingWorker.stop); + const personCommentWaitWorker = registerPersonCommentWaitWork(db, deliveryWork); + server.on("close", personCommentWaitWorker.stop); skillSourceSync.start(deliveryWork); idleDeadlineOwners.skills = bindIdleDeadlineOwner(skillSourceSync.reconciliationSnapshot, readIdleSkillSourceSchedule, () => ({ coverage: { kind: "skill_sources" } })); @@ -1625,7 +1628,7 @@ async function startServerWithDatabaseTeardown( () => !isIdleTaskDrainActive() && !heartbeatSchedulerStopped && !isWarmStandby()).ready) .catch((err: unknown) => logger.error({ err }, "startup provider task recovery failed")))); trackHeartbeatSchedulerWork(startupTimeline.background("delivery_workers", () => timeStartupRecovery("delivery_workers", - () => Promise.all([budgetEnforcementWorker, accountingWorker, fastResponseWorker, ...deliveryWorkers].map(worker => worker.ready))))); + () => Promise.all([budgetEnforcementWorker, accountingWorker, personCommentWaitWorker, fastResponseWorker, ...deliveryWorkers].map(worker => worker.ready))))); trackHeartbeatSchedulerWork(startupTimeline.background("github_connections", () => Promise.all([githubEventWorker.ready, githubContinuityWorker.ready]))); diff --git a/server/src/services/delivery-work-notifications.ts b/server/src/services/delivery-work-notifications.ts index 46b1b53fa83..e419a441e56 100644 --- a/server/src/services/delivery-work-notifications.ts +++ b/server/src/services/delivery-work-notifications.ts @@ -19,6 +19,7 @@ export const DELIVERY_QUEUES = { strandedAgentStatus: "stranded-agent-status", activeRunSilence: "active-run-silence", deferredExecutionReceipts: "deferred-execution-receipts", + nativeProviderTurnWaits: "native-provider-turn-waits", taskRetryReceiptSettlement: "task-retry-receipt-settlement", nativeStatusWakeIntents: "native-status-wake-intents", orphanBlockers: "orphan-blockers", diff --git a/server/src/services/native-runtime/native-provider-turn-wait.test.ts b/server/src/services/native-runtime/native-provider-turn-wait.test.ts new file mode 100644 index 00000000000..6738589567e --- /dev/null +++ b/server/src/services/native-runtime/native-provider-turn-wait.test.ts @@ -0,0 +1,252 @@ +import { randomUUID } from "node:crypto"; +import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; +import { + agents, agentWakeupRequests, companies, createDb, type Db, EMBEDDED_POSTGRES_TEST_TIMEOUT_MS, heartbeatRuns, issueComments, issues, +} from "@paperclipai/db"; +import { getEmbeddedPostgresTestSupport, startEmbeddedPostgresTestDatabase } from "../../__tests__/helpers/embedded-postgres.js"; +import { appendHeartbeatRunEvent } from "../heartbeat-run-events.js"; +import { notifyDeferredExecutionWork } from "../deferred-execution-notifications.js"; +import { createDeliveryWorkCoordinator } from "../delivery-work-coordinator.js"; +import { idleWorkSnapshot } from "../task-admission.js"; +import { + awaitPersonCommentDuringNativeRun, nativeProviderTurnWaitOptions, nativeProviderTurnWaitStartedAt, personCommentedDuringNativeRun, + registerPersonCommentWaitWork, +} from "./native-provider-turn-wait.js"; + +const support = await getEmbeddedPostgresTestSupport(); +const USER = "provider-turn-user"; + +describe.skipIf(!support.supported)("native provider-turn wait control-plane hooks", () => { + let database: Awaited>; + let db: ReturnType; + let coordinator: ReturnType | undefined; + let worker: ReturnType | undefined; + const errors: unknown[] = []; + const controllers: AbortController[] = []; + beforeAll(async () => { + database = await startEmbeddedPostgresTestDatabase("paperclip-provider-turn-wait-"); + db = createDb(database.connectionString, { idleTimeoutSeconds: 0, connectTimeoutSeconds: 0, maxLifetimeSeconds: 0 }); + }, EMBEDDED_POSTGRES_TEST_TIMEOUT_MS); + beforeEach(() => { + errors.length = 0; + vi.useFakeTimers({ toFake: ["Date", "setTimeout", "clearTimeout"], shouldAdvanceTime: true }); + }); + afterEach(async () => { + for (const controller of controllers.splice(0)) controller.abort(new Error("test ended")); + worker?.stop(); await coordinator?.stop(); worker = undefined; coordinator = undefined; + vi.useRealTimers(); + }); + afterAll(async () => { await db?.$client.end(); await database?.cleanup(); }); + + type Scope = Parameters[1]; + async function start(read: (database: Db, scope: Scope) => Promise = personCommentedDuringNativeRun) { + coordinator = createDeliveryWorkCoordinator({ owner: db, canRun: () => true, canReconcile: () => true, + onError: error => errors.push(error) }); + worker = registerPersonCommentWaitWork(db, coordinator, read); + await worker.ready; + } + const settle = () => vi.waitFor(() => expect(idleWorkSnapshot().active).toBe(0)); + const unavailable = () => new Error("database unavailable"); + function wait(scope: Scope) { + const abort = new AbortController(); + controllers.push(abort); + const state = { ended: false, abort, promise: Promise.resolve() }; + state.promise = awaitPersonCommentDuringNativeRun(db, scope, abort.signal).then(() => { state.ended = true; }); + state.promise.catch(() => {}); + return state; + } + + async function seed(startedAt = new Date()) { + const [company] = await db.insert(companies).values({ name: "Provider turn", issuePrefix: `P${randomUUID().slice(0, 4)}` }).returning(); + const [agent] = await db.insert(agents).values({ companyId: company!.id, name: "Claude", adapterType: "paperclip_runner" }).returning(); + const issueId = randomUUID(); + const [run] = await db.insert(heartbeatRuns).values({ companyId: company!.id, agentId: agent!.id, status: "running", runtimeMode: "native", + runtimeModeResolvedAt: new Date(), nativeIssueId: issueId, responsibleUserId: USER, startedAt, contextSnapshot: { issueId } }).returning(); + await db.insert(issues).values({ id: issueId, companyId: company!.id, title: "Install and test", status: "in_progress", + assigneeAgentId: agent!.id, executionRunId: run!.id }); + return { companyId: company!.id, agentId: agent!.id, issueId, runId: run!.id }; + } + + async function comment(f: Awaited>, author: "user" | "agent", queued: boolean, createdAt?: Date) { + const [saved] = await db.insert(issueComments).values({ companyId: f.companyId, issueId: f.issueId, + ...(author === "user" ? { authorType: "user", authorUserId: USER } : { authorType: "agent", authorAgentId: f.agentId }), + body: "The install finished, please continue.", ...(createdAt ? { createdAt } : {}) }).returning(); + if (queued) { + await db.transaction(async tx => { + await notifyDeferredExecutionWork(tx, { companyId: f.companyId }); + await tx.insert(agentWakeupRequests).values({ companyId: f.companyId, agentId: f.agentId, source: "automation", + triggerDetail: "system", reason: "issue_commented", status: "deferred_issue_execution", + requestedByActorType: "user", requestedByActorId: USER, + payload: { issueId: f.issueId, commentId: saved!.id, _paperclipWakeContext: { issueId: f.issueId, taskId: f.issueId, + wakeReason: "issue_commented", source: "issue.comment", wakeCommentId: saved!.id, wakeCommentIds: [saved!.id] } } }); + }); + } + return saved!.id; + } + + const prpTerminal = (f: Awaited>, awaiting: boolean) => appendHeartbeatRunEvent(db, { + companyId: f.companyId, runId: f.runId, agentId: f.agentId, eventType: "turn.completed", stream: "system", level: "info", + message: "turn completed", payload: { prpEvent: { eventType: "turn.completed", turnId: "turn-1", + payload: { status: "completed", error: null, ...(awaiting ? { awaitingProviderTurn: true } : {}) } } } }); + + it("restores the wait clock from the first awaited terminal and has none for a previous release's run", async () => { + const f = await seed(); + await prpTerminal(f, false); + expect(await nativeProviderTurnWaitStartedAt(db, f)).toBeNull(); + await prpTerminal(f, true); + const first = await nativeProviderTurnWaitStartedAt(db, f); + expect(first).toEqual(expect.any(Number)); + await new Promise(resolve => setTimeout(resolve, 20)); + await prpTerminal(f, true); + expect(await nativeProviderTurnWaitStartedAt(db, f)).toBe(first); + expect((await nativeProviderTurnWaitOptions(db, f)).startedAtMs).toBe(first); + }); + + it("counts only a person's queued comment made during this run", async () => { + const f = await seed(new Date(Date.now() - 60_000)); + await comment(f, "user", true, new Date(Date.now() - 120_000)); + await comment(f, "agent", true); + await comment(f, "user", false); + expect(await personCommentedDuringNativeRun(db, f)).toBe(false); + await comment(f, "user", true); + expect(await personCommentedDuringNativeRun(db, f)).toBe(true); + }); + + it("ends the wait when a person's comment is queued, through the deferred-wake notification", async () => { + await start(); + const f = await seed(); + const abort = new AbortController(); + let ended = false; + const waiting = awaitPersonCommentDuringNativeRun(db, f, abort.signal).then(() => { ended = true; }); + await new Promise(resolve => setTimeout(resolve, 100)); + expect(ended).toBe(false); + await comment(f, "user", true); + await waiting; + expect(ended).toBe(true); + }); + + it("stops listening when the wait ends for another reason", async () => { + await start(); + const f = await seed(); + const abort = new AbortController(); + const waiting = awaitPersonCommentDuringNativeRun(db, f, abort.signal); + abort.abort(new Error("wait ended")); + await expect(waiting).rejects.toThrow("wait ended"); + }); + + it("retries a failed read and finds a comment already queued, with no further notification", async () => { + const f = await seed(); + await comment(f, "user", true); + let failures = 1; + const read = vi.fn(async (database: Db, scope: Scope) => { + if (failures-- > 0) throw unavailable(); + return personCommentedDuringNativeRun(database, scope); + }); + await start(read); + const waiting = wait(f); + await vi.waitFor(() => expect(errors).toHaveLength(1)); + expect(waiting.ended).toBe(false); + expect(coordinator!.nextWakeAt()! - Date.now()).toBeGreaterThan(4_000); + await vi.advanceTimersByTimeAsync(5_000); + await vi.waitFor(() => expect(waiting.ended).toBe(true), { timeout: 2_000 }); + expect(read).toHaveBeenCalledTimes(2); + }); + + it("checks again after a wake that arrives during a failing read", async () => { + const f = await seed(); + let release!: () => void; + const gate = new Promise(resolve => { release = resolve; }); + const read = vi.fn(async (database: Db, scope: Scope) => { + if (read.mock.calls.length === 1) { await gate; throw unavailable(); } + return personCommentedDuringNativeRun(database, scope); + }); + await start(read); + const waiting = wait(f); + await vi.waitFor(() => expect(read).toHaveBeenCalledTimes(1)); + await comment(f, "user", true); + release(); + await vi.waitFor(() => expect(waiting.ended).toBe(true), { timeout: 2_000 }); + expect(read).toHaveBeenCalledTimes(2); + }); + + it("does not let one waiter's failing read hold back another, and resolves each only for its own comment", async () => { + const a = await seed(); + const b = await seed(); + let broken = true; + let checkedA = 0; + const read = vi.fn(async (database: Db, scope: Scope) => { + if (scope.runId === a.runId && broken) throw unavailable(); + const found = await personCommentedDuringNativeRun(database, scope); + if (scope.runId === a.runId) checkedA += 1; + return found; + }); + await start(read); + const waitingA = wait(a); + const waitingB = wait(b); + await vi.waitFor(() => expect(errors.length).toBeGreaterThan(0)); + await comment(b, "user", true); + await vi.waitFor(() => expect(waitingB.ended).toBe(true), { timeout: 2_000 }); + expect(waitingA.ended).toBe(false); + broken = false; + await vi.advanceTimersByTimeAsync(5_000); + await vi.waitFor(() => expect(checkedA).toBeGreaterThan(0), { timeout: 2_000 }); + expect(waitingA.ended).toBe(false); + await comment(a, "user", true); + await vi.waitFor(() => expect(waitingA.ended).toBe(true), { timeout: 2_000 }); + }); + + it("checks a waiter that is added while a check is running", async () => { + const first = await seed(); + const second = await seed(); + await comment(second, "user", true); + let release!: () => void; + const gate = new Promise(resolve => { release = resolve; }); + const read = vi.fn(async (database: Db, scope: Scope) => { + if (scope.runId === first.runId) await gate; + return personCommentedDuringNativeRun(database, scope); + }); + await start(read); + const waitingFirst = wait(first); + await vi.waitFor(() => expect(read).toHaveBeenCalledTimes(1)); + const waitingSecond = wait(second); + release(); + await vi.waitFor(() => expect(waitingSecond.ended).toBe(true), { timeout: 2_000 }); + expect(read.mock.calls.map(([, scope]) => scope.runId)).toEqual([first.runId, second.runId]); + expect(waitingFirst.ended).toBe(false); + }); + + it("removes an aborted waiter so nothing checks its scope again and no deadline remains", async () => { + const f = await seed(); + const read = vi.fn(async (_database: Db, _scope: Scope) => { throw unavailable(); }); + await start(read); + const abort = new AbortController(); + const waiting = awaitPersonCommentDuringNativeRun(db, f, abort.signal); + await vi.waitFor(() => expect(errors).toHaveLength(1)); + expect(coordinator!.nextWakeAt()).not.toBeNull(); + const reason = new Error("wait ended"); + abort.abort(reason); + await expect(waiting).rejects.toBe(reason); + await comment(f, "user", true); + await vi.advanceTimersByTimeAsync(5_000); + await settle(); + await vi.advanceTimersByTimeAsync(3_600_000); + await settle(); + expect(read).toHaveBeenCalledTimes(1); + expect(coordinator!.nextWakeAt()).toBeNull(); + }); + + it("holds no deadline and runs no check while no waiter is owed a check", async () => { + const f = await seed(); + const read = vi.fn(personCommentedDuringNativeRun); + await start(read); + expect(coordinator!.nextWakeAt()).toBeNull(); + wait(f); + await vi.waitFor(() => expect(read).toHaveBeenCalledTimes(1)); + await settle(); + expect(coordinator!.nextWakeAt()).toBeNull(); + await vi.advanceTimersByTimeAsync(3_600_000); + await settle(); + expect(read).toHaveBeenCalledTimes(1); + expect(coordinator!.nextWakeAt()).toBeNull(); + }); +}); diff --git a/server/src/services/native-runtime/native-provider-turn-wait.ts b/server/src/services/native-runtime/native-provider-turn-wait.ts new file mode 100644 index 00000000000..d933ac46589 --- /dev/null +++ b/server/src/services/native-runtime/native-provider-turn-wait.ts @@ -0,0 +1,109 @@ +import { and, asc, eq, gte, isNotNull, isNull, sql } from "drizzle-orm"; +import { agentWakeupRequests, heartbeatRunEvents, heartbeatRuns, issueComments, type Db } from "@paperclipai/db"; + +import type { createDeliveryWorkCoordinator } from "../delivery-work-coordinator.js"; +import { DELIVERY_QUEUES, subscribeDeliveryWork } from "../delivery-work-notifications.js"; +import type { ProviderTurnWaitOptions } from "../../vendor/paperclip-runner/index.js"; + +type NativeRunScope = { companyId: string; runId: string; issueId: string; agentId: string }; + +export async function nativeProviderTurnWaitStartedAt(db: Db, scope: Pick) { + const [first] = await db.select({ createdAt: heartbeatRunEvents.createdAt }).from(heartbeatRunEvents).where(and( + eq(heartbeatRunEvents.companyId, scope.companyId), eq(heartbeatRunEvents.runId, scope.runId), + eq(heartbeatRunEvents.eventType, "turn.completed"), + sql`${heartbeatRunEvents.payload} -> 'prpEvent' -> 'payload' ->> 'awaitingProviderTurn' = 'true'`, + )).orderBy(asc(heartbeatRunEvents.seq)).limit(1); + return first?.createdAt instanceof Date ? first.createdAt.getTime() : null; +} + +export async function personCommentedDuringNativeRun(db: Db, scope: NativeRunScope) { + const [run] = await db.select({ startedAt: heartbeatRuns.startedAt, createdAt: heartbeatRuns.createdAt }).from(heartbeatRuns) + .where(and(eq(heartbeatRuns.companyId, scope.companyId), eq(heartbeatRuns.id, scope.runId))).limit(1); + if (!run) return false; + const [comment] = await db.select({ id: issueComments.id }).from(issueComments).where(and( + eq(issueComments.companyId, scope.companyId), eq(issueComments.issueId, scope.issueId), + isNotNull(issueComments.authorUserId), isNull(issueComments.authorAgentId), isNull(issueComments.createdByRunId), + isNull(issueComments.deletedAt), gte(issueComments.createdAt, run.startedAt ?? run.createdAt), + sql`exists (select 1 from ${agentWakeupRequests} where ${agentWakeupRequests.companyId} = ${scope.companyId} + and ${agentWakeupRequests.agentId} = ${scope.agentId} and ${agentWakeupRequests.status} = 'deferred_issue_execution' + and ${agentWakeupRequests.payload} ->> 'issueId' = ${scope.issueId} + and (${agentWakeupRequests.payload} -> '_paperclipWakeContext' -> 'wakeCommentIds') @> jsonb_build_array((${issueComments.id})::text))`, + )).limit(1); + return comment !== undefined; +} + +type PersonCommentWaiter = { scope: NativeRunScope; owed: boolean; resolve: () => void }; +type Coordinator = Pick, "register">; +const personCommentWaiters = new WeakMap>(); +const personCommentWakes = new WeakMap void>(); + +function waitersFor(db: Db) { + let waiters = personCommentWaiters.get(db); + if (!waiters) personCommentWaiters.set(db, waiters = new Set()); + return waiters; +} + +export function registerPersonCommentWaitWork(db: Db, coordinator: Coordinator, read = personCommentedDuringNativeRun) { + const waiters = waitersFor(db); + const worker = coordinator.register(DELIVERY_QUEUES.nativeProviderTurnWaits, { + retryMs: 5_000, + runDuringDrain: true, + async run(signal) { + const failures: unknown[] = []; + for (const waiter of [...waiters]) { + if (signal.aborted) return; + if (!waiter.owed) continue; + waiter.owed = false; + try { + if (await read(db, waiter.scope) && waiters.delete(waiter)) waiter.resolve(); + } catch (error) { + waiter.owed = true; + failures.push(error); + } + } + if (failures.length) throw failures[0]; + }, + async hasPending() { + return [...waiters].some(waiter => waiter.owed); + }, + }); + personCommentWakes.set(db, worker.wake); + const unsubscribe = subscribeDeliveryWork(db, DELIVERY_QUEUES.deferredExecutionReceipts, () => { + if (!waiters.size) return; + for (const waiter of waiters) waiter.owed = true; + worker.wake(); + }); + const stop = () => { + unsubscribe(); + if (personCommentWakes.get(db) === worker.wake) personCommentWakes.delete(db); + }; + return { ...worker, stop }; +} + +export function awaitPersonCommentDuringNativeRun(db: Db, scope: NativeRunScope, signal: AbortSignal): Promise { + return new Promise((resolve, reject) => { + if (signal.aborted) { + reject(signal.reason); + return; + } + const waiters = waitersFor(db); + const abort = () => { + waiters.delete(waiter); + reject(signal.reason); + }; + const waiter: PersonCommentWaiter = { scope, owed: true, resolve: () => { + signal.removeEventListener("abort", abort); + resolve(); + } }; + signal.addEventListener("abort", abort, { once: true }); + waiters.add(waiter); + personCommentWakes.get(db)?.(); + }); +} + +export async function nativeProviderTurnWaitOptions(db: Db, scope: NativeRunScope): Promise { + return { + startedAtMs: await nativeProviderTurnWaitStartedAt(db, scope), + onWait: ({ signal }) => awaitPersonCommentDuringNativeRun(db, scope, signal), + }; +} diff --git a/server/src/services/native-runtime/native-session-executor.ts b/server/src/services/native-runtime/native-session-executor.ts index fe7843e2a5d..54a3b50501d 100644 --- a/server/src/services/native-runtime/native-session-executor.ts +++ b/server/src/services/native-runtime/native-session-executor.ts @@ -31,6 +31,7 @@ import { prepareRemoteOpenCodeArtifacts, type OpenCodeLaunchArtifacts } from "./ import { prepareRuntimeContextSource, rehydratePinnedInstructionAsset } from "./runtime-context.js"; import { createNativeUsageDelivery } from "./native-usage-delivery.js"; import { createNativeRecoveryUsageDelivery } from "./native-recovery-usage-delivery.js"; +import { nativeProviderTurnWaitOptions } from "./native-provider-turn-wait.js"; import { createNativeTurnAccounting, NATIVE_LOST_TURN_USAGE_EVIDENCE, nativeUsageCostUsd, nativeUsageBiller, normalizeNativeUsage, usesNativeUsageDelivery, isNativeUsageAccountingEvent, isNativeUsageDeliveryEvent } from "./native-usage-accounting.js"; import { crashPoint } from "@paperclipai/shared/crash-points"; export { nativeUsageCostUsd, nativeUsageBiller, normalizeNativeUsage } from "./native-usage-accounting.js"; @@ -12377,10 +12378,13 @@ async function executePaperclipNativeSessionAttempt( startedAtMs: nativeSessionExecuteStartedAtMs, }); trace.activate(runnerSessionStartupScope); + const providerTurnWait = input.execution.provider.kind === "acpx" && input.execution.provider.agent === "claude" + ? await nativeProviderTurnWaitOptions(input.db, input.execution.binding) : undefined; const runExecution = () => executeNativeSession({ resumeInterruptedTurn: input.restartRecovery?.kind === "resume_dead_runner" || input.restartRecovery?.kind === "reattach_remote_runner" || scheduledResumeContinuation, + providerTurnWait, getFreshSessionHandoff: input.getFreshSessionHandoff, // A failed seal commits nothing: the messages stay queued for the // turn boundary instead of failing this run before its turn. diff --git a/server/src/services/native-runtime/native-usage-accounting.test.ts b/server/src/services/native-runtime/native-usage-accounting.test.ts index 00f0bc201ab..c63a01430db 100644 --- a/server/src/services/native-runtime/native-usage-accounting.test.ts +++ b/server/src/services/native-runtime/native-usage-accounting.test.ts @@ -126,6 +126,31 @@ describe("native turn accounting", () => { expect(accounting.snapshot().usage).not.toHaveProperty("accountingUsageLost"); }); + it("counts a prompt turn and the provider-started turn after it once each, as the executor receives them", () => { + const acpx = { kind: "acpx" as const, agent: "claude", model: "claude-sonnet-5" } as never; + const accounting = createNativeTurnAccounting(acpx); + const report = (inputTokens: number, outputTokens: number, sessionCost: number) => ({ kind: "usage", usage: { + total: { inputTokens: 0, outputTokens: 0, providerCostUsd: sessionCost }, + runDelta: { inputTokens, outputTokens, cacheReadTokens: 0, cacheWriteTokens: 0, providerCostUsd: 0 }, runDeltaComplete: true } }); + const history = [ + event(1, "turn.started", "turn_lab_prompt", { status: "inProgress" }), + event(2, "item.completed", "turn_lab_prompt", report(6, 4, 0.2)), + event(3, "turn.completed", "turn_lab_prompt", { status: "completed", error: null, awaitingProviderTurn: true }), + event(4, "turn.started", "provider-1", { status: "inProgress", origin: "provider" }), + event(5, "item.completed", "provider-1", report(30, 20, 0.465)), + event(6, "turn.completed", "provider-1", { status: "completed", error: null }), + ]; + history.forEach(value => accounting.observe(value)); + history.forEach(value => accounting.observe(value)); + const snapshot = accounting.finish("provider-1"); + expect(snapshot.complete).toBe(true); + expect(snapshot.turnId).toBe("provider-1"); + expect(normalizeNativeUsage(snapshot.usage)).toEqual({ inputTokens: 36, outputTokens: 24, cachedInputTokens: 0, cacheWriteTokens: 0 }); + expect(nativeUsageCostUsd(snapshot.usage, acpx)).toBeUndefined(); + expect(snapshot.usage).not.toHaveProperty("accountingCostUsdExact"); + expect(JSON.stringify(snapshot.usage)).not.toMatch(/0\.665|0\.465|0\.2[^0-9]/); + }); + it("keeps an incomplete provider report pending instead of trusting placeholder zeroes", () => { const accounting = createNativeTurnAccounting(provider); accounting.observe(event(1, "turn.started")); diff --git a/server/src/vendor/paperclip-runner/index.ts b/server/src/vendor/paperclip-runner/index.ts index dce78cbca01..24bc7363a46 100644 --- a/server/src/vendor/paperclip-runner/index.ts +++ b/server/src/vendor/paperclip-runner/index.ts @@ -67,6 +67,7 @@ export type { PrpTerminalState, PrpVerificationReasonCode, PrpWireConnection, + ProviderTurnWaitOptions, ReplayControlPlaneEventsInput, RunnerExecutionDriver, RunnerLaunchPreparer,