@pikku/core 0.12.83 → 0.12.86

package/dist/services/file-scenario-run-store.d.ts

@@ -0,0 +1,58 @@
+import type { ScenarioArtifact, ScenarioResult, ScenarioRunRecord, ScenarioRunStore, ScenarioRunSummary } from '../wirings/workflow/scenario-run.types.js';
+/** Counts and duration, derived rather than stored so they cannot disagree. */
+export declare const scenarioRunSummary: (record: ScenarioRunRecord) => ScenarioRunSummary;
+export declare const scenarioArtifactContentType: (path: string) => string;
+export interface FileScenarioRunStoreOptions {
+    /** The directory runs live under — one folder per run, named by its id. */
+    dir: string;
+    /**
+     * How many runs to keep. Older ones are deleted, with their artifacts, as a
+     * new run opens.
+     *
+     * Bounded on purpose: a run with video is megabytes, and an unbounded history
+     * beside a project is a directory nobody notices until it is enormous.
+     */
+    keep?: number;
+}
+/**
+ * Scenario run history as files on disk — the OSS store.
+ *
+ * One folder per run holding its record and everything it filed, which makes a
+ * run a thing you can open, copy, attach to an issue or delete with `rm -rf`.
+ * A hosted project swaps this for a table and an object store; the console
+ * reads the same shapes from either.
+ *
+ * Writes are serialised through one chain. Scenarios finish one at a time, but
+ * `recordScenario` is read-modify-write on a single file, and a store that
+ * corrupts its own history the first time two things overlap is worse than no
+ * history.
+ */
+export declare class FileScenarioRunStore implements ScenarioRunStore {
+    private readonly options;
+    private writes;
+    constructor(options: FileScenarioRunStoreOptions);
+    start(record: ScenarioRunRecord): Promise<void>;
+    recordScenario(runId: string, result: ScenarioResult): Promise<void>;
+    attachArtifacts(runId: string, artifacts: ScenarioArtifact[]): Promise<void>;
+    finish(runId: string, outcome: Pick<ScenarioRunRecord, 'status' | 'finishedAt' | 'skipped' | 'hookFailures'>): Promise<void>;
+    readArtifact(runId: string, path: string): Promise<{
+        body: Uint8Array<ArrayBuffer>;
+        contentType: string;
+    } | undefined>;
+    list(options?: {
+        limit?: number;
+    }): Promise<ScenarioRunSummary[]>;
+    get(runId: string): Promise<ScenarioRunRecord | undefined>;
+    remove(runId: string): Promise<void>;
+    /** Where this run's artifacts live, for a driver writing into it. */
+    runDir(runId: string): string;
+    private serialise;
+    private read;
+    private write;
+    private runIds;
+    /**
+     * Drop the oldest runs past the limit, never the one just opened — a `keep`
+     * of zero or one must still leave the run being started.
+     */
+    private prune;
+}

package/dist/services/file-scenario-run-store.js

