fix(agent-core-v2): align runtime resolution with IAgentLifecycleService on upstream main

Author: mb

packages/agent-core-v2/src/agent/fullCompaction/fullCompactionService.ts

@@ -26,7 +26,7 @@ import { IAgentStateService } from '#/agent/state/agentState';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { stripDynamicToolContext } from '#/agent/toolSelect/dynamicTools';
 import { IAgentToolSelectService } from '#/agent/toolSelect/toolSelect';
-import { IAgentManager } from '#/session/agentManager/agentManager';
+import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { AgentTodo, type TodoRuntime } from '#/session/todo/todoAgentRuntime';
 import { renderTodoList } from '#/session/todo/todoItem';
 import {
@@ -145,7 +145,7 @@ export class AgentFullCompactionService extends Service implements IAgentFullCom
     @IAgentProfileService private readonly profile: IAgentProfileService,
     @IAgentToolRegistryService private readonly toolRegistry: IAgentToolRegistryService,
     @IAgentToolSelectService private readonly toolSelect: IAgentToolSelectService,
-    @IAgentManager private readonly manager: IAgentManager,
+    @IAgentLifecycleService private readonly manager: IAgentLifecycleService,
     @IAgentScopeContext private readonly agent: IAgentScopeContext,
     @ITelemetryService private readonly telemetry: ITelemetryService,
     @IEventDispatcher private readonly dispatcher: IEventDispatcher,

packages/agent-core-v2/src/agent/tools/todo-list/todoListTool.ts

@@ -2,7 +2,7 @@ import type { ToolExecution } from '#/tool/toolContract';
 import { toInputJsonSchema } from '#/tool/input-schema';
 
 import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
-import { IAgentManager } from '#/session/agentManager/agentManager';
+import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { AgentTodo, type TodoRuntime } from '#/session/todo/todoAgentRuntime';
 import {
   TODO_LIST_TOOL_NAME,
@@ -25,7 +25,7 @@ export class TodoListTool implements ITodoListTool {
   readonly parameters: Record<string, unknown> = toInputJsonSchema(TodoListInputSchema);
 
   constructor(
-    @IAgentManager private readonly manager: IAgentManager,
+    @IAgentLifecycleService private readonly manager: IAgentLifecycleService,
     @IAgentScopeContext private readonly scope: IAgentScopeContext,
   ) {}
 

packages/agent-core-v2/src/agent/userTool/userToolService.ts

@@ -13,7 +13,7 @@ import type {
 } from '#/tool/toolContract';
 import { IAgentToolRegistryService } from '#/agent/toolRegistry/toolRegistry';
 import { IAgentStateService } from '#/agent/state/agentState';
-import { IAgentManager } from '#/session/agentManager/agentManager';
+import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { AgentInteraction } from '#/session/interaction/interactionAgentRuntime';
 import { IAgentScopeContext } from '#/agent/scopeContext/scopeContext';
 import { IEventDispatcher } from '#/state/eventDispatcher';
@@ -41,7 +41,7 @@ export class AgentUserToolService extends Service implements IAgentUserToolServi
     @IAgentScopeContext private readonly scopeContext: IAgentScopeContext,
     @IAgentToolRegistryService private readonly registry: IAgentToolRegistryService,
     @IAgentProfileService private readonly profile: IAgentProfileService,
-    @IAgentManager private readonly manager: IAgentManager,
+    @IAgentLifecycleService private readonly manager: IAgentLifecycleService,
     @IEventDispatcher private readonly dispatcher: IEventDispatcher,
     @IAgentStateService private readonly agentState: IAgentStateService,
   ) {

packages/agent-core-v2/src/session/subagent/mirrorAgentRun.ts

@@ -7,8 +7,9 @@ import { tryAgentContextOf } from '#/agent/scopeContext/scopeContext';
 import { isProviderRateLimitError } from '#/kosong/contract/errors';
 import { type TokenUsage } from '#/kosong/contract/usage';
 import { ITelemetryService } from '#/app/telemetry/telemetry';
+import type { SubagentCreatedEvent } from '#/app/telemetry/events';
 import { Event2 } from '#/app/event/event2';
-import { IAgentManager } from '#/session/agentManager/agentManager';
+import { IAgentLifecycleService } from '#/session/agentLifecycle/agentLifecycle';
 import { IEventDispatcher } from '#/state/eventDispatcher';
 
 import { type AgentRunHandle, ISessionSubagentService } from './subagent';

packages/agent-core-v2/src/session/subagent/subagentService.ts

@@ -29,7 +29,7 @@ import { ILogService } from '#/_base/log/log';
 import { ISessionContext } from '#/session/sessionContext/sessionContext';
 import { RuntimeWorkspaceView } from '#/runtime/runtimeWorkspaceView';
 import { createHooks } from '#/hooks';
-import { IAgentManager, MAIN_AGENT_ID } from '#/session/agentManager/agentManager';
+import { IAgentLifecycleService, MAIN_AGENT_ID } from '#/session/agentLifecycle/agentLifecycle';
 import { agentContextOf } from '#/agent/scopeContext/scopeContext';
 
 import {
@@ -64,7 +64,7 @@ export class SessionSubagentService extends Service implements ISessionSubagentS
   }
 
   constructor(
-    @IAgentManager private readonly agentManager: IAgentManager,
+    @IAgentLifecycleService private readonly agentLifecycle: IAgentLifecycleService,
     @ISessionAgentProfileCatalog private readonly catalog: ISessionAgentProfileCatalog,
     @IConfigService private readonly configService: IConfigService,
     @IFlagService private readonly flags: IFlagService,
@@ -75,14 +75,14 @@ export class SessionSubagentService extends Service implements ISessionSubagentS
     super();
   }
 
-  async run(agent: AgentContext, request: AgentRunRequest, opts: RunAgentOptions): Promise<AgentRunHandle> {
-    const current = this.agentManager.get(agent.agentId);
+  run(agent: AgentContext, request: AgentRunRequest, opts: RunAgentOptions): Promise<AgentRunHandle> {
+    const current = this.agentLifecycle.get(agent.agentId);
     if (current !== agent) {
       throw new Error2(ErrorCodes.AGENT_NOT_FOUND, `Agent "${agent.agentId}" does not exist`, {
         details: { agentId: agent.agentId },
       });
     }
-    const handle = this.agentManager.handleOf(agent.agentId);
+    const handle = this.agentLifecycle.handleOf(agent.agentId);
     if (handle === undefined) {
       throw new Error2(ErrorCodes.AGENT_NOT_FOUND, `Agent "${agent.agentId}" does not exist`, {
         details: { agentId: agent.agentId },
@@ -162,12 +162,12 @@ export class SessionSubagentService extends Service implements ISessionSubagentS
       let created: IAgentScopeHandle;
       try {
         if (plan.fork) {
-          const forked = await this.agentManager.fork(agentContextOf(caller), {
+          const forked = await this.agentLifecycle.fork(agentContextOf(caller), {
             labels: opts.labels,
           });
-          created = this.agentManager.handleOf(forked.agentId)!;
+          created = this.agentLifecycle.handleOf(forked.agentId)!;
         } else {
-          const createdContext = await this.agentManager.create({
+          const createdContext = await this.agentLifecycle.create({
             binding: {
               profile: plan.profileName,
               model: plan.model,
@@ -176,7 +176,7 @@ export class SessionSubagentService extends Service implements ISessionSubagentS
             labels: opts.labels,
             runtimeId: lease!.runtime.identity.runtimeId,
           });
-          created = this.agentManager.handleOf(createdContext.agentId)!;
+          created = this.agentLifecycle.handleOf(createdContext.agentId)!;
         }
       } catch (error) {
         throw wrapSubagentModelError(
@@ -232,7 +232,7 @@ export class SessionSubagentService extends Service implements ISessionSubagentS
   }
 
   private requireCaller(agentId: string): IAgentScopeHandle {
-    const handle = this.agentManager.handleOf(agentId);
+    const handle = this.agentLifecycle.handleOf(agentId);
     if (handle === undefined) {
       throw new Error2(ErrorCodes.AGENT_NOT_FOUND, `Caller agent "${agentId}" does not exist`, {
         details: { agentId },

packages/agent-core-v2/test/agent/userTool/userTool.test.ts

@@ -399,17 +399,17 @@ describe('AgentUserToolService (wire-backed)', () => {
 
   it('resolves the current interaction runtime at execution time', async () => {
     let currentInteraction = createInteractionStub();
-    const managerStub: IAgentManager = {
+    const managerStub: IAgentLifecycleService = {
       resolve: () => currentInteraction,
-    } as unknown as IAgentManager;
+    } as unknown as IAgentLifecycleService;
 
     const ixDynamic = disposables.add(new TestInstantiationService());
     ixDynamic.stub(IFileSystemStorageService, new InMemoryStorageService());
     ixDynamic.set(IAppendLogStore, new SyncDescriptor(AppendLogStore));
     ixDynamic.set(IAgentStateService, new AgentStateService());
     ixDynamic.set(IAgentToolRegistryService, new SyncDescriptor(AgentToolRegistryService));
     ixDynamic.stub(IAgentProfileService, createProfileStub());
-    ixDynamic.stub(IAgentManager, managerStub);
+    ixDynamic.stub(IAgentLifecycleService, managerStub);
     ixDynamic.set(IAgentUserToolService, new SyncDescriptor(AgentUserToolService));
     registerTestAgentWire(ixDynamic, testWireScope(SCOPE, 'user-tool-dynamic'), {
       log: ixDynamic.get(IAppendLogStore),

packages/agent-core-v2/test/app/skillCatalog/types.test.ts

@@ -55,6 +55,8 @@ describe('skill/types', () => {
       name: 'cv_ssh-ops',
       description: 'SSH ops',
       path: '/skills/cv_ssh-ops',
+      dir: '/skills/cv_ssh-ops',
+      content: '',
       source: 'user',
       metadata: {
         type: 'prompt',
@@ -64,7 +66,7 @@ describe('skill/types', () => {
         groups: ['cv', 'cv/ops'],
         tags: ['cv', 'ssh'],
       },
-    } as SkillDefinition;
+    };
     expect(summarizeSkill(skill)).toEqual({
       name: 'cv_ssh-ops',
       description: 'SSH ops',

packages/agent-core-v2/test/session/subagent/spawn.test.ts

@@ -512,15 +512,12 @@ describe('SessionSubagentService planSpawn and spawn', () => {
     expect(forkAgent).not.toHaveBeenCalled();
   });
 
-  it('rejects running a turn on a stale AgentContext', async () => {
+  it('rejects running a turn on a stale AgentContext', () => {
     const svc = service();
     const staleContext = stubAgentContext(CALLER_ID, 0);
 
-    await expect(
+    expect(() =>
       svc.run(staleContext, { kind: 'prompt', prompt: 'hello' }, { signal: new AbortController().signal }),
-    ).rejects.toMatchObject({
-      code: ErrorCodes.AGENT_NOT_FOUND,
-      message: `Agent "${CALLER_ID}" does not exist`,
-    });
+    ).toThrow(`Agent "${CALLER_ID}" does not exist`);
   });
 });