@pikku/core 0.12.78 → 0.12.80

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

@@ -0,0 +1,226 @@
+import { describe, test, before } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `aiStorageService`. Runs only when a backend supplies one. */
+export const defineAiStorageServiceTests = (name, aiStorageService) => {
+    const factory = aiStorageService;
+    describe(`AIStorageService [${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('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/channel-store-tests.d.ts

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

package/dist/testing/service-tests/channel-store-tests.js

@@ -0,0 +1,72 @@
+import { describe, test, before } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `channelStore`. Runs only when a backend supplies one. */
+export const defineChannelStoreTests = (name, channelStore) => {
+    const factory = channelStore;
+    describe(`ChannelStore [${name}]`, () => {
+        let store;
+        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/dist/testing/service-tests/credential-service-tests.d.ts

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

package/dist/testing/service-tests/credential-service-tests.js

@@ -0,0 +1,109 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `credentialService`. Runs only when a backend supplies one. */
+export const defineCredentialServiceTests = (name, credentialService) => {
+    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('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('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('token', 'user-1');
+            const u2 = await service.get('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('shared');
+            const perUser = await service.get('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('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('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/dist/testing/service-tests/deployment-service-tests.d.ts

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

package/dist/testing/service-tests/deployment-service-tests.js

@@ -0,0 +1,21 @@
+import { describe, test, before, after } from 'node:test';
+/** Conformance suite for `deploymentService`. Runs only when a backend supplies one. */
+export const defineDeploymentServiceTests = (name, deploymentService) => {
+    const factory = deploymentService;
+    describe(`DeploymentService [${name}]`, () => {
+        let service;
+        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/dist/testing/service-tests/event-hub-store-tests.d.ts

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

package/dist/testing/service-tests/event-hub-store-tests.js

@@ -0,0 +1,34 @@
+import { describe, test, before } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `eventHubStore`. Runs only when a backend supplies one. */
+export const defineEventHubStoreTests = (name, eventHubStore) => {
+    const factory = eventHubStore;
+    describe(`EventHubStore [${name}]`, () => {
+        let store;
+        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, []);
+        });
+    });
+};

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

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

package/dist/testing/service-tests/secret-service-tests.js

@@ -0,0 +1,80 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `secretService`. Runs only when a backend supplies one. */
+export const defineSecretServiceTests = (name, secretService) => {
+    const factory = secretService;
+    const kek = 'test-key-encryption-key-32chars!';
+    describe(`SecretService [${name}]`, () => {
+        test('setSecret and getSecret', async () => {
+            const service = await factory({ key: kek });
+            await service.setSecret('api-key', {
+                token: 'sk-123',
+                endpoint: 'https://api.example.com',
+            });
+            const result = await service.getSecret('api-key');
+            assert.deepEqual(result.reveal(), {
+                token: 'sk-123',
+                endpoint: 'https://api.example.com',
+            });
+        });
+        test('getSecret wraps the raw string rather than returning it', async () => {
+            const service = await factory({ key: kek });
+            await service.setSecret('string-secret', 'plain-value');
+            const result = await service.getSecret('string-secret');
+            assert.strictEqual(result.reveal(), 'plain-value');
+        });
+        test('hasSecret returns true/false', async () => {
+            const service = await factory({ key: kek });
+            assert.strictEqual(await service.hasSecret('api-key'), true);
+            assert.strictEqual(await service.hasSecret('nonexistent'), false);
+        });
+        test('getSecret throws for missing key', async () => {
+            const service = await factory({ key: kek });
+            await assert.rejects(() => service.getSecret('nonexistent'), {
+                message: 'Requested secret not found',
+            });
+        });
+        test('setSecret upserts existing key', async () => {
+            const service = await factory({ key: kek });
+            await service.setSecret('upsert-key', { v: 1 });
+            await service.setSecret('upsert-key', { v: 2 });
+            const result = await service.getSecret('upsert-key');
+            assert.deepEqual(result.reveal(), { v: 2 });
+        });
+        test('deleteSecret removes the key', async () => {
+            const service = await factory({ key: kek });
+            await service.setSecret('to-delete', 'bye');
+            assert.strictEqual(await service.hasSecret('to-delete'), true);
+            await service.deleteSecret('to-delete');
+            assert.strictEqual(await service.hasSecret('to-delete'), false);
+        });
+        test('rotateKEK re-wraps all secrets', async () => {
+            const newKEK = 'new-key-encryption-key-rotated!';
+            const oldService = await factory({ key: kek });
+            await oldService.setSecret('rotate-test', { important: 'data' });
+            const rotatedService = await factory({
+                key: newKEK,
+                keyVersion: 2,
+                previousKey: kek,
+            });
+            const before = await rotatedService.getSecret('rotate-test');
+            assert.deepEqual(before.reveal(), { 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.getSecret('rotate-test');
+            assert.deepEqual(after.reveal(), { 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/dist/testing/service-tests/session-store-tests.d.ts

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

package/dist/testing/service-tests/session-store-tests.js

@@ -0,0 +1,43 @@
+import { describe, test, before } from 'node:test';
+import assert from 'node:assert/strict';
+/** Conformance suite for `sessionStore`. Runs only when a backend supplies one. */
+export const defineSessionStoreTests = (name, sessionStore) => {
+    const factory = sessionStore;
+    describe(`SessionStore [${name}]`, () => {
+        let store;
+        before(async () => {
+            store = await factory();
+        });
+        test('get returns undefined for unknown user', async () => {
+            const result = await store.get('unknown-user');
+            assert.equal(result, undefined);
+        });
+        test('set and get round-trip', async () => {
+            const session = {
+                userId: 'user-1',
+                organizationId: 'org-1',
+            };
+            await store.set('user-1', session);
+            const result = await store.get('user-1');
+            assert.deepEqual(result, session);
+        });
+        test('set overwrites previous session', async () => {
+            const asAdmin = { userId: 'user-2', role: 'admin' };
+            const asMember = { userId: 'user-2', role: 'member' };
+            await store.set('user-2', asAdmin);
+            await store.set('user-2', asMember);
+            const result = await store.get('user-2');
+            assert.deepEqual(result, { userId: 'user-2', role: 'member' });
+        });
+        test('clear removes session', async () => {
+            await store.set('user-3', { userId: 'user-3' });
+            assert.ok(await store.get('user-3'));
+            await store.clear('user-3');
+            const result = await store.get('user-3');
+            assert.equal(result, undefined);
+        });
+        test('clear is no-op for unknown user', async () => {
+            await store.clear('nonexistent');
+        });
+    });
+};

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

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