@@ -0,0 +1,214 @@
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+/** The record, beside the images and footage the same run produced. */
+const RECORD_FILE = 'run.json';
+/**
+ * A run id is a path segment, and `get('../../etc')` is a file read.
+ *
+ * Ids are generated here, so anything failing this arrived from outside and is
+ * refused rather than sanitised — a request for a run that cannot exist is a
+ * request for a run that does not exist.
+ */
+const SAFE_RUN_ID = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+/** Counts and duration, derived rather than stored so they cannot disagree. */
+export const scenarioRunSummary = (record) => ({
+    runId: record.runId,
+    environment: record.environment,
+    surface: record.surface,
+    status: record.status,
+    startedAt: record.startedAt,
+    finishedAt: record.finishedAt,
+    durationMs: record.finishedAt
+        ? new Date(record.finishedAt).getTime() -
+            new Date(record.startedAt).getTime()
+        : undefined,
+    passed: record.results.filter((r) => r.status === 'passed').length,
+    failed: record.results.filter((r) => r.status === 'failed').length,
+    skipped: record.skipped.length,
+    artifacts: record.results.reduce((total, result) => total + (result.artifacts?.length ?? 0), 0),
+});
+/**
+ * What a scenario artifact is served as.
+ *
+ * A short, closed list rather than a MIME database: a run produces images and
+ * recordings and nothing else, and anything unrecognised is served as bytes the
+ * browser is told not to interpret.
+ */
+const CONTENT_TYPES = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    webp: 'image/webp',
+    mp4: 'video/mp4',
+    webm: 'video/webm',
+};
+export const scenarioArtifactContentType = (path) => CONTENT_TYPES[path.split('.').pop()?.toLowerCase() ?? ''] ??
+    'application/octet-stream';
+/**
+ * An artifact path is a content key from the record, but it arrives from a
+ * client and is joined onto a directory. Anything that could climb out of the
+ * run, or name something other than a file inside it, is refused.
+ */
+const SAFE_ARTIFACT_PATH = /^[A-Za-z0-9][A-Za-z0-9._-]*(\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/;
+const DEFAULT_KEEP = 20;
+/**
+ * Scenario run history as files on disk — the OSS store.
+ *
+ * One folder per run holding its record and everything it filed, which makes a
+ * run a thing you can open, copy, attach to an issue or delete with `rm -rf`.
+ * A hosted project swaps this for a table and an object store; the console
+ * reads the same shapes from either.
+ *
+ * Writes are serialised through one chain. Scenarios finish one at a time, but
+ * `recordScenario` is read-modify-write on a single file, and a store that
+ * corrupts its own history the first time two things overlap is worse than no
+ * history.
+ */
+export class FileScenarioRunStore {
+    options;
+    writes = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+    }
+    async start(record) {
+        await this.serialise(async () => {
+            await this.write(record);
+            await this.prune(record.runId);
+        });
+    }
+    async recordScenario(runId, result) {
+        await this.serialise(async () => {
+            const record = await this.read(runId);
+            if (!record) {
+                return;
+            }
+            record.results.push(result);
+            await this.write(record);
+        });
+    }
+    async attachArtifacts(runId, artifacts) {
+        if (artifacts.length === 0) {
+            return;
+        }
+        await this.serialise(async () => {
+            const record = await this.read(runId);
+            if (!record) {
+                return;
+            }
+            for (const artifact of artifacts) {
+                const result = record.results.find((candidate) => candidate.name === artifact.scenario);
+                // An artifact whose scenario is not in the results belongs to a
+                // scenario that never produced one — it is dropped rather than filed
+                // under a run-level bucket nothing renders.
+                if (result) {
+                    result.artifacts = [...(result.artifacts ?? []), artifact];
+                }
+            }
+            await this.write(record);
+        });
+    }
+    async finish(runId, outcome) {
+        await this.serialise(async () => {
+            const record = await this.read(runId);
+            if (!record) {
+                return;
+            }
+            await this.write({ ...record, ...outcome });
+        });
+    }
+    async readArtifact(runId, path) {
+        if (!SAFE_RUN_ID.test(runId) || !SAFE_ARTIFACT_PATH.test(path)) {
+            return undefined;
+        }
+        try {
+            const file = await readFile(join(this.options.dir, runId, ...path.split('/')));
+            return {
+                body: new Uint8Array(file),
+                contentType: scenarioArtifactContentType(path),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async list(options = {}) {
+        const summaries = [];
+        for (const runId of await this.runIds()) {
+            const record = await this.read(runId);
+            if (record) {
+                summaries.push(scenarioRunSummary(record));
+            }
+        }
+        summaries.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+        return options.limit ? summaries.slice(0, options.limit) : summaries;
+    }
+    async get(runId) {
+        return this.read(runId);
+    }
+    async remove(runId) {
+        if (!SAFE_RUN_ID.test(runId)) {
+            return;
+        }
+        await rm(join(this.options.dir, runId), { recursive: true, force: true });
+    }
+    /** Where this run's artifacts live, for a driver writing into it. */
+    runDir(runId) {
+        return join(this.options.dir, runId);
+    }
+    serialise(work) {
+        const next = this.writes.then(work, work);
+        // Swallowed on the CHAIN only, so one failed write does not reject every
+        // later one; the caller still sees its own rejection through `next`.
+        this.writes = next.catch(() => { });
+        return next;
+    }
+    async read(runId) {
+        if (!SAFE_RUN_ID.test(runId)) {
+            return undefined;
+        }
+        try {
+            const raw = await readFile(join(this.options.dir, runId, RECORD_FILE), 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            // A folder with artifacts but no readable record is a run that was killed
+            // mid-write. It is not listable, and it is not an error either.
+            return undefined;
+        }
+    }
+    async write(record) {
+        const dir = join(this.options.dir, record.runId);
+        await mkdir(dir, { recursive: true });
+        await writeFile(join(dir, RECORD_FILE), JSON.stringify(record, null, 2) + '\n');
+    }
+    async runIds() {
+        try {
+            const entries = await readdir(this.options.dir, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isDirectory() && SAFE_RUN_ID.test(entry.name))
+                .map((entry) => entry.name);
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Drop the oldest runs past the limit, never the one just opened — a `keep`
+     * of zero or one must still leave the run being started.
+     */
+    async prune(keeping) {
+        const keep = this.options.keep ?? DEFAULT_KEEP;
+        const dated = [];
+        for (const runId of await this.runIds()) {
+            if (runId === keeping) {
+                continue;
+            }
+            const record = await this.read(runId);
+            dated.push({ runId, startedAt: record?.startedAt ?? '' });
+        }
+        dated.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+        for (const { runId } of dated.slice(Math.max(keep - 1, 0))) {
+            await rm(join(this.options.dir, runId), { recursive: true, force: true });
+        }
+    }
+}

package/dist/services/http-personas.d.ts

@@ -24,7 +24,7 @@ export interface HttpPersonasConfig {
     /**
      * Default model a persona thinks with when `converse(...)` is called without
      * an explicit `model`. Its own turns/approvals/evaluation run in-process via
-     * the configured `aiAgentRunner`.
+     * the configured `agentRunner`.
      */
     model?: string;
 }

package/dist/services/http-personas.js

@@ -53,8 +53,8 @@ export class HttpPersona {
         return readScenarioHttpResponse(res);
     }
     async converse(options) {
-        const { aiAgentRunner } = getSingletonServices();
-        if (!aiAgentRunner) {
+        const { agentRunner } = getSingletonServices();
+        if (!agentRunner) {
             throw new AIProviderNotConfiguredError();
         }
         const model = options.model ?? this.config.model;
@@ -72,7 +72,7 @@ export class HttpPersona {
             approvals: options.approvals,
             model,
             maxTurns: options.maxTurns,
-            llm: (params) => aiAgentRunner.run(params),
+            llm: (params) => agentRunner.run(params),
             target: {
                 run: (message) => this.agentRun(options.agent, message, threadId, resourceId),
                 approve: (runId, decisions) => this.agentApprove(options.agent, runId, decisions),

package/dist/services/{in-memory-ai-run-state-service.d.ts → in-memory-agent-run-state-service.d.ts}

@@ -1,7 +1,7 @@
-import type { AIRunStateService, CreateRunInput, SaveScoreInput } from './ai-run-state-service.js';
-import type { AgentRunState, PendingApproval } from '../wirings/ai-agent/ai-agent.types.js';
-import type { AIRunScore } from '../wirings/ai-scorer/ai-scorer.types.js';
-export declare class InMemoryAIRunStateService implements AIRunStateService {
+import type { AgentRunStateService, CreateRunInput, SaveScoreInput } from './agent-run-state-service.js';
+import type { AgentRunState, PendingApproval } from '../wirings/agent/agent.types.js';
+import type { AgentRunScore } from '../wirings/agent-scorer/agent-scorer.types.js';
+export declare class InMemoryAgentRunStateService implements AgentRunStateService {
     private runs;
     private scores;
     private counter;
@@ -15,5 +15,5 @@ export declare class InMemoryAIRunStateService implements AIRunStateService {
         approval: PendingApproval;
     } | null>;
     saveScore(score: SaveScoreInput): Promise<void>;
-    getScores(runId: string): Promise<AIRunScore[]>;
+    getScores(runId: string): Promise<AgentRunScore[]>;
 }

package/dist/services/{in-memory-ai-run-state-service.js → in-memory-agent-run-state-service.js}

@@ -1,4 +1,4 @@
-export class InMemoryAIRunStateService {
+export class InMemoryAgentRunStateService {
     runs = new Map();
     scores = new Map();
     counter = 0;

package/dist/services/in-memory-workflow-service.d.ts

@@ -1,5 +1,5 @@
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js';
-import type { SerializedError } from '../types/core.types.js';
+import type { SerializedError } from '../errors/serialized-error.js';
 import type { WorkflowPlannedStep, WorkflowQueueOptions, WorkflowRun, WorkflowRunService, WorkflowRunWire, StepState, StepStatus, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
 export declare class InMemoryWorkflowService extends PikkuWorkflowService implements WorkflowRunService {
     constructor(options?: WorkflowQueueOptions);

package/dist/services/index.d.ts

@@ -14,8 +14,9 @@ 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 { FileScenarioRunStore, scenarioArtifactContentType, scenarioRunSummary, type FileScenarioRunStoreOptions, } from './file-scenario-run-store.js';
 export type { ContentService, SignContentKeyArgs, SignURLArgs, GetUploadURLArgs, UploadURLResult, BucketKeyArgs, WriteFileArgs, CopyFileArgs, } from './content-service.js';
 export type { ScenarioPersona, ResolvedPersona, ScenarioPersonas, } from './personas-service.js';
 export type { JWTService } from './jwt-service.js';
@@ -26,14 +27,15 @@ export type { SecretService, SecretValues } from './secret-service.js';
 export type { VariablesService } from './variables-service.js';
 export type { SchemaService } from './schema-service.js';
 export type { SessionService } from './user-session-service.js';
-export type { ScheduledTaskSummary, ScheduledTaskInfo, SchedulerService, } from './scheduler-service.js';
+export type { ScheduledTaskSummary, ScheduledTaskInfo, } from './scheduler-service.js';
+export { SchedulerService } from './scheduler-service.js';
 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';
@@ -50,3 +52,5 @@ export type { MCPMeta, RPCMetaRecord, ServiceMeta, ServicesMetaRecord, Middlewar
 export type { CoverageService, ScriptCoverage, FunctionCoverageEntry, FunctionCoverageReport, CoverageFunctionMeta, } from './v8-coverage-service.js';
 export { StubTracker, createStubProxy, getStubTracker, isTestRun, stub, spy, type StubCall, } from './stub-tracker.js';
 export { SecretHostNotAllowedError, assertSecretAllowedForHost, } from './secret-host-binding.js';
+export type { AuditFacets, AuditQuery, AuditQueryResult, } from './audit-service.js';
+export { SecretAccessDeniedError, withoutSecrets } from './secretless.js';

package/dist/services/index.js

@@ -14,11 +14,14 @@ 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 { FileScenarioRunStore, scenarioArtifactContentType, scenarioRunSummary, } from './file-scenario-run-store.js';
 export { DEFAULT_WEBHOOK_RETRIES, PIKKU_OUTGOING_WEBHOOK_QUEUE_NAME, WebhookService, } from './webhook-service.js';
+export { SchedulerService } from './scheduler-service.js';
 export { TypedCredentialService } from './typed-credential-service.js';
 export { NoopAuditService, createInvocationAudit } from './audit-service.js';
 export { InMemorySessionStore } from './in-memory-session-store.js';
 export { StubTracker, createStubProxy, getStubTracker, isTestRun, stub, spy, } from './stub-tracker.js';
 export { SecretHostNotAllowedError, assertSecretAllowedForHost, } from './secret-host-binding.js';
+export { SecretAccessDeniedError, withoutSecrets } from './secretless.js';

package/dist/services/local-secrets.d.ts

@@ -1,4 +1,4 @@
-import { type SecretValue } from '../secret-value.js';
+import { type SecretValue } from '../classification/secret-value.js';
 import type { SecretService, SecretValues } from './secret-service.js';
 import type { VariablesService } from './variables-service.js';
 export declare class LocalSecretService implements SecretService {

package/dist/services/local-secrets.js

@@ -1,4 +1,4 @@
-import { createSecretValue, isSecretValue, } from '../secret-value.js';
+import { createSecretValue, isSecretValue, } from '../classification/secret-value.js';
 import { LocalVariablesService } from './local-variables.js';
 export class LocalSecretService {
     variables;

package/dist/services/logger.d.ts

@@ -1,11 +1,11 @@
-import type { Safe } from '../secret-value.js';
+import type { Safe } from '../classification/secret-value.js';
 export declare enum LogLevel {
-    'trace' = 0,
-    'debug' = 1,
-    'info' = 2,
-    'warn' = 3,
-    'error' = 4,
-    'critical' = 5
+    trace = 0,
+    debug = 1,
+    info = 2,
+    warn = 3,
+    error = 4,
+    critical = 5
 }
 /**
  * A log line is the easiest place to leak a vault secret, so every parameter is

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

@@ -13,12 +13,13 @@ import type { TriggerMeta, TriggerSourceMeta } from '../wirings/trigger/trigger.
 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 { FunctionMeta, FunctionsMeta, PermissionMetadata } from '../function/function-meta.types.js';
+import type { MiddlewareMetadata } from '../middleware/middleware.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/services/scoped-secret-service.d.ts

@@ -1,4 +1,4 @@
-import type { SecretValue } from '../secret-value.js';
+import type { SecretValue } from '../classification/secret-value.js';
 import type { SecretService, SecretValues } from './secret-service.js';
 export declare class ScopedSecretService implements SecretService {
     private secrets;

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

@@ -1,4 +1,4 @@
-import type { SecretValue } from '../secret-value.js';
+import type { SecretValue } from '../classification/secret-value.js';
 /** A record of secrets, each still wrapped. */
 export type SecretValues<T> = {
     [K in keyof T]: SecretValue<T[K]>;

package/dist/services/typed-secret-service.d.ts

@@ -1,5 +1,13 @@
-import type { SecretValue } from '../secret-value.js';
+import type { SecretValue } from '../classification/secret-value.js';
 import type { SecretService, SecretValues } from './secret-service.js';
+/**
+ * The wrapper, or `undefined` when the generated map declares the key as an
+ * optional property. The `undefined` has to be lifted OUT of `SecretValue` —
+ * a missing optional secret resolves to `undefined` itself, not to a wrapper
+ * around it, so `SecretValue<T | undefined>` would type a value that never
+ * exists and hide the `undefined` behind a `.reveal()` the caller never reaches.
+ */
+export type SecretResult<T> = undefined extends T ? SecretValue<Exclude<T, undefined>> | undefined : SecretValue<T>;
 export interface CredentialStatus {
     secretId: string;
     name: string;
@@ -12,6 +20,12 @@ export interface CredentialStatus {
 export type CredentialMeta = {
     name: string;
     displayName: string;
+    /**
+     * Declared `optional: true`, so absence is a supported state rather than a
+     * misconfiguration. The generated map types the key as an optional property,
+     * which is what puts `undefined` in `getSecret`'s return type.
+     */
+    optional?: boolean;
     oauth2?: {
         tokenSecretId: string;
     };
@@ -21,7 +35,7 @@ export declare class TypedSecretService<TMap = Record<string, unknown>> implemen
     private credentialsMeta;
     private cache;
     constructor(secrets: SecretService, credentialsMeta: Record<string, CredentialMeta>);
-    getSecret<K extends keyof TMap & string>(key: K): Promise<SecretValue<TMap[K]>>;
+    getSecret<K extends keyof TMap & string>(key: K): Promise<SecretResult<TMap[K]>>;
     getSecret<T = string>(key: string): Promise<SecretValue<T>>;
     hasSecret(key: string): Promise<boolean>;
     setSecret<K extends string>(key: K, value: K extends keyof TMap ? TMap[K] : unknown): Promise<void>;

package/dist/services/typed-secret-service.js

@@ -11,6 +11,11 @@ export class TypedSecretService {
         if (this.cache.has(key)) {
             return this.cache.get(key);
         }
+        if (this.credentialsMeta[key]?.optional &&
+            !(await this.secrets.hasSecret(key))) {
+            this.cache.set(key, undefined);
+            return undefined;
+        }
         const value = await this.secrets.getSecret(key);
         this.cache.set(key, value);
         return value;

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

@@ -1,4 +1,4 @@
-import type { Safe } from '../secret-value.js';
+import type { Safe } from '../classification/secret-value.js';
 export interface SendWebhookInput {
     url: string;
     /** Sent as the `X-Pikku-Event` header. */

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

@@ -1,4 +1,5 @@
-import type { CoreUserSession, SerializedError } from '../types/core.types.js';
+import type { CoreUserSession } from '../types/core.types.js';
+import type { SerializedError } from '../errors/serialized-error.js';
 import type { WorkflowRun, WorkflowPlannedStep, WorkflowRunWire, WorkflowRunStatus, StepState, WorkflowStatus, WorkflowVersionStatus } from '../wirings/workflow/workflow.types.js';
 import type { RunTimeline, ReconstructedRunState } from '../wirings/workflow/run-timeline.js';
 export interface WorkflowService {

package/dist/testing/index.d.ts

@@ -1,2 +1,3 @@
 export { defineServiceTests } from './service-tests.js';
 export type { ServiceTestConfig } from './service-tests.js';
+export { clearPikkuRuntimeState } from '../test-utils.js';

package/dist/testing/index.js

@@ -1 +1,2 @@
 export { defineServiceTests } from './service-tests.js';
+export { clearPikkuRuntimeState } from '../test-utils.js';

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/{ai-storage-service-tests.js → agent-storage-service-tests.js}

@@ -1,9 +1,9 @@
 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}]`, () => {
+/** 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();

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);