@pikku/core 0.12.83 → 0.12.86

package/src/wirings/{ai-agent/ai-agent-runner.test.ts → agent/agent-runner.test.ts}

@@ -2,13 +2,13 @@ import { beforeEach, describe, test } from 'node:test'
 import assert from 'node:assert/strict'
 
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-import { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js'
+import { runAgent, resumeAgentSync } from './agent-runner.js'
 import type {
   AgentRunState,
-  CoreAIAgent,
-  PikkuAIMiddlewareHooks,
-} from './ai-agent.types.js'
-import type { AIAgentStepResult } from '../../services/ai-agent-runner-service.js'
+  CoreAgent,
+  PikkuAgentMiddlewareHooks,
+} from './agent.types.js'
+import type { AgentStepResult } from '../../services/agent-runner-service.js'
 import {
   AIProviderNotConfiguredError,
   ForbiddenError,
@@ -19,7 +19,7 @@ beforeEach(() => {
 })
 
 const addTestAgent = (agentName: string) => {
-  const agent: CoreAIAgent = {
+  const agent: CoreAgent = {
     name: agentName,
     description: 'test agent',
     instructions: 'be helpful',
@@ -36,8 +36,8 @@ const addTestAgent = (agentName: string) => {
 }
 
 const makeStepResult = (
-  overrides?: Partial<AIAgentStepResult>
-): AIAgentStepResult => ({
+  overrides?: Partial<AgentStepResult>
+): AgentStepResult => ({
   text: '',
   toolCalls: [],
   toolResults: [],
@@ -50,8 +50,8 @@ const asOwner = (resourceId: string) => ({
   sessionService: { get: () => ({ userId: resourceId }) } as never,
 })
 
-describe('runAIAgent', () => {
-  test('throws when aiRunState service is missing', async () => {
+describe('runAgent', () => {
+  test('throws when agentRunState service is missing', async () => {
     addTestAgent('missing-run-state-agent')
 
     pikkuState(null, 'package', 'singletonServices', {
@@ -61,25 +61,25 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
+      agentRunner: {
         run: async () => makeStepResult({ text: 'unused' }),
       },
     } as any)
 
     await assert.rejects(
       () =>
-        runAIAgent(
+        runAgent(
           'missing-run-state-agent',
           { message: 'hello', threadId: 't', resourceId: 'r' },
           {}
         ),
       {
-        message: 'AIRunStateService not available in singletonServices',
+        message: 'AgentRunStateService not available in singletonServices',
       }
     )
   })
 
-  test('throws AIProviderNotConfiguredError when aiAgentRunner is missing', async () => {
+  test('throws AIProviderNotConfiguredError when agentRunner is missing', async () => {
     addTestAgent('no-provider-agent')
 
     const mockServices = {
@@ -89,7 +89,7 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-no-provider',
         updateRun: async () => {},
       },
@@ -99,7 +99,7 @@ describe('runAIAgent', () => {
 
     await assert.rejects(
       () =>
-        runAIAgent(
+        runAgent(
           'no-provider-agent',
           { message: 'hello', threadId: 't', resourceId: 'r' },
           {}
@@ -125,12 +125,12 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
+      agentRunner: {
         run: async () => {
           throw expectedError
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-1',
         updateRun: async (_runId: string, patch: unknown) => {
           updates.push(patch)
@@ -142,7 +142,7 @@ describe('runAIAgent', () => {
 
     await assert.rejects(
       () =>
-        runAIAgent(
+        runAgent(
           'failing-agent',
           {
             message: 'hello',
@@ -170,8 +170,8 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> => {
           callCount++
           if (callCount === 1) {
             return makeStepResult({
@@ -197,7 +197,7 @@ describe('runAIAgent', () => {
           })
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-multi',
         updateRun: async () => {},
       },
@@ -205,7 +205,7 @@ describe('runAIAgent', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'multi-step-agent',
       {
         message: 'hello',
@@ -226,13 +226,13 @@ describe('runAIAgent', () => {
     addTestAgent('afterstep-agent')
 
     const afterStepCalls: unknown[] = []
-    const middleware: PikkuAIMiddlewareHooks = {
+    const middleware: PikkuAgentMiddlewareHooks = {
       afterStep: async (_services, ctx) => {
         afterStepCalls.push(ctx)
       },
     }
     const agent = pikkuState(null, 'agent', 'agents').get('afterstep-agent')!
-    agent.aiMiddleware = [middleware] as any
+    agent.agentMiddleware = [middleware] as any
     pikkuState(null, 'agent', 'agents').set('afterstep-agent', agent)
 
     let callCount = 0
@@ -243,8 +243,8 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> => {
           callCount++
           if (callCount === 1) {
             return makeStepResult({
@@ -266,7 +266,7 @@ describe('runAIAgent', () => {
           })
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-afterstep',
         updateRun: async () => {},
       },
@@ -274,7 +274,7 @@ describe('runAIAgent', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    await runAIAgent(
+    await runAgent(
       'afterstep-agent',
       { message: 'hi', threadId: 't1', resourceId: 'r1' },
       {}
@@ -295,13 +295,13 @@ describe('runAIAgent', () => {
     addTestAgent('onerror-agent')
 
     const onErrorCalls: unknown[] = []
-    const middleware: PikkuAIMiddlewareHooks = {
+    const middleware: PikkuAgentMiddlewareHooks = {
       onError: async (_services, ctx) => {
         onErrorCalls.push(ctx)
       },
     }
     const agent = pikkuState(null, 'agent', 'agents').get('onerror-agent')!
-    agent.aiMiddleware = [middleware] as any
+    agent.agentMiddleware = [middleware] as any
     pikkuState(null, 'agent', 'agents').set('onerror-agent', agent)
 
     const expectedError = new Error('boom')
@@ -312,12 +312,12 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
+      agentRunner: {
         run: async () => {
           throw expectedError
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-err',
         updateRun: async () => {},
       },
@@ -327,7 +327,7 @@ describe('runAIAgent', () => {
 
     await assert.rejects(
       () =>
-        runAIAgent(
+        runAgent(
           'onerror-agent',
           { message: 'hi', threadId: 't2', resourceId: 'r2' },
           {}
@@ -344,7 +344,7 @@ describe('runAIAgent', () => {
   test('onError hook failure does not suppress original error', async () => {
     addTestAgent('onerror-throws-agent')
 
-    const middleware: PikkuAIMiddlewareHooks = {
+    const middleware: PikkuAgentMiddlewareHooks = {
       onError: async () => {
         throw new Error('hook error')
       },
@@ -352,7 +352,7 @@ describe('runAIAgent', () => {
     const agent = pikkuState(null, 'agent', 'agents').get(
       'onerror-throws-agent'
     )!
-    agent.aiMiddleware = [middleware] as any
+    agent.agentMiddleware = [middleware] as any
     pikkuState(null, 'agent', 'agents').set('onerror-throws-agent', agent)
 
     const expectedError = new Error('original error')
@@ -363,12 +363,12 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
+      agentRunner: {
         run: async () => {
           throw expectedError
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-safe',
         updateRun: async () => {},
       },
@@ -378,7 +378,7 @@ describe('runAIAgent', () => {
 
     await assert.rejects(
       () =>
-        runAIAgent(
+        runAgent(
           'onerror-throws-agent',
           { message: 'hi', threadId: 't3', resourceId: 'r3' },
           {}
@@ -401,12 +401,12 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
+      agentRunner: {
         run: async () => {
           throw new Error('should not run')
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async (run: any) => {
           createdRuns.push(run)
           return 'run-missing-rpc'
@@ -417,7 +417,7 @@ describe('runAIAgent', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'missing-rpc-agent',
       { message: 'deploy', threadId: 'thread-1', resourceId: 'resource-1' },
       asOwner('resource-1')
@@ -449,7 +449,7 @@ describe('runAIAgent', () => {
     const inputMessages = [
       { id: 'extra', role: 'system', content: 'extra', createdAt: new Date() },
     ] as any
-    const middleware: PikkuAIMiddlewareHooks = {
+    const middleware: PikkuAgentMiddlewareHooks = {
       modifyInput: async (_services, ctx) => ({
         instructions: `${ctx.instructions}\n\nextra rules`,
         messages: [...ctx.messages, ...inputMessages],
@@ -460,7 +460,7 @@ describe('runAIAgent', () => {
       }),
     }
     const agent = pikkuState(null, 'agent', 'agents').get('middleware-agent')!
-    agent.aiMiddleware = [middleware] as any
+    agent.agentMiddleware = [middleware] as any
     pikkuState(null, 'agent', 'agents').set('middleware-agent', agent)
 
     const mockServices = {
@@ -470,8 +470,8 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (params: any): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (params: any): Promise<AgentStepResult> => {
           seenRunnerParams.push({
             instructions: params.instructions,
             messages: params.messages,
@@ -483,7 +483,7 @@ describe('runAIAgent', () => {
           } as any)
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-middleware',
         updateRun: async () => {},
       },
@@ -491,7 +491,7 @@ describe('runAIAgent', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'middleware-agent',
       { message: 'hello', threadId: 'thread-mw', resourceId: 'resource-mw' },
       {}
@@ -522,13 +522,13 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> => {
           runnerCalls++
           return makeStepResult({ text: 'should not happen' })
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-stop',
         updateRun: async (_runId: string, patch: any) => {
           updates.push(patch)
@@ -538,7 +538,7 @@ describe('runAIAgent', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'prepare-stop-agent',
       {
         message: 'hello',
@@ -588,8 +588,8 @@ describe('runAIAgent', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> =>
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> =>
           makeStepResult({
             text: 'Need approval',
             toolCalls: [
@@ -603,13 +603,13 @@ describe('runAIAgent', () => {
             finishReason: 'tool-calls',
           }),
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-approval',
         updateRun: async (_runId: string, patch: any) => {
           updates.push(patch)
         },
       },
-      aiStorage: {
+      agentStorage: {
         createThread: async () => {},
         getMessages: async () => [],
         saveMessages: async (_threadId: string, messages: any[]) => {
@@ -620,7 +620,7 @@ describe('runAIAgent', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'approval-agent',
       { message: 'deploy', threadId: 'thread-a', resourceId: 'resource-a' },
       {}
@@ -659,25 +659,25 @@ describe('runAIAgent', () => {
   })
 })
 
-describe('resumeAIAgentSync', () => {
+describe('resumeAgentSync', () => {
   test('throws for missing services, missing runs, wrong status, and missing runner', async () => {
     pikkuState(null, 'package', 'singletonServices', {} as any)
-    await assert.rejects(() => resumeAIAgentSync('run-x', [], {}), {
-      message: 'AIRunStateService not available in singletonServices',
+    await assert.rejects(() => resumeAgentSync('run-x', [], {}), {
+      message: 'AgentRunStateService not available in singletonServices',
     })
 
     pikkuState(null, 'package', 'singletonServices', {
-      aiRunState: {
+      agentRunState: {
         getRun: async () => null,
       },
     } as any)
-    await assert.rejects(() => resumeAIAgentSync('run-x', [], {}), {
+    await assert.rejects(() => resumeAgentSync('run-x', [], {}), {
       message: 'No run found for runId run-x',
     })
 
     addTestAgent('resume-guard-agent')
     pikkuState(null, 'package', 'singletonServices', {
-      aiRunState: {
+      agentRunState: {
         getRun: async () => ({
           runId: 'run-y',
           agentName: 'resume-guard-agent',
@@ -690,12 +690,12 @@ describe('resumeAIAgentSync', () => {
         }),
       },
     } as any)
-    await assert.rejects(() => resumeAIAgentSync('run-y', [], asOwner('r')), {
+    await assert.rejects(() => resumeAgentSync('run-y', [], asOwner('r')), {
       message: 'Run run-y is not suspended (status: completed)',
     })
 
     pikkuState(null, 'package', 'singletonServices', {
-      aiRunState: {
+      agentRunState: {
         getRun: async () => ({
           runId: 'run-z',
           agentName: 'resume-guard-agent',
@@ -712,7 +712,7 @@ describe('resumeAIAgentSync', () => {
       },
     } as any)
     await assert.rejects(
-      () => resumeAIAgentSync('run-z', [], asOwner('r')),
+      () => resumeAgentSync('run-z', [], asOwner('r')),
       (error: unknown) => error instanceof AIProviderNotConfiguredError
     )
   })
@@ -769,14 +769,14 @@ describe('resumeAIAgentSync', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> =>
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> =>
           makeStepResult({
             text: 'Resumed answer',
             usage: { inputTokens: 5, outputTokens: 3 },
           }),
       },
-      aiRunState: {
+      agentRunState: {
         getRun: async () => run,
         createRun: async () => 'unused',
         updateRun: async (_runId: string, patch: any) => {
@@ -787,7 +787,7 @@ describe('resumeAIAgentSync', () => {
           return true
         },
       },
-      aiStorage: {
+      agentStorage: {
         saveMessages: async (threadId: string, messages: any[]) => {
           savedMessages.push({ threadId, messages })
         },
@@ -797,7 +797,7 @@ describe('resumeAIAgentSync', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await resumeAIAgentSync(
+    const result = await resumeAgentSync(
       'run-resume',
       [{ toolCallId: 'tc-1', approved: true }],
       asOwner('resource-resume')
@@ -864,32 +864,31 @@ describe('resumeAIAgentSync', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> =>
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> =>
           makeStepResult({
             text: 'Refunded',
             usage: { inputTokens: 1, outputTokens: 1 },
           }),
       },
-      aiRunState: {
+      agentRunState: {
         getRun: async () => run,
         createRun: async () => 'unused',
         updateRun: async () => {},
         resolveApproval: async () => claimsLeft-- > 0,
       },
-      aiStorage: {
+      agentStorage: {
         saveMessages: async () => {},
         getMessages: async () => [],
       },
     } as any)
 
     const approvals = [{ toolCallId: 'tc-claim', approved: true }]
-    await resumeAIAgentSync('run-claim', approvals, asOwner('resource-claim'))
+    await resumeAgentSync('run-claim', approvals, asOwner('resource-claim'))
     assert.equal(executions, 1, 'the winner ran the tool once')
 
     await assert.rejects(
-      () =>
-        resumeAIAgentSync('run-claim', approvals, asOwner('resource-claim')),
+      () => resumeAgentSync('run-claim', approvals, asOwner('resource-claim')),
       /already resolved by another caller/
     )
     assert.equal(executions, 1, 'the loser did not run it a second time')
@@ -927,14 +926,14 @@ describe('resumeAIAgentSync', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> =>
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> =>
           makeStepResult({
             text: 'Declined',
             usage: { inputTokens: 1, outputTokens: 1 },
           }),
       },
-      aiRunState: {
+      agentRunState: {
         getRun: async () => baseRun,
         createRun: async () => 'unused',
         updateRun: async () => {},
@@ -943,7 +942,7 @@ describe('resumeAIAgentSync', () => {
           return true
         },
       },
-      aiStorage: {
+      agentStorage: {
         saveMessages: async (_threadId: string, messages: any[]) => {
           savedMessages.push(messages)
         },
@@ -953,7 +952,7 @@ describe('resumeAIAgentSync', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const denied = await resumeAIAgentSync(
+    const denied = await resumeAgentSync(
       'run-deny',
       [{ toolCallId: 'tc-2', approved: false }],
       asOwner('resource-deny')
@@ -968,7 +967,7 @@ describe('resumeAIAgentSync', () => {
 
     await assert.rejects(
       () =>
-        resumeAIAgentSync(
+        resumeAgentSync(
           'run-deny',
           [{ toolCallId: 'tc-2', approved: false }],
           asOwner('resource-deny'),
@@ -1030,19 +1029,19 @@ describe('resumeAIAgentSync', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> =>
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> =>
           makeStepResult({
             text: 'Recovered',
             usage: { inputTokens: 1, outputTokens: 1 },
           }),
       },
-      aiRunState: {
+      agentRunState: {
         getRun: async () => run,
         resolveApproval: async () => true,
         updateRun: async () => {},
       },
-      aiStorage: {
+      agentStorage: {
         saveMessages: async (_threadId: string, messages: any[]) => {
           savedMessages.push(messages)
         },
@@ -1050,7 +1049,7 @@ describe('resumeAIAgentSync', () => {
       },
     } as any)
 
-    const result = await resumeAIAgentSync(
+    const result = await resumeAgentSync(
       'run-error',
       [{ toolCallId: 'tc-error', approved: true }],
       asOwner('resource-error')
@@ -1069,7 +1068,7 @@ describe('getCredential API key override', () => {
     const overrideRunCalls: string[] = []
 
     const overrideRunner = {
-      run: async (): Promise<AIAgentStepResult> => {
+      run: async (): Promise<AgentStepResult> => {
         overrideRunCalls.push('override')
         return makeStepResult({ text: 'from-override', finishReason: 'stop' })
       },
@@ -1082,14 +1081,14 @@ describe('getCredential API key override', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> => {
           originalRunCalls.push('original')
           return makeStepResult({ text: 'from-original', finishReason: 'stop' })
         },
         withApiKey: (_key: string) => overrideRunner,
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-key-override',
         updateRun: async () => {},
       },
@@ -1097,7 +1096,7 @@ describe('getCredential API key override', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'api-key-agent',
       { message: 'hi', threadId: 't-key', resourceId: 'r-key' },
       { getCredential: async () => ({ apiKey: 'my-secret-key' }) }
@@ -1120,8 +1119,8 @@ describe('getCredential API key override', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> => {
           originalRunCalls.push('original')
           return makeStepResult({ text: 'from-original', finishReason: 'stop' })
         },
@@ -1133,7 +1132,7 @@ describe('getCredential API key override', () => {
             }),
         }),
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-no-cred',
         updateRun: async () => {},
       },
@@ -1141,7 +1140,7 @@ describe('getCredential API key override', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    const result = await runAIAgent(
+    const result = await runAgent(
       'no-cred-agent',
       { message: 'hi', threadId: 't-no-cred', resourceId: 'r-no-cred' },
       { getCredential: async () => null }
@@ -1163,13 +1162,13 @@ describe('getCredential API key override', () => {
         error: () => {},
         debug: () => {},
       },
-      aiAgentRunner: {
-        run: async (): Promise<AIAgentStepResult> => {
+      agentRunner: {
+        run: async (): Promise<AgentStepResult> => {
           originalRunCalls.push('original')
           return makeStepResult({ text: 'from-original', finishReason: 'stop' })
         },
       },
-      aiRunState: {
+      agentRunState: {
         createRun: async () => 'run-no-withkey',
         updateRun: async () => {},
       },
@@ -1177,7 +1176,7 @@ describe('getCredential API key override', () => {
 
     pikkuState(null, 'package', 'singletonServices', mockServices)
 
-    await runAIAgent(
+    await runAgent(
       'no-withkey-agent',
       { message: 'hi', threadId: 't-no-withkey', resourceId: 'r-no-withkey' },
       { getCredential: async () => ({ apiKey: 'ignored-key' }) }
@@ -1207,11 +1206,11 @@ describe('C2 resume run ownership', () => {
   test('rejects resuming a run owned by another user', async () => {
     addTestAgent('resume-owner-agent')
     pikkuState(null, 'package', 'singletonServices', {
-      aiRunState: { getRun: async () => suspendedRun('user-a') },
+      agentRunState: { getRun: async () => suspendedRun('user-a') },
     } as any)
 
     await assert.rejects(
-      () => resumeAIAgentSync('run-owned', [], withSession('user-b')),
+      () => resumeAgentSync('run-owned', [], withSession('user-b')),
       (e: unknown) => e instanceof ForbiddenError
     )
   })
@@ -1219,11 +1218,11 @@ describe('C2 resume run ownership', () => {
   test('allows the owning user past the ownership gate', async () => {
     addTestAgent('resume-owner-agent')
     pikkuState(null, 'package', 'singletonServices', {
-      aiRunState: { getRun: async () => suspendedRun('user-a') },
+      agentRunState: { getRun: async () => suspendedRun('user-a') },
     } as any)
 
     await assert.rejects(
-      () => resumeAIAgentSync('run-owned', [], withSession('user-a')),
+      () => resumeAgentSync('run-owned', [], withSession('user-a')),
       (e: unknown) => e instanceof AIProviderNotConfiguredError
     )
   })