import { envFlagsMockFns, resetEnvFlagsMock } from '@sim/testing'

import { apiKeyByokMock, apiKeyByokMockFns } from '@sim/testing/mocks/api-key-byok.mock'

import { toolsMock, toolsMockFns } from '@sim/testing/mocks/tools.mock'

import {

workspaceFileSecretProvenanceMock,

workspaceFileSecretProvenanceMockFns,

} from '@sim/testing/mocks/workspace-file-secret-provenance.mock'

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'

const { mockAttachLargeFileRemoteUrls, mockExecuteRequest, mockUploadLargeFilesToProvider } =

vi.hoisted(() => ({

mockAttachLargeFileRemoteUrls: vi.fn(),

mockExecuteRequest: vi.fn(),

mockUploadLargeFilesToProvider: vi.fn(),

}))

vi.mock('@/lib/api-key/byok', () => apiKeyByokMock)

vi.mock('@/providers/registry', () => ({

getProviderExecutor: vi.fn().mockResolvedValue({

executeRequest: (...args: unknown[]) => mockExecuteRequest(...args),

}),

vi.mock('@/providers/file-attachments.server', () => ({

attachLargeFileRemoteUrls: (...args: unknown[]) => mockAttachLargeFileRemoteUrls(...args),

canUseProviderLargeFilePath: () => true,

uploadLargeFilesToProvider: (...args: unknown[]) => mockUploadLargeFilesToProvider(...args),

'@/lib/uploads/contexts/workspace/file-secret-provenance',

() => workspaceFileSecretProvenanceMock

vi.mock('@/tools', () => toolsMock)

import type { AgentTurnState } from '@/lib/memory/conversation-types'

import { AgentTurnStateMachine } from '@/lib/memory/turn-state'

import type { ExecutionContext, NormalizedBlockOutput, StreamingExecution } from '@/executor/types'

import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'

import { executeProviderRequest } from '@/providers'

import * as conversationGeneration from '@/providers/conversation-generation'

import { captureProviderConversationStep } from '@/providers/conversation-history'

import {

isConversationHistoryNotice,

markConversationHistoryNotice,

} from '@/providers/conversation-metadata'

import { executeProviderTool } from '@/providers/runtime-context'

import type { AgentStreamEvent } from '@/providers/stream-events'

import type { ProviderRequest, ProviderResponse, ProviderToolConfig } from '@/providers/types'

import { prepareToolExecution } from '@/providers/utils'

const mockGetApiKeyWithBYOK = apiKeyByokMockFns.mockGetApiKeyWithBYOK

const mockExecuteTool = toolsMockFns.mockExecuteTool

mockExecuteTool.mockImplementation(async () => ({ success: true, output: {} }))

const mockFilterModelSafeWorkspaceFileAttachments =

workspaceFileSecretProvenanceMockFns.mockFilterModelSafeWorkspaceFileAttachments

mockFilterModelSafeWorkspaceFileAttachments.mockImplementation(async (attachments) => attachments)

const HOSTED_RATE_INPUT_COST = 0.340285

const HOSTED_RATE_OUTPUT_COST = 0.0387

const HOSTED_RATE_TOTAL_COST = HOSTED_RATE_INPUT_COST + HOSTED_RATE_OUTPUT_COST

const ARBITRARY_SCHEMA_CONTROL_KEYS = [

'$schema',

'format',

'contentEncoding',

'contentMediaType',

'type',

] as const

function makeAnthropicResponse(): ProviderResponse {

function makeProviderTool(id: string, credential: string): ProviderToolConfig {

describe('executeProviderRequest — durable Agent continuation', () => {

const tool = makeProviderTool('http_request', 'credential-1')

const initialRequest: ProviderRequest = {

model: 'gpt-4o',

messages: [{ role: 'user', content: 'Finish the work.' }],

tools: [tool],

workflowId: 'workflow-1',

executionId: 'execution-1',

blockId: 'agent-1',

}

const toolMessage = (ids: string[]) => ({

})

const response = (): ProviderResponse => ({

})

beforeEach(() => {

mockExecuteRequest.mockReset().mockImplementation(async () => response())

mockExecuteTool.mockReset().mockResolvedValue({ success: true, output: { value: 'saved' } })

})

async function executeCall(request: ProviderRequest, id: string) {

}

it.each([undefined, { role: 'user', content: 'Actual current input' }])(

'does not bind a runtime history notice instead of current input %j',

async (currentInput) => {

const notice = { role: 'user', content: 'Some retained history was omitted.' }

markConversationHistoryNotice(notice)

const bindPrompt = vi.spyOn(conversationGeneration, 'bindConversationGenerationPrompt')

try {

await executeProviderRequest(

'openai',

{ ...initialRequest, messages: [...(currentInput ? [currentInput] : []), notice] },

{ agentConversation: new AgentTurnStateMachine({ save: vi.fn() }) }

)

expect(bindPrompt).toHaveBeenCalledWith(expect.anything(), currentInput)

const request = mockExecuteRequest.mock.calls[0][0] as ProviderRequest

expect(isConversationHistoryNotice(request.messages!.at(-1)!)).toBe(true)

expect(Object.keys(request.messages!.at(-1)!)).toEqual(['role', 'content'])

} finally {

bindPrompt.mockRestore()

}

}

)

it('carries completed work and usage to fallback without dispatching the tool again', async () => {

const session = new AgentTurnStateMachine({ save: vi.fn() })

mockExecuteRequest.mockImplementationOnce(async (request: ProviderRequest) => {

await captureProviderConversationStep(request, 'chat-completions', toolMessage(['call-1']), {

input: 7,

output: 3,

})

await executeCall(request, 'call-1')

throw new Error('Primary failed after the completed tool')

})

await expect(

executeProviderRequest('openai', initialRequest, { agentConversation: session })

).rejects.toThrow('Primary failed')

const result = (await executeProviderRequest(

'groq',

{ ...initialRequest, model: 'llama-3.3-70b-versatile' },

{ agentConversation: session }

)) as ProviderResponse

expect(mockExecuteTool).toHaveBeenCalledTimes(1)

const fallback = mockExecuteRequest.mock.calls[1][0] as ProviderRequest

expect(fallback.messages).toEqual([

...initialRequest.messages!,

expect.objectContaining({

role: 'assistant',

tool_calls: toolMessage(['call-1']).tool_calls,

}),

{ role: 'tool', name: 'http_request', tool_call_id: 'call-1', content: '{"value":"saved"}' },

])

expect(session.getPendingCalls()).toEqual([])

expect(result.tokens).toMatchObject({ input: 9, output: 4, total: 13 })

})

it('restores a partial parallel batch and only retries the call without a recorded result', async () => {

let checkpoint: AgentTurnState | undefined

const session = new AgentTurnStateMachine({

save: async (state) => {

checkpoint = state

},

})

mockExecuteRequest.mockImplementationOnce(async (request: ProviderRequest) => {

await captureProviderConversationStep(

request,

'chat-completions',

toolMessage(['done', 'pending'])

)

await executeCall(request, 'done')

throw new Error('Process stopped before the other result was recorded')

})

await expect(

executeProviderRequest('openai', initialRequest, { agentConversation: session })

).rejects.toThrow('Process stopped')

const pendingIdentity = session.getPendingCalls()[0].invocationId

const restored = new AgentTurnStateMachine({ save: vi.fn() }, checkpoint)

await executeProviderRequest('openai', initialRequest, { agentConversation: restored })

expect(mockExecuteTool).toHaveBeenCalledTimes(2)

expect(mockExecuteTool.mock.calls.map((call) => (call[1] as { key: string }).key)).toEqual([

'done',

'pending',

])

expect(mockExecuteTool.mock.calls[1][1]).toMatchObject({

_context: { invocationId: pendingIdentity },

})

expect(restored.getPendingCalls()).toEqual([])

const resumedRequest = mockExecuteRequest.mock.calls[1][0] as ProviderRequest

expect(resumedRequest.messages?.filter((message) => message.role === 'tool')).toHaveLength(2)

await executeProviderRequest('openai', initialRequest, { agentConversation: restored })

expect(mockExecuteTool).toHaveBeenCalledTimes(2)

})

it('preserves the ordinary provider path without an Agent memory session', async () => {

mockExecuteRequest.mockImplementationOnce(async (request: ProviderRequest) => {

await captureProviderConversationStep(request, 'chat-completions', toolMessage(['call-1']))

expect(request.resolveToolInvocationId).toBeUndefined()

await executeCall(request, 'call-1')

return response()

})

await executeProviderRequest('openai', initialRequest)

await executeProviderRequest('openai', initialRequest)

expect(mockExecuteTool).toHaveBeenCalledTimes(1)

expect(mockExecuteRequest.mock.calls[1][0].messages).toEqual(initialRequest.messages)

})

it('returns a completed checkpoint after current authorization without another model call', async () => {

const state: AgentTurnState = {

version: 1,

steps: [

{

id: 'final-step',

assistant: { role: 'assistant', content: '{"answer":42}' },

calls: [],

results: [],

usage: { input: 7, output: 3, cacheRead: 2 },

cost: { input: 0.4, output: 0.6, total: 1 },

},

],

final: { content: '{"answer":42}', model: 'claude-opus-4-6' },

}

const restored = new AgentTurnStateMachine({ save: vi.fn() }, state)

mockGetApiKeyWithBYOK.mockResolvedValueOnce({ apiKey: 'new-byok-key', isBYOK: true })

const result = (await executeProviderRequest(

'openai',

{ ...initialRequest, workspaceId: 'workspace-1' },

{ agentConversation: restored }

)) as ProviderResponse

expect(mockGetApiKeyWithBYOK).toHaveBeenCalledTimes(1)

expect(mockAttachLargeFileRemoteUrls).toHaveBeenCalledTimes(1)

expect(mockUploadLargeFilesToProvider).toHaveBeenCalledTimes(1)

expect(mockExecuteRequest).not.toHaveBeenCalled()

expect(mockExecuteTool).not.toHaveBeenCalled()

expect(result).toMatchObject({

content: '{"answer":42}',

model: 'claude-opus-4-6',

tokens: { input: 7, output: 3, cacheRead: 2, total: 12 },

cost: { input: 0.4, output: 0.6, total: 1 },

})

})

it('adds previous usage once when a stream completion callback is repeated', async () => {

const session = new AgentTurnStateMachine(

{ save: vi.fn() },

{

version: 1,

steps: [

{

id: 'previous-step',

assistant: { role: 'assistant', content: 'Partial answer' },

calls: [],

results: [],

usage: { input: 7, output: 3 },

cost: { input: 0.4, output: 0.6, total: 1 },

},

],

}

)

const onFullContent = vi.fn()

const streaming: StreamingExecution = {

stream: new ReadableStream(),

onFullContent,

execution: {

success: true,

logs: [],

metadata: { startTime: '', duration: 0 },

output: {

content: 'Finished.',

tokens: { input: 2, output: 1, total: 3 },

cost: { input: 0, output: 0, total: 0 },

},

},

}

mockExecuteRequest.mockResolvedValueOnce(streaming)

const result = (await executeProviderRequest(

'openai',

{ ...initialRequest, stream: true },

{ agentConversation: session }

)) as StreamingExecution

await Promise.all([result.onFullContent?.('Finished.'), result.onFullContent?.('Finished.')])

expect(result.execution.output.tokens).toMatchObject({ input: 9, output: 4, total: 13 })

expect(result.execution.output.cost).toMatchObject({ input: 0.4, output: 0.6, total: 1 })

expect(onFullContent).toHaveBeenCalledTimes(2)

})

it('retains prior billed usage when the finishing provider has no usage or cost', async () => {

const session = new AgentTurnStateMachine(

{ save: vi.fn() },

{

version: 1,

steps: [

{

id: 'previous-step',

assistant: { role: 'assistant', content: 'Partial answer' },

calls: [],

results: [],

usage: { input: 7, output: 3 },

cost: { input: 0.4, output: 0.6, total: 1 },

},

],

}

)

mockExecuteRequest.mockResolvedValueOnce({ content: 'Finished.', model: 'gpt-4o' })

const result = (await executeProviderRequest('openai', initialRequest, {

agentConversation: session,

})) as ProviderResponse

expect(result.tokens).toMatchObject({ input: 7, output: 3, total: 10 })

expect(result.cost).toMatchObject({ input: 0.4, output: 0.6, total: 1 })

})

it.each(['empty', 'cancelled', 'failed'])(

'retains prior usage when a %s stream never calls onFullContent',

async (exit) => {

const session = new AgentTurnStateMachine(

{ save: vi.fn() },

{

version: 1,

steps: [

{

id: 'previous-step',

assistant: { role: 'assistant', content: 'Partial answer' },

calls: [],

results: [],

usage: { input: 7, output: 3 },

cost: { input: 0.4, output: 0.6, total: 1 },

},

],

}

)

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'test-byok', isBYOK: true })

const output: NormalizedBlockOutput = { content: '' }

const writeUsage = () => {

output.tokens = { input: 2, output: 1, cacheRead: 4, total: 7 }

output.cost = { input: 2, output: 3, toolCost: 0.25, total: 5.25 }

}

const onFullContent = vi.fn()

const streaming: StreamingExecution = {

stream: new ReadableStream(

{

pull(controller) {

},

cancel: writeUsage,

},

{ highWaterMark: 0 }

),

onFullContent,

execution: {

success: true,

logs: [],

metadata: { startTime: '', duration: 0 },

output,

},

}

mockExecuteRequest.mockResolvedValueOnce(streaming)

const result = (await executeProviderRequest(

'openai',

{ ...initialRequest, workspaceId: 'workspace-1', stream: true },

{ agentConversation: session }

)) as StreamingExecution

expect(output.tokens).toMatchObject({ input: 7, output: 3, total: 10 })

expect(output.cost).toMatchObject({ input: 0.4, output: 0.6, total: 1 })

if (exit === 'cancelled') await result.stream.cancel()

else if (exit === 'failed')

await expect(result.stream.getReader().read()).rejects.toThrow('stream interrupted')

else await expect(result.stream.getReader().read()).resolves.toMatchObject({ done: true })

expect(output.tokens).toMatchObject({ input: 9, output: 4, cacheRead: 4, total: 17 })

expect(output.cost).toMatchObject({ input: 0.4, output: 0.6, toolCost: 0.25, total: 1.25 })

expect({ ...output }.cost).toMatchObject({ total: 1.25 })

expect(output.cost).toMatchObject({ total: 1.25 })

expect(onFullContent).not.toHaveBeenCalled()

}

)

it('does not replay pending tools after cancellation', async () => {

const session = new AgentTurnStateMachine({ save: vi.fn() })

mockExecuteRequest.mockImplementationOnce(async (request: ProviderRequest) => {

await captureProviderConversationStep(request, 'chat-completions', toolMessage(['pending']))

throw new Error('Process stopped')

})

await expect(

executeProviderRequest('openai', initialRequest, { agentConversation: session })

).rejects.toThrow('Process stopped')

const abort = new AbortController()

abort.abort()

await expect(

executeProviderRequest(

'openai',

{ ...initialRequest, abortSignal: abort.signal },

{

agentConversation: session,

}

)

).rejects.toMatchObject({ name: 'AbortError' })

expect(mockExecuteTool).not.toHaveBeenCalled()

expect(mockExecuteRequest).toHaveBeenCalledTimes(1)

})

it('propagates a nonretryable tool failure without another execution', async () => {

const session = new AgentTurnStateMachine({ save: vi.fn() })

const failure = Object.assign(new Error('Policy denied this operation'), { retryable: false })

mockExecuteTool.mockRejectedValueOnce(failure)

mockExecuteRequest.mockImplementationOnce(async (request: ProviderRequest) => {

await captureProviderConversationStep(request, 'chat-completions', toolMessage(['call-1']))

await executeCall(request, 'call-1')

return response()

})

await expect(

executeProviderRequest('openai', initialRequest, { agentConversation: session })

).rejects.toBe(failure)

expect(mockExecuteTool).toHaveBeenCalledTimes(1)

expect(mockExecuteRequest).toHaveBeenCalledTimes(1)

})

describe('executeProviderRequest — tool identities', () => {

it('passes trusted execution context to both attachment authorization stages without serializing it', async () => {

const executionContext = {

workflowId: 'workflow-1',

workspaceId: 'workspace-1',

executionId: 'execution-1',

} as ExecutionContext

mockExecuteRequest.mockResolvedValueOnce({ content: 'ready', model: 'test-model' })

await executeProviderRequest('anthropic', { model: 'test-model' }, { executionContext })

expect(mockAttachLargeFileRemoteUrls).toHaveBeenCalledWith(

expect.objectContaining({ model: 'test-model' }),

'anthropic',

executionContext

)

expect(mockUploadLargeFilesToProvider).toHaveBeenCalledWith(

expect.objectContaining({ model: 'test-model' }),

'anthropic',

executionContext

)

expect(mockExecuteRequest.mock.calls[0][0]).not.toHaveProperty('executionContext')

expect(mockExecuteRequest.mock.calls[0][0]).not.toHaveProperty('principal')

})

it('sends unique opaque ids and projects provider aliases out of the response', async () => {

const tools = [

makeProviderTool('gmail_send', 'credential-a'),

makeProviderTool('gmail_send', 'credential-b'),

]

mockExecuteRequest.mockImplementationOnce(async (request) => {

const alias = request.tools[1].id

expect(request.tools.map((tool: ProviderToolConfig) => tool.id)).toEqual([

'gmail_send',

'gmail_send__sim_2',

])

expect(alias).not.toContain('credential-b')

return {

content: 'sent',

model: 'test-model',

toolCalls: [{ name: alias, arguments: {} }],

timing: {

startTime: 'start',

endTime: 'end',

duration: 1,

timeSegments: [{ type: 'tool', name: alias, startTime: 0, endTime: 1, duration: 1 }],

},

}

})

const response = (await executeProviderRequest('anthropic', {

model: 'test-model',

tools,

})) as ProviderResponse

expect(response.toolCalls?.[0].name).toBe('gmail_send')

expect(response.timing?.timeSegments?.[0].name).toBe('gmail_send')

expect(tools[1].params.oauthCredential).toBe('credential-b')

})

it('keeps the alias map active while a streaming provider executes the selected instance', async () => {

const tools = [

makeProviderTool('gmail_send', 'credential-a'),

makeProviderTool('gmail_send', 'credential-b'),

]

mockExecuteRequest.mockImplementationOnce(async (request) => {

const selected = request.tools[1] as ProviderToolConfig

const output: NormalizedBlockOutput = {

toolCalls: { list: [], count: 0 },

providerTiming: { startTime: 'start', endTime: 'end', duration: 0, timeSegments: [] },

}

return {

streamFormat: 'agent-events-v1',

stream: new ReadableStream<AgentStreamEvent>({

async pull(controller) {

},

}),

execution: { success: true, output },

}

})

const response = await executeProviderRequest('anthropic', {

model: 'test-model',

tools,

})

expect(response).not.toBeInstanceOf(ReadableStream)

expect(response).toHaveProperty('stream')

const streaming = response as StreamingExecution

const reader = (streaming.stream as ReadableStream<AgentStreamEvent>).getReader()

const event = await reader.read()

await reader.read()

expect(mockExecuteTool).toHaveBeenCalledWith(

'gmail_send',

{ oauthCredential: 'credential-b' },

expect.any(Object)

)

expect(event.value).toEqual({ type: 'tool_call_start', id: 'call-1', name: 'gmail_send' })

expect(streaming.execution.output.toolCalls?.list[0].name).toBe('gmail_send')

})

describe('executeProviderRequest — BYOK regression', () => {

it('zeroes block-level model cost for BYOK callers (existing behavior)', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-byok', isBYOK: true })

mockExecuteRequest.mockResolvedValue(makeAnthropicResponse())

const result = (await executeProviderRequest('anthropic', {

model: 'claude-opus-4-6',

workspaceId: 'ws-1',

})) as ProviderResponse

expect(result.cost?.total).toBe(0)

expect(result.cost?.input).toBe(0)

expect(result.cost?.output).toBe(0)

})

it('zeroes per-segment model cost for BYOK callers so trace aggregation does not re-charge', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-byok', isBYOK: true })

mockExecuteRequest.mockResolvedValue(makeAnthropicResponse())

const result = (await executeProviderRequest('anthropic', {

model: 'claude-opus-4-6',

workspaceId: 'ws-1',

})) as ProviderResponse

const segment = result.timing?.timeSegments?.[0]

expect(segment?.cost).toBeDefined()

expect(segment?.cost?.input).toBe(0)

expect(segment?.cost?.output).toBe(0)

expect(segment?.cost?.total).toBe(0)

// Tokens must be preserved so the UI still displays usage even when

// BYOK callers are not billed.

expect(segment?.tokens?.input).toBe(68057)

expect(segment?.tokens?.output).toBe(1548)

})

it('does not zero per-segment cost for non-BYOK hosted callers', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-rotating', isBYOK: false })

mockExecuteRequest.mockResolvedValue(makeAnthropicResponse())

const result = (await executeProviderRequest('anthropic', {

model: 'claude-opus-4-6',

workspaceId: 'ws-1',

})) as ProviderResponse

const segment = result.timing?.timeSegments?.[0]

expect(segment?.cost?.total).toBeCloseTo(HOSTED_RATE_TOTAL_COST, 6)

})

/**

it('counts a provider-folded tool cost exactly once', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-rotating', isBYOK: false })

mockExecuteRequest.mockResolvedValue({

content: 'hi',

model: 'claude-opus-4-6',

tokens: { input: 100, output: 50, total: 150 },

cost: {

input: 0.0005,

output: 0.00125,

total: 0.00675,

toolCost: 0.005,

pricing: { input: 5.0, output: 25.0, updatedAt: '2026-04-01' },

},

toolResults: [{ cost: { total: 0.005 } }],

} as ProviderResponse)

const result = (await executeProviderRequest('anthropic', {

model: 'claude-opus-4-6',

workspaceId: 'ws-1',

})) as ProviderResponse

expect(result.cost?.toolCost).toBeCloseTo(0.005, 8)

expect(result.cost?.total).toBeCloseTo(0.00675, 8)

})

it('adds failed Function cost once alongside successful tool results', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-byok', isBYOK: true })

mockExecuteTool.mockResolvedValueOnce({

success: false,

output: { cost: { total: 0.004 } },

error: 'execution failed',

})

mockExecuteRequest.mockImplementationOnce(async () => {

const execution = await executeProviderTool('function_execute', {})

expect(execution.rawResponse.success).toBe(false)

return {

...makeAnthropicResponse(),

toolResults: [{ cost: { total: 0.005 } }],

} as ProviderResponse

})

const result = (await executeProviderRequest('anthropic', {

model: 'claude-opus-4-6',

workspaceId: 'ws-1',

tools: [makeProviderTool('function_execute', 'credential')],

})) as ProviderResponse

expect(result.cost).toMatchObject({ input: 0, output: 0 })

expect(result.cost?.toolCost).toBeCloseTo(0.009, 8)

expect(result.cost?.total).toBeCloseTo(0.009, 8)

})

/**

it('does not leak tool cost into a segment sharing the provider cost object', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-rotating', isBYOK: false })

envFlagsMockFns.getCostMultiplier.mockReturnValue(1)

const sharedCost = {

input: 0.0005,

output: 0.00125,

total: 0.00175,

pricing: { input: 5.0, output: 25.0, updatedAt: '2026-04-01' },

}

mockExecuteRequest.mockResolvedValue({

content: 'hi',

model: 'claude-opus-4-6',

tokens: { input: 100, output: 50, total: 150 },

cost: sharedCost,

toolResults: [{ cost: { total: 0.004 } }],

timing: {

startTime: '2026-04-30T21:27:37.878Z',

endTime: '2026-04-30T21:27:38.000Z',

duration: 122,

timeSegments: [

{

type: 'model',

name: 'claude-opus-4-6',

startTime: 1777584457878,

endTime: 1777584457940,

duration: 62,

cost: sharedCost,

},

],

},

} as ProviderResponse)

const result = (await executeProviderRequest('anthropic', {

model: 'claude-opus-4-6',

workspaceId: 'ws-1',

})) as ProviderResponse

expect(result.cost?.total).toBeCloseTo(0.00575, 8)

expect(result.timing?.timeSegments?.[0]?.cost?.total).toBeCloseTo(0.00175, 8)

})

it('keeps the provider cost rather than recomputing it from tokens', async () => {

mockGetApiKeyWithBYOK.mockResolvedValue({ apiKey: 'sk-rotating', isBYOK: false })

// Cache-tier pricing this layer cannot rebuild from `tokens` alone.

mockExecuteRequest.mockResolvedValue({

content: 'hi',