@pikku/core 0.12.107 → 0.12.111

package/src/testing/service-tests/agent-storage-service-tests.ts

@@ -1,379 +0,0 @@
-import { describe, test, before } from 'node:test'
-import assert from 'node:assert/strict'
-
-import type { AgentStorageService } from '../../services/agent-storage-service.js'
-import type { AgentRunStateService } from '../../services/agent-run-state-service.js'
-import type { ServiceTestConfig } from '../service-tests.js'
-
-/** Conformance suite for `agentStorageService`. Runs only when a backend supplies one. */
-export const defineAiStorageServiceTests = (
-  name: string,
-  agentStorageService: NonNullable<
-    ServiceTestConfig['services']['agentStorageService']
-  >
-): void => {
-  const factory = agentStorageService
-  describe(`AgentStorageService [${name}]`, () => {
-    let storage: AgentStorageService & AgentRunStateService
-
-    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' as const,
-          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/src/testing/service-tests/channel-store-tests.ts

@@ -1,98 +0,0 @@
-import { describe, test, before } from 'node:test'
-import assert from 'node:assert/strict'
-
-import type { ChannelStore } from '../../wirings/channel/channel-store.js'
-import type { ServiceTestConfig } from '../service-tests.js'
-
-/** Conformance suite for `channelStore`. Runs only when a backend supplies one. */
-export const defineChannelStoreTests = (
-  name: string,
-  channelStore: NonNullable<ServiceTestConfig['services']['channelStore']>
-): void => {
-  const factory = channelStore
-  describe(`ChannelStore [${name}]`, () => {
-    let store: ChannelStore
-
-    before(async () => {
-      store = await factory()
-    })
-
-    test('addChannel and getChannel', async () => {
-      await store.addChannel({
-        channelId: 'ch-1',
-        channelName: 'test-channel',
-        openingData: { foo: 'bar' },
-      })
-
-      const result = await store.getChannel('ch-1')
-      assert.equal(result.channelId, 'ch-1')
-      assert.equal(result.channelName, 'test-channel')
-      assert.deepEqual(result.openingData, { foo: 'bar' })
-      assert.equal(result.pikkuUserId, undefined)
-    })
-
-    test('setPikkuUserId', async () => {
-      await store.setPikkuUserId('ch-1', 'user-1')
-
-      const result = await store.getChannel('ch-1')
-      assert.equal(result.pikkuUserId, 'user-1')
-    })
-
-    test('setPikkuUserId to null', async () => {
-      await store.setPikkuUserId('ch-1', null)
-
-      const result = await store.getChannel('ch-1')
-      assert.equal(result.pikkuUserId, undefined)
-    })
-
-    test('getChannel throws for missing channel', async () => {
-      await assert.rejects(
-        async () => {
-          await store.getChannel('missing')
-        },
-        { message: 'Channel not found: missing' }
-      )
-    })
-
-    test('removeChannels', async () => {
-      await store.addChannel({
-        channelId: 'ch-2',
-        channelName: 'temp-channel',
-      })
-      await store.removeChannels(['ch-2'])
-      await assert.rejects(async () => {
-        await store.getChannel('ch-2')
-      })
-    })
-
-    test('removeChannels with empty array is no-op', async () => {
-      await store.removeChannels([])
-    })
-
-    test('session round-trip — set / get / clear', async () => {
-      await store.addChannel({
-        channelId: 'ch-state',
-        channelName: 'test-channel',
-      })
-
-      const empty = await store.getState('ch-state')
-      assert.equal(empty, undefined)
-
-      const payload = { userId: 'u-7', meta: { foo: 1 } }
-      await store.setState('ch-state', payload)
-      const got = await store.getState('ch-state')
-      assert.deepEqual(got, payload)
-
-      const next = { userId: 'u-8' }
-      await store.setState('ch-state', next)
-      const got2 = await store.getState('ch-state')
-      assert.deepEqual(got2, next)
-
-      await store.clearState('ch-state')
-      const after = await store.getState('ch-state')
-      assert.equal(after, undefined)
-
-      await store.removeChannels(['ch-state'])
-    })
-  })
-}

package/src/testing/service-tests/credential-service-tests.ts

@@ -1,143 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import type { ServiceTestConfig } from '../service-tests.js'
-
-/** Conformance suite for `credentialService`. Runs only when a backend supplies one. */
-export const defineCredentialServiceTests = (
-  name: string,
-  credentialService: NonNullable<
-    ServiceTestConfig['services']['credentialService']
-  >
-): void => {
-  const factory = credentialService
-  const kek = 'test-key-encryption-key-32chars!'
-
-  describe(`CredentialService [${name}]`, () => {
-    test('set and get (global)', async () => {
-      const service = await factory({ key: kek })
-      await service.set('stripe', { apiKey: 'sk-123' })
-      const result = await service.get<{ apiKey: string }>('stripe')
-      assert.deepEqual(result, { apiKey: 'sk-123' })
-    })
-
-    test('get returns null for missing', async () => {
-      const service = await factory({ key: kek })
-      const result = await service.get('nonexistent')
-      assert.equal(result, null)
-    })
-
-    test('has returns true/false', async () => {
-      const service = await factory({ key: kek })
-      await service.set('exists', { key: 'val' })
-      assert.strictEqual(await service.has('exists'), true)
-      assert.strictEqual(await service.has('nope'), false)
-    })
-
-    test('set upserts existing credential', async () => {
-      const service = await factory({ key: kek })
-      await service.set('upsert', { v: 1 })
-      await service.set('upsert', { v: 2 })
-      const result = await service.get<{ v: number }>('upsert')
-      assert.deepEqual(result, { v: 2 })
-    })
-
-    test('delete removes credential', async () => {
-      const service = await factory({ key: kek })
-      await service.set('to-delete', { bye: true })
-      assert.strictEqual(await service.has('to-delete'), true)
-      await service.delete('to-delete')
-      assert.strictEqual(await service.has('to-delete'), false)
-    })
-
-    test('per-user isolation', async () => {
-      const service = await factory({ key: kek })
-      await service.set('token', { access: 'user1' }, 'user-1')
-      await service.set('token', { access: 'user2' }, 'user-2')
-
-      const u1 = await service.get<{ access: string }>('token', 'user-1')
-      const u2 = await service.get<{ access: string }>('token', 'user-2')
-      assert.deepEqual(u1, { access: 'user1' })
-      assert.deepEqual(u2, { access: 'user2' })
-    })
-
-    test('per-user delete does not affect other users', async () => {
-      const service = await factory({ key: kek })
-      await service.set('cred', { val: 'a' }, 'user-a')
-      await service.set('cred', { val: 'b' }, 'user-b')
-
-      await service.delete('cred', 'user-a')
-      assert.strictEqual(await service.has('cred', 'user-a'), false)
-      assert.strictEqual(await service.has('cred', 'user-b'), true)
-    })
-
-    test('global and per-user are separate', async () => {
-      const service = await factory({ key: kek })
-      await service.set('shared', { scope: 'global' })
-      await service.set('shared', { scope: 'user' }, 'user-1')
-
-      const global = await service.get<{ scope: string }>('shared')
-      const perUser = await service.get<{ scope: string }>('shared', 'user-1')
-      assert.deepEqual(global, { scope: 'global' })
-      assert.deepEqual(perUser, { scope: 'user' })
-    })
-
-    test('getAll returns all credentials for a user', async () => {
-      const service = await factory({ key: kek })
-      await service.set('cred-a', { a: 1 }, 'user-x')
-      await service.set('cred-b', { b: 2 }, 'user-x')
-      await service.set('cred-c', { c: 3 }, 'user-y')
-
-      const all = await service.getAll('user-x')
-      assert.deepEqual(all['cred-a'], { a: 1 })
-      assert.deepEqual(all['cred-b'], { b: 2 })
-      assert.strictEqual(all['cred-c'], undefined)
-    })
-
-    test('getAll returns empty for unknown user', async () => {
-      const service = await factory({ key: kek })
-      const all = await service.getAll('nobody')
-      assert.deepEqual(all, {})
-    })
-
-    test('rotateKEK re-wraps all credentials', async () => {
-      const newKEK = 'new-key-encryption-key-rotated!'
-      const oldService = await factory({ key: kek })
-      await oldService.set('rotate-cred', { important: 'data' }, 'user-r')
-
-      const rotatedService = await factory({
-        key: newKEK,
-        keyVersion: 2,
-        previousKey: kek,
-      })
-
-      const before = await rotatedService.get<{ important: string }>(
-        'rotate-cred',
-        'user-r'
-      )
-      assert.deepEqual(before, { important: 'data' })
-
-      assert.ok(rotatedService.rotateKEK)
-      const count = await rotatedService.rotateKEK!()
-      assert.ok(count > 0)
-
-      const newOnlyService = await factory({
-        key: newKEK,
-        keyVersion: 2,
-      })
-      const after = await newOnlyService.get<{ important: string }>(
-        'rotate-cred',
-        'user-r'
-      )
-      assert.deepEqual(after, { important: 'data' })
-    })
-
-    test('rotateKEK throws without previousKey', async () => {
-      const service = await factory({ key: kek })
-      assert.ok(service.rotateKEK)
-      await assert.rejects(() => service.rotateKEK!(), {
-        message: 'No previousKey configured — nothing to rotate from',
-      })
-    })
-  })
-}

package/src/testing/service-tests/deployment-service-tests.ts

@@ -1,33 +0,0 @@
-import { describe, test, before, after } from 'node:test'
-
-import type { DeploymentService } from '../../services/deployment-service.js'
-import type { ServiceTestConfig } from '../service-tests.js'
-
-/** Conformance suite for `deploymentService`. Runs only when a backend supplies one. */
-export const defineDeploymentServiceTests = (
-  name: string,
-  deploymentService: NonNullable<
-    ServiceTestConfig['services']['deploymentService']
-  >
-): void => {
-  const factory = deploymentService
-  describe(`DeploymentService [${name}]`, () => {
-    let service: DeploymentService & { stop(): Promise<void> }
-
-    before(async () => {
-      service = await factory()
-    })
-
-    after(async () => {
-      await service.stop()
-    })
-
-    test('start registers deployment', async () => {
-      await service.start({
-        deploymentId: 'deploy-1',
-        endpoint: 'http://localhost:3000',
-        functions: ['funcA', 'funcB'],
-      })
-    })
-  })
-}

package/src/testing/service-tests/event-hub-store-tests.ts

@@ -1,48 +0,0 @@
-import { describe, test, before } from 'node:test'
-import assert from 'node:assert/strict'
-
-import type { EventHubStore } from '../../wirings/channel/eventhub-store.js'
-import type { ServiceTestConfig } from '../service-tests.js'
-
-/** Conformance suite for `eventHubStore`. Runs only when a backend supplies one. */
-export const defineEventHubStoreTests = (
-  name: string,
-  eventHubStore: NonNullable<ServiceTestConfig['services']['eventHubStore']>
-): void => {
-  const factory = eventHubStore
-  describe(`EventHubStore [${name}]`, () => {
-    let store: EventHubStore<Record<string, any>>
-
-    before(async () => {
-      store = await factory()
-    })
-
-    test('subscribe and getChannelIdsForTopic', async () => {
-      const result = await store.subscribe('topic-1', 'ch-1')
-      assert.equal(result, true)
-
-      const ids = await store.getChannelIdsForTopic('topic-1')
-      assert.deepEqual(ids, ['ch-1'])
-    })
-
-    test('subscribe duplicate is idempotent', async () => {
-      const result = await store.subscribe('topic-1', 'ch-1')
-      assert.equal(result, true)
-    })
-
-    test('unsubscribe returns true when exists', async () => {
-      const result = await store.unsubscribe('topic-1', 'ch-1')
-      assert.equal(result, true)
-    })
-
-    test('unsubscribe returns false when not exists', async () => {
-      const result = await store.unsubscribe('topic-1', 'ch-1')
-      assert.equal(result, false)
-    })
-
-    test('getChannelIdsForTopic returns empty for unknown topic', async () => {
-      const ids = await store.getChannelIdsForTopic('unknown')
-      assert.deepEqual(ids, [])
-    })
-  })
-}