@pikku/core 0.12.83 → 0.12.86

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

@@ -1,5 +1,5 @@
-import type { AIStreamChannel, AIStreamEvent } from './ai-agent.types.js'
-import { randomUUID } from './ai-agent-utils.js'
+import type { AgentStreamChannel, AgentStreamEvent } from './agent.types.js'
+import { randomUUID } from './agent-utils.js'
 
 type AGUIEvent =
   | { type: 'TEXT_MESSAGE_START'; messageId: string }
@@ -57,9 +57,9 @@ function resultToString(result: unknown): string {
 }
 
 export function wrapChannelWithAGUI(
-  inner: AIStreamChannel,
+  inner: AgentStreamChannel,
   options?: AGUIChannelOptions
-): AIStreamChannel {
+): AgentStreamChannel {
   const threadId = options?.threadId ?? randomUUID()
   let runId: string | null = options?.runId ?? null
 
@@ -87,9 +87,9 @@ export function wrapChannelWithAGUI(
         type: 'RUN_STARTED',
         threadId,
         runId: resolveRunId(),
-      } as unknown as AIStreamEvent)
+      } as unknown as AgentStreamEvent)
     }
-    inner.send(event as unknown as AIStreamEvent)
+    inner.send(event as unknown as AgentStreamEvent)
   }
 
   function endTextMessage(): void {
@@ -171,7 +171,7 @@ export function wrapChannelWithAGUI(
     sendBinary: (data) => inner.sendBinary(data),
     close: () => inner.close(),
 
-    send: (event: AIStreamEvent) => {
+    send: (event: AgentStreamEvent) => {
       if (terminal) return
 
       switch (event.type) {

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

@@ -6,10 +6,10 @@ import {
   pikkuState,
   setSingletonServices,
 } from '../../pikku-state.js'
-import { assertAgentAuthorized } from './ai-agent-prepare.js'
+import { assertAgentAuthorized } from './agent-prepare.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 = {
@@ -27,16 +27,16 @@ beforeEach(() => {
 
 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`,
     instructions: `${agentName} instructions`,
     model: 'test/test-model',
     ...overrides,
-  } as CoreAIAgent
+  } as CoreAgent
 
   pikkuState(null, 'agent', 'agents').set(agentName, agent)
   return agent

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

@@ -4,13 +4,11 @@ import {
   applyOutputMiddleware,
   finalizeAgentRun,
   type FinalizedRun,
-} from './ai-agent-finalize.js'
-import type { AIAgentStep, PikkuAIMiddlewareHooks } from './ai-agent.types.js'
-import type { AIRunStateService } from '../../services/ai-run-state-service.js'
+} from './agent-finalize.js'
+import type { AgentStep, PikkuAgentMiddlewareHooks } from './agent.types.js'
+import type { AgentRunStateService } from '../../services/agent-run-state-service.js'
 
-const step = (
-  toolCalls: NonNullable<AIAgentStep['toolCalls']>
-): AIAgentStep => ({
+const step = (toolCalls: NonNullable<AgentStep['toolCalls']>): AgentStep => ({
   usage: { inputTokens: 0, outputTokens: 0 },
   toolCalls,
 })
@@ -24,7 +22,7 @@ const call = (name: string, result: string) => ({
 describe('applyOutputMiddleware', () => {
   test('hands the middleware every tool call the run made, flattened across steps', async () => {
     const seen: string[][] = []
-    const middleware: PikkuAIMiddlewareHooks[] = [
+    const middleware: PikkuAgentMiddlewareHooks[] = [
       {
         modifyOutput: (_services, ctx) => {
           seen.push(ctx.toolCalls.map((c) => c.name))
@@ -48,7 +46,7 @@ describe('applyOutputMiddleware', () => {
   })
 
   test('a rewritten tool call is redistributed back onto the step it came from', async () => {
-    const middleware: PikkuAIMiddlewareHooks[] = [
+    const middleware: PikkuAgentMiddlewareHooks[] = [
       {
         modifyOutput: (_services, ctx) => ({
           text: ctx.text,
@@ -79,7 +77,7 @@ describe('applyOutputMiddleware', () => {
   })
 
   test('dropping a tool call collapses the calls into the last step rather than mis-attributing them', async () => {
-    const middleware: PikkuAIMiddlewareHooks[] = [
+    const middleware: PikkuAgentMiddlewareHooks[] = [
       {
         modifyOutput: (_services, ctx) => ({
           text: ctx.text,
@@ -108,7 +106,7 @@ describe('applyOutputMiddleware', () => {
 
   test('runs the chain in reverse registration order, each hook seeing the previous rewrite', async () => {
     const order: string[] = []
-    const middleware: PikkuAIMiddlewareHooks[] = [
+    const middleware: PikkuAgentMiddlewareHooks[] = [
       {
         modifyOutput: (_services, ctx) => {
           order.push(`first saw ${ctx.text}`)
@@ -152,14 +150,14 @@ describe('finalizeAgentRun', () => {
 
   test('completes the run and records its usage', async () => {
     const updates: unknown[] = []
-    const aiRunState = {
+    const agentRunState = {
       updateRun: async (_runId: string, update: unknown) => {
         updates.push(update)
       },
-    } as unknown as AIRunStateService
+    } as unknown as AgentRunStateService
 
     await finalizeAgentRun(
-      aiRunState,
+      agentRunState,
       run({ inputTokens: 10, outputTokens: 20, model: 'gpt-4o' })
     )
 
@@ -173,13 +171,16 @@ describe('finalizeAgentRun', () => {
 
   test('omits usage entirely when no model reported one', async () => {
     const updates: any[] = []
-    const aiRunState = {
+    const agentRunState = {
       updateRun: async (_runId: string, update: unknown) => {
         updates.push(update)
       },
-    } as unknown as AIRunStateService
+    } as unknown as AgentRunStateService
 
-    await finalizeAgentRun(aiRunState, run({ inputTokens: 0, outputTokens: 0 }))
+    await finalizeAgentRun(
+      agentRunState,
+      run({ inputTokens: 0, outputTokens: 0 })
+    )
 
     assert.deepEqual(updates, [{ status: 'completed' }])
   })

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

@@ -1,12 +1,12 @@
 import type {
-  AIAgentStep,
-  AIMessage,
-  PikkuAIMiddlewareHooks,
-} from './ai-agent.types.js'
-import type { AIRunStateService } from '../../services/ai-run-state-service.js'
+  AgentStep,
+  AgentMessage,
+  PikkuAgentMiddlewareHooks,
+} from './agent.types.js'
+import type { AgentRunStateService } from '../../services/agent-run-state-service.js'
 import { pikkuState } from '../../pikku-state.js'
-import { scoreFinishedRun } from '../ai-scorer/ai-scorer-live.js'
-import { recordScoreSnapshot } from '../ai-scorer/ai-scorer-snapshots.js'
+import { scoreFinishedRun } from '../agent-scorer/agent-scorer-live.js'
+import { recordScoreSnapshot } from '../agent-scorer/agent-scorer-snapshots.js'
 
 export type RunUsage = {
   inputTokens: number
@@ -28,7 +28,7 @@ export type FinalizedRun = {
   /** The prompt the run answered — what a scorer grades the answer against. */
   input: string
   text: string
-  steps: AIAgentStep[]
+  steps: AgentStep[]
   usage: RunUsage
 }
 
@@ -36,7 +36,7 @@ export type FinalizedRun = {
  * The prompt a run answered: the most recent user turn, which is what the model
  * was last asked. On a resumed run the earlier turns are context, not the ask.
  */
-export const lastUserMessageText = (messages: AIMessage[]): string => {
+export const lastUserMessageText = (messages: AgentMessage[]): string => {
   for (let i = messages.length - 1; i >= 0; i--) {
     const message = messages[i]
     if (message?.role !== 'user') continue
@@ -52,8 +52,8 @@ export const lastUserMessageText = (messages: AIMessage[]): string => {
 }
 
 const flattenToolCalls = (
-  steps: AIAgentStep[]
-): NonNullable<AIAgentStep['toolCalls']> =>
+  steps: AgentStep[]
+): NonNullable<AgentStep['toolCalls']> =>
   steps.flatMap((step) => step.toolCalls ?? [])
 
 /**
@@ -63,9 +63,9 @@ const flattenToolCalls = (
  * step rather than silently mis-attributing calls to the wrong step.
  */
 const distributeToolCalls = (
-  steps: AIAgentStep[],
-  toolCalls: NonNullable<AIAgentStep['toolCalls']>
-): AIAgentStep[] => {
+  steps: AgentStep[],
+  toolCalls: NonNullable<AgentStep['toolCalls']>
+): AgentStep[] => {
   if (toolCalls.length !== flattenToolCalls(steps).length) {
     return steps.map((step, index) => ({
       ...step,
@@ -89,22 +89,22 @@ const distributeToolCalls = (
  * wraps the others, so it sees the output last.
  */
 export const applyOutputMiddleware = async (
-  aiMiddlewares: PikkuAIMiddlewareHooks[],
+  agentMiddlewares: PikkuAgentMiddlewareHooks[],
   singletonServices: any,
   input: {
     text: string
-    messages: AIMessage[]
-    steps: AIAgentStep[]
+    messages: AgentMessage[]
+    steps: AgentStep[]
     usage: { inputTokens: number; outputTokens: number }
   }
-): Promise<{ text: string; messages: AIMessage[]; steps: AIAgentStep[] }> => {
+): Promise<{ text: string; messages: AgentMessage[]; steps: AgentStep[] }> => {
   let text = input.text
   let messages = input.messages
   let steps = input.steps
   let toolCalls = flattenToolCalls(steps)
 
-  for (let i = aiMiddlewares.length - 1; i >= 0; i--) {
-    const mw = aiMiddlewares[i]
+  for (let i = agentMiddlewares.length - 1; i >= 0; i--) {
+    const mw = agentMiddlewares[i]
     if (!mw.modifyOutput) continue
     const result = await mw.modifyOutput(singletonServices, {
       text,
@@ -136,10 +136,10 @@ export const applyOutputMiddleware = async (
  * the streaming path, the client already has the reply.
  */
 export const finalizeAgentRun = async (
-  aiRunState: AIRunStateService,
+  agentRunState: AgentRunStateService,
   run: FinalizedRun
 ): Promise<void> => {
-  await aiRunState.updateRun(run.runId, {
+  await agentRunState.updateRun(run.runId, {
     status: 'completed',
     ...(run.usage.model
       ? {

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

@@ -5,7 +5,7 @@ import {
   agentStream,
   agentResume,
   agentApprove,
-} from './ai-agent-helpers.js'
+} from './agent-helpers.js'
 
 describe('agent helpers', () => {
   describe('agent', () => {

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

@@ -1,4 +1,4 @@
-import type { AgentInterruptResult } from './ai-agent-interrupt.js'
+import type { AgentInterruptResult } from './agent-interrupt.js'
 
 export function agent<TAgentMap extends Record<string, { output: any }>>(
   agentName: string & keyof TAgentMap