@pikku/core 0.12.83 → 0.12.84

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

@@ -7,14 +7,14 @@ import {
   setSingletonServices,
 } from '../../pikku-state.js'
 import {
-  addAIAgent,
-  approveAIAgent,
-  getAIAgents,
-  getAIAgentsMeta,
-} from './ai-agent-registry.js'
+  addAgent,
+  approveAgent,
+  getAgents,
+  getAgentsMeta,
+} from './agent-registry.js'
 import { clearPermissionsCache } from '../../permissions.js'
 import { ForbiddenError, MissingScopeError } from '../../errors/errors.js'
-import type { CoreAIAgent } from './ai-agent.types.js'
+import type { CoreAgent } from './agent.types.js'
 import type { CoreUserSession } from '../../types/core.types.js'
 
 const logger = {
@@ -26,7 +26,7 @@ const logger = {
 
 const registerAgent = (
   agentName: string,
-  overrides: Partial<CoreAIAgent> = {}
+  overrides: Partial<CoreAgent> = {}
 ) => {
   const agent = {
     name: agentName,
@@ -34,7 +34,7 @@ const registerAgent = (
     goal: `${agentName} goal`,
     model: 'test/test-model',
     ...overrides,
-  } as CoreAIAgent
+  } as CoreAgent
   pikkuState(null, 'agent', 'agents').set(agentName, agent)
   pikkuState(null, 'agent', 'agentsMeta')[agentName] = { ...agent } as any
   return agent
@@ -53,7 +53,7 @@ beforeEach(() => {
   setSingletonServices({ logger } as any)
 })
 
-describe('addAIAgent', () => {
+describe('addAgent', () => {
   test('skips registration when metadata is missing and warns', () => {
     const warnings: string[] = []
     const originalWarn = console.warn
@@ -62,7 +62,7 @@ describe('addAIAgent', () => {
     }
 
     try {
-      addAIAgent('missing-agent', {
+      addAgent('missing-agent', {
         name: 'missing-agent',
         description: 'desc',
         goal: 'goal',
@@ -73,7 +73,7 @@ describe('addAIAgent', () => {
       console.warn = originalWarn
     }
 
-    assert.equal(getAIAgents().has('missing-agent'), false)
+    assert.equal(getAgents().has('missing-agent'), false)
     assert.match(warnings[0], /Skipping AI agent 'missing-agent'/)
   })
 
@@ -84,7 +84,7 @@ describe('addAIAgent', () => {
       goal: 'goal',
     } as any
 
-    addAIAgent('assistant', {
+    addAgent('assistant', {
       name: 'assistant',
       description: 'desc',
       goal: 'goal',
@@ -92,10 +92,10 @@ describe('addAIAgent', () => {
       model: 'model',
     } as any)
 
-    assert.equal(getAIAgents().get('assistant')?.name, 'assistant')
+    assert.equal(getAgents().get('assistant')?.name, 'assistant')
     assert.throws(
       () =>
-        addAIAgent('assistant', {
+        addAgent('assistant', {
           name: 'assistant',
           description: 'desc',
           goal: 'goal',
@@ -109,7 +109,7 @@ describe('addAIAgent', () => {
   })
 })
 
-describe('approveAIAgent', () => {
+describe('approveAgent', () => {
   const ownerParams = {
     sessionService: sessionService({ userId: 'resource-1' } as CoreUserSession),
   } as any
@@ -117,13 +117,13 @@ describe('approveAIAgent', () => {
   test('throws when run state service is missing, run is missing, or run is not suspended', async () => {
     registerAgent('agent')
 
-    await assert.rejects(() => approveAIAgent(null as any, 'run-1', []), {
-      message: 'AIRunStateService not available',
+    await assert.rejects(() => approveAgent(null as any, 'run-1', []), {
+      message: 'AgentRunStateService not available',
     })
 
     await assert.rejects(
       () =>
-        approveAIAgent(
+        approveAgent(
           {
             getRun: async () => null,
             updateRun: async () => {},
@@ -140,7 +140,7 @@ describe('approveAIAgent', () => {
 
     await assert.rejects(
       () =>
-        approveAIAgent(
+        approveAgent(
           {
             getRun: async () => ({
               runId: 'run-1',
@@ -171,7 +171,7 @@ describe('approveAIAgent', () => {
 
   test('rejects approval when run agent does not match expected agent', async () => {
     registerAgent('internal-agent')
-    const aiRunState = {
+    const agentRunState = {
       getRun: async () => ({
         runId: 'run-1',
         agentName: 'internal-agent',
@@ -188,8 +188,8 @@ describe('approveAIAgent', () => {
 
     await assert.rejects(
       () =>
-        approveAIAgent(
-          aiRunState,
+        approveAgent(
+          agentRunState,
           'run-1',
           [{ toolCallId: 'call-1', approved: true }],
           'public-agent',
@@ -205,7 +205,7 @@ describe('approveAIAgent', () => {
   test('marks run resumed when at least one approval is granted', async () => {
     registerAgent('assistant')
     const updates: any[] = []
-    const result = await approveAIAgent(
+    const result = await approveAgent(
       {
         getRun: async () => ({
           runId: 'run-2',
@@ -264,7 +264,7 @@ describe('approveAIAgent', () => {
   test('keeps run suspended when nothing is approved', async () => {
     registerAgent('assistant')
     const updates: any[] = []
-    const result = await approveAIAgent(
+    const result = await approveAgent(
       {
         getRun: async () => ({
           runId: 'run-3',
@@ -310,7 +310,7 @@ describe('approveAIAgent', () => {
   })
 })
 
-describe('approveAIAgent authorization', () => {
+describe('approveAgent authorization', () => {
   const suspendedRun = (agentName: string, resourceId: string) => ({
     runId: 'run-auth',
     agentName,
@@ -329,7 +329,7 @@ describe('approveAIAgent authorization', () => {
     const updates: any[] = []
     return {
       updates,
-      aiRunState: {
+      agentRunState: {
         getRun: async () => suspendedRun(agentName, resourceId),
         updateRun: async (_runId: string, patch: any) => {
           updates.push(patch)
@@ -340,12 +340,15 @@ describe('approveAIAgent authorization', () => {
 
   test('rejects when the run belongs to another session principal', async () => {
     registerAgent('owned-agent')
-    const { updates, aiRunState } = runStateFor('owned-agent', 'user-a:default')
+    const { updates, agentRunState } = runStateFor(
+      'owned-agent',
+      'user-a:default'
+    )
 
     await assert.rejects(
       () =>
-        approveAIAgent(
-          aiRunState,
+        approveAgent(
+          agentRunState,
           'run-auth',
           [{ toolCallId: 'call-1', approved: true }],
           undefined,
@@ -359,13 +362,13 @@ describe('approveAIAgent authorization', () => {
   test('rejects when the agent permissions deny', async () => {
     registerAgent('denied-agent', {
       permissions: { denied: async () => false },
-    } as Partial<CoreAIAgent>)
-    const { updates, aiRunState } = runStateFor('denied-agent', 'u1')
+    } as Partial<CoreAgent>)
+    const { updates, agentRunState } = runStateFor('denied-agent', 'u1')
 
     await assert.rejects(
       () =>
-        approveAIAgent(
-          aiRunState,
+        approveAgent(
+          agentRunState,
           'run-auth',
           [{ toolCallId: 'call-1', approved: true }],
           undefined,
@@ -378,12 +381,12 @@ describe('approveAIAgent authorization', () => {
 
   test('rejects when a required scope is no longer held', async () => {
     registerAgent('scoped-agent', { scopes: ['admin:refund'] })
-    const { updates, aiRunState } = runStateFor('scoped-agent', 'u1')
+    const { updates, agentRunState } = runStateFor('scoped-agent', 'u1')
 
     await assert.rejects(
       () =>
-        approveAIAgent(
-          aiRunState,
+        approveAgent(
+          agentRunState,
           'run-auth',
           [{ toolCallId: 'call-1', approved: true }],
           undefined,
@@ -401,11 +404,11 @@ describe('approveAIAgent authorization', () => {
 
   test('rejects when auth is required and the session is gone', async () => {
     registerAgent('auth-agent', { auth: true })
-    const { updates, aiRunState } = runStateFor('auth-agent', 'resource-1')
+    const { updates, agentRunState } = runStateFor('auth-agent', 'resource-1')
 
     await assert.rejects(
       () =>
-        approveAIAgent(aiRunState, 'run-auth', [
+        approveAgent(agentRunState, 'run-auth', [
           { toolCallId: 'call-1', approved: true },
         ]),
       ForbiddenError
@@ -415,10 +418,13 @@ describe('approveAIAgent authorization', () => {
 
   test('allows the owning session through the gate', async () => {
     registerAgent('owned-agent', { scopes: ['admin:refund'] })
-    const { updates, aiRunState } = runStateFor('owned-agent', 'user-a:default')
+    const { updates, agentRunState } = runStateFor(
+      'owned-agent',
+      'user-a:default'
+    )
 
-    const result = await approveAIAgent(
-      aiRunState,
+    const result = await approveAgent(
+      agentRunState,
       'run-auth',
       [{ toolCallId: 'call-1', approved: true }],
       undefined,
@@ -437,9 +443,9 @@ describe('approveAIAgent authorization', () => {
   })
 })
 
-describe('getAIAgentsMeta', () => {
+describe('getAgentsMeta', () => {
   test('returns the shared metadata registry', () => {
-    const meta = getAIAgentsMeta()
+    const meta = getAgentsMeta()
     meta.assistant = { name: 'assistant' } as any
     assert.equal(
       pikkuState(null, 'agent', 'agentsMeta').assistant.name,

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

@@ -1,17 +1,17 @@
-import type { CoreAIAgent, AgentRunState } from './ai-agent.types.js'
+import type { CoreAgent, AgentRunState } from './agent.types.js'
 import { pikkuState } from '../../pikku-state.js'
-import type { AIRunStateService } from '../../services/ai-run-state-service.js'
+import type { AgentRunStateService } from '../../services/agent-run-state-service.js'
 import {
   agentSessionScope,
   assertAgentAuthorized,
   assertResourcePrincipalOwner,
   resolveAgent,
-  type RunAIAgentParams,
-} from './ai-agent-prepare.js'
+  type RunAgentParams,
+} from './agent-prepare.js'
 
-export const addAIAgent = (
+export const addAgent = (
   agentName: string,
-  agent: CoreAIAgent<any, any>,
+  agent: CoreAgent<any, any>,
   packageName: string | null = null
 ) => {
   const agentsMeta = pikkuState(packageName, 'agent', 'agentsMeta')
@@ -29,12 +29,12 @@ export const addAIAgent = (
   agents.set(agentName, agent)
 }
 
-export async function approveAIAgent(
-  aiRunState: AIRunStateService,
+export async function approveAgent(
+  agentRunState: AgentRunStateService,
   runId: string,
   approvals: { toolCallId: string; approved: boolean }[],
   expectedAgentName?: string,
-  params: RunAIAgentParams = {}
+  params: RunAgentParams = {}
 ): Promise<{
   status: 'resumed' | 'suspended'
   runId: string
@@ -42,9 +42,9 @@ export async function approveAIAgent(
   rejected: string[]
   remainingApprovals: number
 }> {
-  if (!aiRunState) throw new Error('AIRunStateService not available')
+  if (!agentRunState) throw new Error('AgentRunStateService not available')
 
-  const run = await aiRunState.getRun(runId)
+  const run = await agentRunState.getRun(runId)
   if (!run) throw new Error('Run not found: ' + runId)
   assertResourcePrincipalOwner(
     params,
@@ -76,7 +76,7 @@ export async function approveAIAgent(
   )
 
   const hasApproved = approvedIds.size > 0
-  await aiRunState.updateRun(runId, {
+  await agentRunState.updateRun(runId, {
     status: hasApproved ? 'running' : 'suspended',
     pendingApprovals: remaining.length > 0 ? remaining : undefined,
   })
@@ -90,10 +90,10 @@ export async function approveAIAgent(
   }
 }
 
-export const getAIAgents = () => {
+export const getAgents = () => {
   return pikkuState(null, 'agent', 'agents')
 }
 
-export const getAIAgentsMeta = () => {
+export const getAgentsMeta = () => {
   return pikkuState(null, 'agent', 'agentsMeta')
 }

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

@@ -6,11 +6,11 @@ import {
   pikkuState,
   setSingletonServices,
 } from '../../pikku-state.js'
-import { resumeAIAgentSync } from './ai-agent-runner.js'
-import { resumeAIAgent } from './ai-agent-stream.js'
+import { resumeAgentSync } from './agent-runner.js'
+import { resumeAgent } from './agent-stream.js'
 import { clearPermissionsCache } from '../../permissions.js'
 import { ForbiddenError, MissingScopeError } from '../../errors/errors.js'
-import type { CoreAIAgent } from './ai-agent.types.js'
+import type { CoreAgent } from './agent.types.js'
 import type { CoreUserSession } from '../../types/core.types.js'
 
 const logger = {
@@ -39,7 +39,7 @@ const setup = (agentName: string, resourceId = 'u1') => {
   const resolved: string[] = []
   setSingletonServices({
     logger,
-    aiRunState: {
+    agentRunState: {
       getRun: async () => suspendedRun(agentName, resourceId),
       resolveApproval: async (toolCallId: string) => {
         resolved.push(toolCallId)
@@ -52,15 +52,15 @@ const setup = (agentName: string, resourceId = 'u1') => {
 
 const addAgent = (
   agentName: string,
-  overrides: Partial<CoreAIAgent> = {}
-): CoreAIAgent => {
-  const agent: CoreAIAgent = {
+  overrides: Partial<CoreAgent> = {}
+): CoreAgent => {
+  const agent: CoreAgent = {
     name: agentName,
     description: `${agentName} description`,
     goal: `${agentName} goal`,
     model: 'test/test-model',
     ...overrides,
-  } as CoreAIAgent
+  } as CoreAgent
 
   pikkuState(null, 'agent', 'agents').set(agentName, agent)
   return agent
@@ -78,16 +78,16 @@ beforeEach(() => {
   clearPermissionsCache()
 })
 
-describe('resumeAIAgentSync authorization', () => {
+describe('resumeAgentSync authorization', () => {
   test('rejects when the agent permissions deny', async () => {
     const resolved = setup('denied-agent')
     addAgent('denied-agent', {
       permissions: { denied: async () => false },
-    } as Partial<CoreAIAgent>)
+    } as Partial<CoreAgent>)
 
     await assert.rejects(
       () =>
-        resumeAIAgentSync(
+        resumeAgentSync(
           RUN_ID,
           [{ toolCallId: TOOL_CALL_ID, approved: true }],
           { sessionService: sessionService({ userId: 'u1' }) } as any
@@ -107,7 +107,7 @@ describe('resumeAIAgentSync authorization', () => {
 
     await assert.rejects(
       () =>
-        resumeAIAgentSync(
+        resumeAgentSync(
           RUN_ID,
           [{ toolCallId: TOOL_CALL_ID, approved: true }],
           {
@@ -128,7 +128,7 @@ describe('resumeAIAgentSync authorization', () => {
 
     await assert.rejects(
       () =>
-        resumeAIAgentSync(
+        resumeAgentSync(
           RUN_ID,
           [{ toolCallId: TOOL_CALL_ID, approved: true }],
           {
@@ -150,7 +150,7 @@ describe('resumeAIAgentSync authorization', () => {
 
     await assert.rejects(
       () =>
-        resumeAIAgentSync(
+        resumeAgentSync(
           RUN_ID,
           [{ toolCallId: TOOL_CALL_ID, approved: true }],
           { sessionService: sessionService(undefined) } as any
@@ -160,7 +160,7 @@ describe('resumeAIAgentSync authorization', () => {
   })
 })
 
-describe('resumeAIAgent (streaming) authorization', () => {
+describe('resumeAgent (streaming) authorization', () => {
   const channel = {
     send: async () => {},
     close: async () => {},
@@ -170,11 +170,11 @@ describe('resumeAIAgent (streaming) authorization', () => {
     const resolved = setup('stream-denied')
     addAgent('stream-denied', {
       permissions: { denied: async () => false },
-    } as Partial<CoreAIAgent>)
+    } as Partial<CoreAgent>)
 
     await assert.rejects(
       () =>
-        resumeAIAgent(
+        resumeAgent(
           { runId: RUN_ID, toolCallId: TOOL_CALL_ID, approved: true },
           channel,
           { sessionService: sessionService({ userId: 'u1' }) } as any
@@ -190,7 +190,7 @@ describe('resumeAIAgent (streaming) authorization', () => {
 
     await assert.rejects(
       () =>
-        resumeAIAgent(
+        resumeAgent(
           { runId: RUN_ID, toolCallId: TOOL_CALL_ID, approved: true },
           channel,
           {

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

@@ -2,15 +2,11 @@ import type { PikkuRawWire } from '../../types/core.types.js'
 import type { SessionService } from '../../services/user-session-service.js'
 import type { CoreUserSession } from '../../types/core.types.js'
 import type { PikkuRPC } from '../rpc/rpc-types.js'
-import type { AIAgentInput, AIStreamChannel } from './ai-agent.types.js'
-import type { StreamAIAgentOptions } from './ai-agent-prepare.js'
-import { runAIAgent, resumeAIAgentSync } from './ai-agent-runner.js'
-import {
-  streamAIAgent,
-  resumeAIAgent,
-  interruptAIAgent,
-} from './ai-agent-stream.js'
-import { wrapChannelWithAGUI } from './ai-agent-agui.js'
+import type { AgentInput, AgentStreamChannel } from './agent.types.js'
+import type { StreamAgentOptions } from './agent-prepare.js'
+import { runAgent, resumeAgentSync } from './agent-runner.js'
+import { streamAgent, resumeAgent, interruptAgent } from './agent-stream.js'
+import { wrapChannelWithAGUI } from './agent-agui.js'
 
 export type AgentRPCOptions = {
   sessionService?: SessionService<CoreUserSession>
@@ -32,14 +28,14 @@ export const createAgentRPC = (
     getCredential: wire.getCredential?.bind(wire),
   })
 
-  const streamingChannel = (): AIStreamChannel => {
-    const channel = wire.channel as unknown as AIStreamChannel | undefined
+  const streamingChannel = (): AgentStreamChannel => {
+    const channel = wire.channel as unknown as AgentStreamChannel | undefined
     if (!channel) throw new Error('No channel available for streaming')
     return channel
   }
 
   /** `run` and `approve` return the same shape; only the call differs. */
-  const asRunResult = (result: Awaited<ReturnType<typeof runAIAgent>>) => ({
+  const asRunResult = (result: Awaited<ReturnType<typeof runAgent>>) => ({
     runId: result.runId,
     result: result.object ?? result.text,
     usage: result.usage,
@@ -50,8 +46,8 @@ export const createAgentRPC = (
   })
 
   return {
-    run: async (agentName: string, input: AIAgentInput) =>
-      asRunResult(await runAIAgent(agentName, input, params())),
+    run: async (agentName: string, input: AgentInput) =>
+      asRunResult(await runAgent(agentName, input, params())),
 
     stream: async (
       agentName: string,
@@ -62,10 +58,10 @@ export const createAgentRPC = (
         model?: string
         temperature?: number
       },
-      streamOptions?: StreamAIAgentOptions
+      streamOptions?: StreamAgentOptions
     ) => {
       let currentRunId: string | undefined
-      await streamAIAgent(
+      await streamAgent(
         agentName,
         input,
         wrapChannelWithAGUI(streamingChannel(), {
@@ -87,9 +83,9 @@ export const createAgentRPC = (
     resume: async (
       runId: string,
       input: { toolCallId: string; approved: boolean },
-      streamOptions?: StreamAIAgentOptions
+      streamOptions?: StreamAgentOptions
     ) => {
-      await resumeAIAgent(
+      await resumeAgent(
         { runId, ...input },
         wrapChannelWithAGUI(streamingChannel(), { runId }),
         params(),
@@ -98,7 +94,7 @@ export const createAgentRPC = (
     },
 
     interrupt: async (runId: string, reason?: 'speech' | 'user' | 'timeout') =>
-      interruptAIAgent(
+      interruptAgent(
         { runId, ...(reason ? { reason } : {}) },
         { sessionService: options.sessionService }
       ),
@@ -109,7 +105,7 @@ export const createAgentRPC = (
       expectedAgentName?: string
     ) =>
       asRunResult(
-        await resumeAIAgentSync(
+        await resumeAgentSync(
           runId,
           approvals,
           { sessionService: options.sessionService },