@pikku/core 0.12.83 → 0.12.84

package/dist/services/in-memory-agent-run-state-service.js

@@ -0,0 +1,54 @@
+export class InMemoryAgentRunStateService {
+    runs = new Map();
+    scores = new Map();
+    counter = 0;
+    async createRun(run) {
+        const runId = `run-${++this.counter}-${Date.now()}`;
+        this.runs.set(runId, { ...run, runId });
+        return runId;
+    }
+    async updateRun(runId, updates) {
+        const run = this.runs.get(runId);
+        if (run) {
+            Object.assign(run, updates, { updatedAt: new Date() });
+        }
+    }
+    async getRun(runId) {
+        return this.runs.get(runId) ?? null;
+    }
+    async getRunsByThread(threadId) {
+        return [...this.runs.values()].filter((r) => r.threadId === threadId);
+    }
+    async resolveApproval(toolCallId, status) {
+        for (const run of this.runs.values()) {
+            if (run.pendingApprovals) {
+                const approval = run.pendingApprovals.find((a) => a.toolCallId === toolCallId);
+                if (approval) {
+                    run.pendingApprovals = run.pendingApprovals.filter((a) => a.toolCallId !== toolCallId);
+                    run.updatedAt = new Date();
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async findRunByToolCallId(toolCallId) {
+        for (const run of this.runs.values()) {
+            if (run.pendingApprovals) {
+                const approval = run.pendingApprovals.find((a) => a.toolCallId === toolCallId);
+                if (approval) {
+                    return { run, approval };
+                }
+            }
+        }
+        return null;
+    }
+    async saveScore(score) {
+        const existing = this.scores.get(score.runId) ?? [];
+        existing.push({ ...score, createdAt: new Date() });
+        this.scores.set(score.runId, existing);
+    }
+    async getScores(runId) {
+        return [...(this.scores.get(runId) ?? [])];
+    }
+}

package/dist/services/index.d.ts

@@ -14,7 +14,7 @@ export { InMemoryWorkflowService } from './in-memory-workflow-service.js';
 export { QueueWebhookService, pikkuWebhookWorkerFunc, } from './queue-webhook-service.js';
 export { InMemoryQueueService } from './in-memory-queue-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
-export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
+export { InMemoryAgentRunStateService } from './in-memory-agent-run-state-service.js';
 export { LocalGatewayService } from './local-gateway-service.js';
 export type { ContentService, SignContentKeyArgs, SignURLArgs, GetUploadURLArgs, UploadURLResult, BucketKeyArgs, WriteFileArgs, CopyFileArgs, } from './content-service.js';
 export type { ScenarioPersona, ResolvedPersona, ScenarioPersonas, } from './personas-service.js';
@@ -30,10 +30,10 @@ export type { ScheduledTaskSummary, ScheduledTaskInfo, SchedulerService, } from
 export type { TriggerService } from './trigger-service.js';
 export type { GatewayService } from './gateway-service.js';
 export type { DeploymentService, DeploymentConfig, DeploymentInfo, DeploymentServiceConfig, } from './deployment-service.js';
-export type { AIStorageService } from './ai-storage-service.js';
-export type { AIAgentRunnerParams, AIAgentRunnerResult, AIAgentStepResult, AIAgentRunnerService, } from './ai-agent-runner-service.js';
+export type { AgentStorageService } from './agent-storage-service.js';
+export type { AgentRunnerParams, AgentRunnerResult, AgentStepResult, AgentRunnerService, } from './agent-runner-service.js';
 export type { AIEmbeddingService } from './ai-embedding-service.js';
-export type { CreateRunInput, SaveScoreInput, AIRunStateService, } from './ai-run-state-service.js';
+export type { CreateRunInput, SaveScoreInput, AgentRunStateService, } from './agent-run-state-service.js';
 export type { CredentialMeta } from './typed-secret-service.js';
 export type { CredentialService } from './credential-service.js';
 export { TypedCredentialService } from './typed-credential-service.js';

package/dist/services/index.js

@@ -14,7 +14,7 @@ export { InMemoryWorkflowService } from './in-memory-workflow-service.js';
 export { QueueWebhookService, pikkuWebhookWorkerFunc, } from './queue-webhook-service.js';
 export { InMemoryQueueService } from './in-memory-queue-service.js';
 export { InMemoryTriggerService } from './in-memory-trigger-service.js';
-export { InMemoryAIRunStateService } from './in-memory-ai-run-state-service.js';
+export { InMemoryAgentRunStateService } from './in-memory-agent-run-state-service.js';
 export { LocalGatewayService } from './local-gateway-service.js';
 export { DEFAULT_WEBHOOK_RETRIES, PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME, WebhookService, } from './webhook-service.js';
 export { TypedCredentialService } from './typed-credential-service.js';

package/dist/services/meta-service.d.ts

@@ -14,11 +14,11 @@ import type { SecretDefinitionsMeta } from '../wirings/secret/secret.types.js';
 import type { CredentialDefinitionsMeta } from '../wirings/credential/credential.types.js';
 import type { VariableDefinitionsMeta } from '../wirings/variable/variable.types.js';
 import type { FunctionMeta, FunctionsMeta, MiddlewareMetadata, PermissionMetadata } from '../types/core.types.js';
-import type { AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AgentsMeta } from '../wirings/agent/agent.types.js';
 import type { GatewaysMeta } from '../wirings/gateway/gateway.types.js';
 export type { FunctionMeta, FunctionsMeta, MiddlewareMetadata as MiddlewareMeta, PermissionMetadata as PermissionMeta, };
-export type AgentsMeta = AIAgentMeta;
-export type AgentMeta = AIAgentMeta[string];
+export type { AgentsMeta };
+export type AgentMeta = AgentsMeta[string];
 export interface MCPMeta {
     resources: MCPResourceMeta;
     tools: MCPToolMeta;

package/dist/testing/service-tests/agent-run-service-tests.d.ts

@@ -7,4 +7,4 @@ export declare const defineAgentRunServiceTests: (name: string, agentRunService:
  * only runs when a backend supplies both. Passed explicitly rather than
  * closed over, so the dependency is visible in the signature.
  */
-aiStorageService?: ServiceTestConfig["services"]["aiStorageService"]) => void;
+agentStorageService?: ServiceTestConfig["services"]["agentStorageService"]) => void;

package/dist/testing/service-tests/agent-run-service-tests.js

@@ -8,7 +8,7 @@ export const defineAgentRunServiceTests = (name, agentRunService,
  * only runs when a backend supplies both. Passed explicitly rather than
  * closed over, so the dependency is visible in the signature.
  */
-aiStorageService) => {
+agentStorageService) => {
     const factory = agentRunService;
     describe(`AgentRunService [${name}]`, () => {
         let agentService;
@@ -19,8 +19,8 @@ aiStorageService) => {
             const threads = await agentService.listThreads();
             assert.ok(Array.isArray(threads));
         });
-        if (aiStorageService) {
-            const storageFactory = aiStorageService;
+        if (agentStorageService) {
+            const storageFactory = agentStorageService;
             // The `owners` constraint is what keeps the generated thread-management
             // functions from leaking across tenants: a caller may only list threads
             // owned by one of their session principals, matching the

package/dist/testing/service-tests/agent-storage-service-tests.d.ts

@@ -0,0 +1,3 @@
+import type { ServiceTestConfig } from '../service-tests.js';
+/** Conformance suite for `agentStorageService`. Runs only when a backend supplies one. */
+export declare const defineAiStorageServiceTests: (name: string, agentStorageService: NonNullable<ServiceTestConfig["services"]["agentStorageService"]>) => void;

package/dist/testing/service-tests/agent-storage-service-tests.js

@@ -0,0 +1,302 @@
+import { describe, test, before } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `agentStorageService`. Runs only when a backend supplies one. */
+export const defineAiStorageServiceTests = (name, agentStorageService) => {
+    const factory = agentStorageService;
+    describe(`AgentStorageService [${name}]`, () => {
+        let storage;
+        before(async () => {
+            storage = await factory();
+        });
+        test('createThread and getThread', async () => {
+            const thread = await storage.createThread('resource-1', {
+                title: 'Test Thread',
+                metadata: { key: 'val' },
+            });
+            assert.ok(thread.id);
+            assert.equal(thread.resourceId, 'resource-1');
+            assert.equal(thread.title, 'Test Thread');
+            assert.deepEqual(thread.metadata, { key: 'val' });
+            const fetched = await storage.getThread(thread.id);
+            assert.equal(fetched.id, thread.id);
+            assert.equal(fetched.title, 'Test Thread');
+        });
+        test('getThreads', async () => {
+            const threads = await storage.getThreads('resource-1');
+            assert.ok(threads.length >= 1);
+            assert.ok(threads.every((t) => t.resourceId === 'resource-1'));
+        });
+        test('getThread throws for missing', async () => {
+            await assert.rejects(() => storage.getThread('missing-thread'));
+        });
+        test('saveMessages and getMessages', async () => {
+            const thread = await storage.createThread('resource-2');
+            const now = new Date();
+            await storage.saveMessages(thread.id, [
+                { id: 'msg-1', role: 'user', content: 'Hello', createdAt: now },
+                {
+                    id: 'msg-2',
+                    role: 'assistant',
+                    content: 'Hi there',
+                    createdAt: new Date(now.getTime() + 1000),
+                },
+            ]);
+            const messages = await storage.getMessages(thread.id);
+            assert.equal(messages.length, 2);
+            assert.equal(messages[0].role, 'user');
+            assert.equal(messages[0].content, 'Hello');
+            assert.equal(messages[1].role, 'assistant');
+            assert.equal(messages[1].content, 'Hi there');
+        });
+        test('saveMessages with tool calls and results', async () => {
+            const thread = await storage.createThread('resource-3');
+            const now = new Date();
+            await storage.saveMessages(thread.id, [
+                {
+                    id: 'msg-tc',
+                    role: 'assistant',
+                    content: 'Let me call a tool',
+                    toolCalls: [{ id: 'tc-1', name: 'search', args: { query: 'test' } }],
+                    createdAt: now,
+                },
+            ]);
+            await storage.saveMessages(thread.id, [
+                {
+                    id: 'tool-results-msg-tc',
+                    role: 'tool',
+                    toolResults: [{ id: 'tc-1', name: 'search', result: 'found it' }],
+                    createdAt: new Date(now.getTime() + 1000),
+                },
+            ]);
+            const messages = await storage.getMessages(thread.id);
+            assert.equal(messages.length, 2);
+            const assistantMsg = messages[0];
+            assert.equal(assistantMsg.role, 'assistant');
+            assert.ok(assistantMsg.toolCalls);
+            assert.equal(assistantMsg.toolCalls[0].name, 'search');
+            const toolMsg = messages[1];
+            assert.equal(toolMsg.role, 'tool');
+            assert.ok(toolMsg.toolResults);
+            assert.equal(toolMsg.toolResults[0].result, 'found it');
+        });
+        test('getMessages with lastN', async () => {
+            const thread = await storage.createThread('resource-4');
+            const base = Date.now();
+            await storage.saveMessages(thread.id, Array.from({ length: 5 }, (_, i) => ({
+                id: `bulk-msg-${i}`,
+                role: 'user',
+                content: `Message ${i}`,
+                createdAt: new Date(base + i * 1000),
+            })));
+            const messages = await storage.getMessages(thread.id, { lastN: 2 });
+            assert.equal(messages.length, 2);
+            assert.equal(messages[0].content, 'Message 3');
+            assert.equal(messages[1].content, 'Message 4');
+        });
+        test('working memory: save and get', async () => {
+            await storage.saveWorkingMemory('res-1', 'resource', {
+                key: 'value',
+            });
+            const mem = await storage.getWorkingMemory('res-1', 'resource');
+            assert.deepEqual(mem, { key: 'value' });
+        });
+        test('working memory: upsert overwrites', async () => {
+            await storage.saveWorkingMemory('res-1', 'resource', {
+                key: 'updated',
+            });
+            const mem = await storage.getWorkingMemory('res-1', 'resource');
+            assert.deepEqual(mem, { key: 'updated' });
+        });
+        test('working memory: returns null for missing', async () => {
+            const mem = await storage.getWorkingMemory('missing', 'thread');
+            assert.equal(mem, null);
+        });
+        test('createRun and getRun', async () => {
+            const thread = await storage.createThread('resource-5');
+            const now = new Date();
+            const runId = await storage.createRun({
+                agentName: 'test-agent',
+                threadId: thread.id,
+                resourceId: 'resource-5',
+                status: 'running',
+                usage: { inputTokens: 100, outputTokens: 50, model: 'test-model' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            assert.ok(runId);
+            const run = await storage.getRun(runId);
+            assert.ok(run);
+            assert.equal(run.agentName, 'test-agent');
+            assert.equal(run.status, 'running');
+            assert.equal(run.usage.inputTokens, 100);
+        });
+        test('updateRun', async () => {
+            const thread = await storage.createThread('resource-6');
+            const now = new Date();
+            const runId = await storage.createRun({
+                agentName: 'update-agent',
+                threadId: thread.id,
+                resourceId: 'resource-6',
+                status: 'running',
+                usage: { inputTokens: 0, outputTokens: 0, model: 'test' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            await storage.updateRun(runId, {
+                status: 'completed',
+                usage: { inputTokens: 200, outputTokens: 100, model: 'test-v2' },
+            });
+            const run = await storage.getRun(runId);
+            assert.ok(run);
+            assert.equal(run.status, 'completed');
+            assert.equal(run.usage.inputTokens, 200);
+            assert.equal(run.usage.model, 'test-v2');
+        });
+        test('getRunsByThread', async () => {
+            const thread = await storage.createThread('resource-7');
+            const now = new Date();
+            await storage.createRun({
+                agentName: 'multi-agent',
+                threadId: thread.id,
+                resourceId: 'resource-7',
+                status: 'completed',
+                usage: { inputTokens: 10, outputTokens: 5, model: 'test' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            const runs = await storage.getRunsByThread(thread.id);
+            assert.ok(runs.length >= 1);
+            assert.ok(runs.every((r) => r.threadId === thread.id));
+        });
+        test('saveScore and getScores', async () => {
+            const thread = await storage.createThread('resource-score');
+            const now = new Date();
+            const runId = await storage.createRun({
+                agentName: 'scored-agent',
+                threadId: thread.id,
+                resourceId: 'resource-score',
+                status: 'completed',
+                usage: { inputTokens: 10, outputTokens: 5, model: 'test' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            await storage.saveScore({
+                runId,
+                scorerName: 'tool-error-rate',
+                score: 1,
+            });
+            await storage.saveScore({
+                runId,
+                scorerName: 'helpfulness',
+                score: 0.75,
+                reason: 'answered the question but skipped the fee',
+                metadata: { subScores: { accuracy: 0.9 }, judgeTokens: 412 },
+            });
+            const scores = await storage.getScores(runId);
+            assert.equal(scores.length, 2);
+            const byName = new Map(scores.map((s) => [s.scorerName, s]));
+            const clean = byName.get('tool-error-rate');
+            assert.ok(clean);
+            assert.equal(clean.score, 1);
+            assert.equal(clean.reason, undefined);
+            assert.equal(clean.metadata, undefined);
+            const helpful = byName.get('helpfulness');
+            assert.ok(helpful);
+            // A fractional score has to survive the round trip: an integer column
+            // would quietly turn every grade into 0 or 1.
+            assert.equal(helpful.score, 0.75);
+            assert.equal(helpful.reason, 'answered the question but skipped the fee');
+            assert.deepEqual(helpful.metadata, {
+                subScores: { accuracy: 0.9 },
+                judgeTokens: 412,
+            });
+            assert.ok(helpful.createdAt instanceof Date);
+        });
+        test('a re-grade appends rather than replacing the grade that was acted on', async () => {
+            const thread = await storage.createThread('resource-regrade');
+            const now = new Date();
+            const runId = await storage.createRun({
+                agentName: 'regraded-agent',
+                threadId: thread.id,
+                resourceId: 'resource-regrade',
+                status: 'completed',
+                usage: { inputTokens: 1, outputTokens: 1, model: 'test' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            await storage.saveScore({ runId, scorerName: 'helpfulness', score: 0.2 });
+            await storage.saveScore({ runId, scorerName: 'helpfulness', score: 0.8 });
+            const scores = await storage.getScores(runId);
+            assert.equal(scores.length, 2);
+            assert.deepEqual(scores.map((s) => s.score), [0.2, 0.8]);
+        });
+        test('getScores is empty for a run nothing graded', async () => {
+            const thread = await storage.createThread('resource-ungraded');
+            const now = new Date();
+            const runId = await storage.createRun({
+                agentName: 'ungraded-agent',
+                threadId: thread.id,
+                resourceId: 'resource-ungraded',
+                status: 'completed',
+                usage: { inputTokens: 1, outputTokens: 1, model: 'test' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            assert.deepEqual(await storage.getScores(runId), []);
+        });
+        test('resolveApproval', async () => {
+            const thread = await storage.createThread('resource-8');
+            const now = new Date();
+            await storage.saveMessages(thread.id, [
+                {
+                    id: 'approval-msg',
+                    role: 'assistant',
+                    toolCalls: [{ id: 'approval-tc', name: 'dangerous-tool', args: {} }],
+                    createdAt: now,
+                },
+            ]);
+            const runId = await storage.createRun({
+                agentName: 'approval-agent',
+                threadId: thread.id,
+                resourceId: 'resource-8',
+                status: 'suspended',
+                suspendReason: 'approval',
+                pendingApprovals: [
+                    {
+                        type: 'tool-call',
+                        toolCallId: 'approval-tc',
+                        toolName: 'dangerous-tool',
+                        args: {},
+                    },
+                ],
+                usage: { inputTokens: 0, outputTokens: 0, model: 'test' },
+                createdAt: now,
+                updatedAt: now,
+            });
+            let run = await storage.getRun(runId);
+            assert.ok(run);
+            assert.ok(run.pendingApprovals);
+            assert.equal(run.pendingApprovals.length, 1);
+            const claimed = await storage.resolveApproval('approval-tc', 'approved');
+            assert.equal(claimed, true, 'the first approver claims the approval');
+            run = await storage.getRun(runId);
+            assert.ok(run);
+            assert.equal(run.pendingApprovals, undefined);
+            const second = await storage.resolveApproval('approval-tc', 'approved');
+            assert.equal(second, false, 'a second approver of the same tool call claims nothing');
+        });
+        test('deleteThread cascades', async () => {
+            const thread = await storage.createThread('resource-del');
+            await storage.saveMessages(thread.id, [
+                {
+                    id: 'del-msg',
+                    role: 'user',
+                    content: 'goodbye',
+                    createdAt: new Date(),
+                },
+            ]);
+            await storage.deleteThread(thread.id);
+            await assert.rejects(() => storage.getThread(thread.id));
+        });
+    });
+};

package/dist/testing/service-tests.d.ts

@@ -3,11 +3,11 @@ import type { EventHubStore } from '../wirings/channel/eventhub-store.js';
 import type { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js';
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js';
 import type { DeploymentService } from '../services/deployment-service.js';
-import type { AIStorageService } from '../services/ai-storage-service.js';
-import type { AIRunStateService } from '../services/ai-run-state-service.js';
+import type { AgentStorageService } from '../services/agent-storage-service.js';
+import type { AgentRunStateService } from '../services/agent-run-state-service.js';
 import type { SecretService } from '../services/secret-service.js';
 import type { CredentialService } from '../services/credential-service.js';
-import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AgentRunService } from '../wirings/agent/agent.types.js';
 import type { SessionStore } from '../services/session-store.js';
 export interface ServiceTestConfig {
     name: string;
@@ -19,7 +19,7 @@ export interface ServiceTestConfig {
         deploymentService?: () => Promise<DeploymentService & {
             stop(): Promise<void>;
         }>;
-        aiStorageService?: () => Promise<AIStorageService & AIRunStateService>;
+        agentStorageService?: () => Promise<AgentStorageService & AgentRunStateService>;
         agentRunService?: () => Promise<AgentRunService>;
         secretService?: (config: {
             key: string;

package/dist/testing/service-tests.js

@@ -2,7 +2,7 @@ import { defineChannelStoreTests } from './service-tests/channel-store-tests.js'
 import { defineEventHubStoreTests } from './service-tests/event-hub-store-tests.js';
 import { defineWorkflowServiceTests } from './service-tests/workflow-service-tests.js';
 import { defineWorkflowRunServiceTests } from './service-tests/workflow-run-service-tests.js';
-import { defineAiStorageServiceTests } from './service-tests/ai-storage-service-tests.js';
+import { defineAiStorageServiceTests } from './service-tests/agent-storage-service-tests.js';
 import { defineDeploymentServiceTests } from './service-tests/deployment-service-tests.js';
 import { defineSecretServiceTests } from './service-tests/secret-service-tests.js';
 import { defineCredentialServiceTests } from './service-tests/credential-service-tests.js';
@@ -28,8 +28,8 @@ export function defineServiceTests(config) {
     if (services.workflowRunService) {
         defineWorkflowRunServiceTests(name, services.workflowRunService);
     }
-    if (services.aiStorageService) {
-        defineAiStorageServiceTests(name, services.aiStorageService);
+    if (services.agentStorageService) {
+        defineAiStorageServiceTests(name, services.agentStorageService);
     }
     if (services.deploymentService) {
         defineDeploymentServiceTests(name, services.deploymentService);
@@ -41,7 +41,7 @@ export function defineServiceTests(config) {
         defineCredentialServiceTests(name, services.credentialService);
     }
     if (services.agentRunService) {
-        defineAgentRunServiceTests(name, services.agentRunService, services.aiStorageService);
+        defineAgentRunServiceTests(name, services.agentRunService, services.agentStorageService);
     }
     if (services.sessionStore) {
         defineSessionStoreTests(name, services.sessionStore);

package/dist/types/core.types.d.ts

@@ -19,15 +19,15 @@ import type { PikkuTrigger } from '../wirings/trigger/trigger.types.js';
 import type { PikkuGateway } from '../wirings/gateway/gateway.types.js';
 import type { SchedulerService } from '../services/scheduler-service.js';
 import type { DeploymentService } from '../services/deployment-service.js';
-import type { AIStorageService } from '../services/ai-storage-service.js';
+import type { AgentStorageService } from '../services/agent-storage-service.js';
 import type { ContentService } from '../services/content-service.js';
 import type { ScenarioPersonaOf, ScenarioPersonas } from '../services/personas-service.js';
-import type { AIAgentRunnerService } from '../services/ai-agent-runner-service.js';
+import type { AgentRunnerService } from '../services/agent-runner-service.js';
 import type { AIEmbeddingService } from '../services/ai-embedding-service.js';
-import type { AIRunStateService } from '../services/ai-run-state-service.js';
-import type { AgentRunService } from '../wirings/ai-agent/ai-agent.types.js';
+import type { AgentRunStateService } from '../services/agent-run-state-service.js';
+import type { AgentRunService } from '../wirings/agent/agent.types.js';
 import type { VirtualUserRunStore } from '../wirings/virtual-user/virtual-user-run-store.js';
-import type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js';
+import type { PikkuAgentMiddlewareHooks } from '../wirings/agent/agent.types.js';
 import type { WorkflowRunService } from '../wirings/workflow/workflow.types.js';
 import type { CredentialService } from '../services/credential-service.js';
 import type { EmailService } from '../services/email-service.js';
@@ -259,11 +259,11 @@ export interface CoreSingletonServices<Config extends CoreConfig = CoreConfig> {
     eventHub?: EventHubService<Record<string, any>>;
     schedulerService?: SchedulerService;
     deploymentService?: DeploymentService;
-    aiStorage?: AIStorageService;
+    agentStorage?: AgentStorageService;
     content?: ContentService;
-    aiAgentRunner?: AIAgentRunnerService;
+    agentRunner?: AgentRunnerService;
     aiEmbedding?: AIEmbeddingService;
-    aiRunState?: AIRunStateService;
+    agentRunState?: AgentRunStateService;
     agentRunService?: AgentRunService;
     workflowRunService?: WorkflowRunService;
     credentialService?: CredentialService;
@@ -387,8 +387,8 @@ export declare const pikkuMiddleware: <SingletonServices extends CoreSingletonSe
 export declare const pikkuMiddlewareFactory: <In = any>(factory: CorePikkuMiddlewareFactory<In>) => CorePikkuMiddlewareFactory<In>;
 export declare const pikkuChannelMiddleware: <SingletonServices extends CoreSingletonServices = CoreSingletonServices, Event = unknown>(middleware: CorePikkuChannelMiddleware<SingletonServices, Event>) => CorePikkuChannelMiddleware<SingletonServices, Event>;
 export declare const pikkuChannelMiddlewareFactory: <In = any>(factory: CorePikkuChannelMiddlewareFactory<In>) => CorePikkuChannelMiddlewareFactory<In>;
-export type { PikkuAIMiddlewareHooks } from '../wirings/ai-agent/ai-agent.types.js';
-export declare const pikkuAIMiddleware: <State extends Record<string, unknown> = Record<string, unknown>, SingletonServices extends CoreSingletonServices = CoreSingletonServices>(hooks: PikkuAIMiddlewareHooks<State, SingletonServices>) => PikkuAIMiddlewareHooks<State, SingletonServices>;
+export type { PikkuAgentMiddlewareHooks } from '../wirings/agent/agent.types.js';
+export declare const pikkuAgentMiddleware: <State extends Record<string, unknown> = Record<string, unknown>, SingletonServices extends CoreSingletonServices = CoreSingletonServices>(hooks: PikkuAgentMiddlewareHooks<State, SingletonServices>) => PikkuAgentMiddlewareHooks<State, SingletonServices>;
 export type CoreServices<SingletonServices = CoreSingletonServices> = SingletonServices;
 /** Strips `secrets` from a services type. */
 export type SecretlessServices<Services> = Omit<Services, 'secrets'>;

package/dist/types/core.types.js

@@ -16,4 +16,4 @@ export const pikkuChannelMiddleware = (middleware) => {
 export const pikkuChannelMiddlewareFactory = (factory) => {
     return factory;
 };
-export const pikkuAIMiddleware = (hooks) => hooks;
+export const pikkuAgentMiddleware = (hooks) => hooks;

package/dist/types/state.types.d.ts

@@ -5,8 +5,8 @@ import type { CoreChannel, ChannelsMeta } from '../wirings/channel/channel.types
 import type { CLIMeta, CLIProgramState } from '../wirings/cli/cli.types.js';
 import type { HTTPMethod, CoreHTTPFunctionWiring, HTTPWiringsMeta } from '../wirings/http/http.types.js';
 import type { CoreMCPResource, MCPResourceMeta, MCPToolMeta, CoreMCPPrompt, MCPPromptMeta } from '../wirings/mcp/mcp.types.js';
-import type { CoreAIAgent, AIAgentMeta } from '../wirings/ai-agent/ai-agent.types.js';
-import type { PikkuAIScorer, ScorerMeta } from '../wirings/ai-scorer/ai-scorer.types.js';
+import type { CoreAgent, AgentsMeta } from '../wirings/agent/agent.types.js';
+import type { PikkuAgentScorer, ScorerMeta } from '../wirings/agent-scorer/agent-scorer.types.js';
 import type { CoreGateway, GatewaysMeta } from '../wirings/gateway/gateway.types.js';
 import type { CoreQueueWorker, QueueWorkersMeta } from '../wirings/queue/queue.types.js';
 import type { CoreScheduledTask, ScheduledTasksMeta } from '../wirings/scheduler/scheduler.types.js';
@@ -105,9 +105,9 @@ export interface PikkuPackageState {
         promptsMeta: MCPPromptMeta;
     };
     agent: {
-        agents: Map<string, CoreAIAgent>;
-        agentsMeta: AIAgentMeta;
-        scorers: Map<string, PikkuAIScorer>;
+        agents: Map<string, CoreAgent>;
+        agentsMeta: AgentsMeta;
+        scorers: Map<string, PikkuAgentScorer>;
         scorersMeta: ScorerMeta;
         /** Alias -> `provider/model`, from the `models` table in pikku.config.json. */
         modelAliases: Record<string, string>;

package/dist/wirings/actor-flow/run-conversation.d.ts

@@ -1,8 +1,8 @@
 import type { ActorFlowApprovalPolicy, ActorFlowVerdict, TargetAgentDriver } from './actor-flow.types.js';
 import type { ResolvedPersona } from '../../services/personas-service.js';
-import type { AIAgentRunnerParams, AIAgentStepResult } from '../../services/ai-agent-runner-service.js';
+import type { AgentRunnerParams, AgentStepResult } from '../../services/agent-runner-service.js';
 /** The LLM call the actor uses for its own turns/decisions/evaluation. */
-export type ActorLLM = (params: AIAgentRunnerParams) => Promise<AIAgentStepResult>;
+export type ActorLLM = (params: AgentRunnerParams) => Promise<AgentStepResult>;
 export interface RunConversationParams {
     /** The person being played — name, job title, personality. */
     persona: ResolvedPersona;