@pikku/kysely 0.13.15 → 0.13.18

package/CHANGELOG.md

@@ -1,3 +1,232 @@
+## 0.13.18
+
+### Patch Changes
+
+- 746ed6a: fix: one coercion plugin, not three
+
+  The Kysely coercion plugin existed in three copies — the CLI's local database,
+  `@pikku/kysely-node-sqlite` and `@pikku/kysely-bun-sqlite` — and all three had
+  drifted apart. Only the CLI's resolved a column against the tables the query
+  actually named, so two tables that disagree on the kind of a same-named column
+  coerced correctly in local development and silently did not at runtime; only
+  bun's dropped a genuinely ambiguous column instead of letting the last table
+  processed win.
+
+  The single implementation now lives in `@pikku/kysely`, which all three already
+  depended on, and keeps both behaviours: table-qualified resolution first, an
+  ambiguity-safe bare-name fallback second.
+
+  `ColumnKind` — the value type of the generated `coercion.gen.ts` — is
+  `'date' | 'bool' | 'json'`. The CLI's fourth member, `uuid`, was never a
+  coercion kind: the codegen excludes it from the map by construction, because a
+  UUID is a string in both Postgres and SQLite. It is now `AnnotationKind` in the
+  CLI, the union a column may declare in `db/annotations.ts`, of which
+  `ColumnKind` is the coercible subset.
+
+  `@pikku/cli` also drops its unused dependency on the Node-only
+  `@pikku/kysely-node-sqlite`.
+
+- Updated dependencies [5a1a962]
+  - @pikku/core@0.12.86
+
+## 0.13.17
+
+### Patch Changes
+
+- 266e3bc: One door per name: `@pikku/core/ecosystem/*` and the package root are gone
+
+  `@pikku/core` published every module twice. `ecosystem/http` re-exported
+  `./http`, `ecosystem/services` re-exported `./services`, and a name was
+  reachable through either — so every addition had to be made in two places, and a
+  consumer's import said nothing about what it actually used. The package root was
+  the same problem at a larger scale: a single barrel of 206 names that no bundler
+  could take apart, and the one specifier that revealed nothing at all.
+
+  Both are deleted. Every name now lives on the subpath that owns it, and every
+  import carries that subpath — `@pikku/core/http`, `@pikku/core/services`,
+  `@pikku/core/errors`, `@pikku/core/types`.
+
+  Deleting the facades meant the raw subpaths had to become a superset of them,
+  which they were not: the facade tree had accumulated 25 names with no raw home
+  and about 26 more filed under a different area than the module they came from.
+  Those names moved to the area that owns them, and three areas were published as
+  new entry points rather than left on a root that is going away — `./types` (the
+  shared type surface, the largest single destination), `./state` and
+  `./classification`.
+
+  `./classification` is one door onto one subject: what a value is and how it must
+  be handled. Its three halves would each have been an entry point — the brands
+  and manifest types, the stored-form helpers (`hashToken`, `unsafeAsSealed` and
+  friends), and `SecretValue` — split by whether a name happens to be a type or a
+  value, which is the same defect as the facades. The duration and versioned-id
+  helpers went to `./utils`, which already published, and `PikkuRequest` went to
+  `./function`: it is the transport-agnostic request base, not an HTTP one — HTTP
+  has `PikkuHTTPAbstractRequest`, and the only thing outside core that extends
+  `PikkuRequest` is Azure's timer request.
+
+  `./types` inherited the root barrel's habit before it inherited its contents, so
+  the names with an owner elsewhere were moved off it. The middleware types and the
+  five middleware factories — `pikkuMiddleware`, `pikkuMiddlewareFactory`,
+  `pikkuChannelMiddleware`, `pikkuChannelMiddlewareFactory` and
+  `pikkuAgentMiddleware`, runtime values on a types entry point — are now
+  `@pikku/core/middleware`; the function meta types are `@pikku/core/function`;
+  `SerializedError` is `@pikku/core/errors`; and the generic TypeScript helpers
+  (`MakeRequired`, `PickRequired`, `PickOptional`, `RequireAtLeastOne`,
+  `JSONPrimitive`, `JSONValue`) are `@pikku/core/utils`. What is left on `./types`
+  is the vocabulary the wirings share, which no single module owns.
+
+  `pikku` was itself a root barrel — `export * from '@pikku/core'` — and
+  now exports only the services it bundles.
+
+  One module survives at the old specifier, and only for the bootstrap:
+  `packages/cli` is generated by the _published_ CLI pinned in its `build.sh`, and
+  that CLI still writes a bare `@pikku/core` into the files it generates for the
+  CLI itself. `bootstrap-compat/root.ts` carries the eight types it names, a test
+  in core fails if that list grows, and it goes when the pin moves to a CLI
+  released from this branch. The adapter names the pinned CLI reaches for —
+  `pikkuState` and `CreateWireServices` — are rewritten to `@pikku/core/state` and
+  `@pikku/core/types` by the same `build.sh` patch pass, so no second shim is
+  needed for them.
+
+  A guard test keeps the root shut: it parses imports and rejects a bare
+  `@pikku/core` rather than grepping for it, because several tests hold a user's
+  file as a template literal, where `import … from '@pikku/core'` is fixture text
+  rather than an import this repo makes.
+
+  An agent scaffold a project generated under an older CLI is refreshed rather
+  than left to fail: `pikku all` already deleted one importing an entry point
+  `@pikku/core` no longer publishes, and the `#pikku` hub joins that list.
+  Without it a project that scaffolds the agent endpoint but
+  declares no agents keeps the old file forever — the generator that would rewrite
+  it only runs when agents exist, and the file being present is what stops it
+  being regenerated as missing.
+
+  `pikku new addon` also wrote a tsconfig `paths` map naming only the deleted hub.
+  An addon's `imports` map points into `dist`, so `paths` is what resolves
+  `#pikku/<leaf>` for the addon's own source build — it now names the two leaf
+  patterns, in both the addon and its test harness.
+
+- 786dae5: Bump every dependency whose latest release is a major across the monorepo, and
+  port the code the majors broke: `cookie` 2's `parseCookie`/`stringifySetCookie`
+  API in `@pikku/core` and the three runtime HTTP adapters, and assistant-ui 0.15's
+  store client in `@pikku/assistant-ui`.
+- 6eef0a0: Bump every dependency to its latest compatible minor/patch across the monorepo.
+- Updated dependencies [7722ceb]
+- Updated dependencies [375c1ff]
+- Updated dependencies [02a70cd]
+- Updated dependencies [aeef159]
+- Updated dependencies [a281de6]
+- Updated dependencies [266e3bc]
+- Updated dependencies [02a70cd]
+- Updated dependencies [786dae5]
+- Updated dependencies [6eef0a0]
+- Updated dependencies [3561d67]
+- Updated dependencies [a91c433]
+- Updated dependencies [02a70cd]
+- Updated dependencies [9537f74]
+- Updated dependencies [2b57ca8]
+- Updated dependencies [266e3bc]
+- Updated dependencies [9fce0f1]
+- Updated dependencies [83683a0]
+- Updated dependencies [456c88b]
+- Updated dependencies [456c88b]
+- Updated dependencies [c127273]
+  - @pikku/core@0.12.85
+
+## 0.13.16
+
+### Patch Changes
+
+- 7406bfe: Rename the agent runtime from `AI*` to `Agent*` (#596)
+
+  `AI` described the model provider, not the thing being named. Every symbol that
+  belongs to the agent runtime now says `Agent`; the symbols that genuinely wrap a
+  model provider — `AIEmbeddingService`, `AIProviderOptions`, `AIEmbedParams`,
+  `AITranscriptionParams`, `AIGenerateImageParams` and their siblings, and the
+  `@pikku/ai-vercel` / `@pikku/ai-deepinfra` / `@pikku/ai-voice` packages — keep
+  their names.
+
+  **Wiring**
+  - `pikkuAIAgent` → `pikkuAgent`, `pikkuAIScorer` → `pikkuAgentScorer`,
+    `pikkuAIJudge` → `pikkuAgentJudge`
+  - `CoreAIAgent` → `CoreAgent`, `AIAgentInput` → `AgentInput`, `AIAgentStep` →
+    `AgentStep`, `AIMessage` → `AgentMessage`, and the rest of the agent types
+  - `AIAgentRunnerService` → `AgentRunnerService`, `AIStorageService` →
+    `AgentStorageService`, `AIRunStateService` → `AgentRunStateService`
+
+  **Entry points**
+
+  `@pikku/core/agent` → `@pikku/core/agent`, `@pikku/core/agent-scorer` →
+  `@pikku/core/agent-scorer`.
+
+  **Queues**
+
+  The scorer queues are now `agent-score-fast` and `agent-score-slow`. Drain the
+  old `ai-score-fast` / `ai-score-slow` queues before deploying — jobs still
+  sitting on them when the new workers start will never be picked up.
+
+  **Scaffolds**
+
+  The agent scaffold pikku wrote for your project — `<scaffold>/agent/agent.gen.ts`
+  and its schemas file — imports `@pikku/core/ai-agent`, which no longer exists. A
+  scaffold is normally written once and then left alone, so `pikku all` would find
+  it present and leave the broken import in place. It now deletes an agent scaffold
+  importing either removed entry point and regenerates it in the same run. Anything
+  you added to that file goes with it, so move local edits out first.
+
+  **Database**
+
+  The agent tables are renamed: `ai_threads`, `ai_message`, `ai_tool_call`,
+  `ai_working_memory`, `ai_run` and `ai_run_score` become `agent_threads`,
+  `agent_message`, `agent_tool_call`, `agent_working_memory`, `agent_run` and
+  `agent_run_score`, along with their indexes and the `ai_working_memory_pk`
+  constraint. The same rename applies to the MongoDB collections.
+
+  `ensurePikkuSchema` creates tables it cannot find, so an existing database will
+  get empty `agent_*` tables and leave the old data stranded in `ai_*`. Rename
+  them before the first boot on the new version:
+
+  ```sql
+  ALTER TABLE ai_threads        RENAME TO agent_threads;
+  ALTER TABLE ai_message        RENAME TO agent_message;
+  ALTER TABLE ai_tool_call      RENAME TO agent_tool_call;
+  ALTER TABLE ai_working_memory RENAME TO agent_working_memory;
+  ALTER TABLE ai_run            RENAME TO agent_run;
+  ALTER TABLE ai_run_score      RENAME TO agent_run_score;
+  ```
+
+- 6794681: Publish the ecosystem surface as per-area sub-barrels under `@pikku/core/ecosystem/*`, and point generated code, the CLI, the inspector and the runtime adapters at them.
+
+  348 names that only generated code, the toolchain or a runtime adapter ever imports now have a second home on `@pikku/core/ecosystem/<area>` — one sub-barrel per area, matching how core already publishes its entrypoints, so no single barrel grows without bound and a consumer only pulls in the area it uses.
+
+  This step is additive: every name is still exported from the entrypoint it was published from before, so nothing downstream breaks. Removing them from the app-facing barrels is a later change, and needs a release carrying `./ecosystem/*` first.
+
+- a7fcd2e: Declare dependencies that were imported but missing from `package.json`
+
+  `@pikku/openapi-parser` and `@pikku/better-auth` imported `zod`, `@pikku/next`
+  imported `path-to-regexp`, `@pikku/cli` imported `kysely`, and
+  `@pikku/assistant-ui` imported `rxjs`, none of which were declared. Each
+  resolved through Yarn hoisting inside the monorepo and would fail for anyone
+  installing the package on its own.
+
+  `rxjs`, `kysely` and `path-to-regexp` reach consumers through public
+  signatures — `Observable<BaseEvent>` is the return type of a published method,
+  and `createCoercionPlugin` returns a `KyselyPlugin` — so they are runtime
+  dependencies rather than build-only ones.
+
+  `@pikku/assistant-ui` pins `rxjs` to the exact `7.8.1` that `@ag-ui/client`
+  pins, rather than a caret range. The two packages exchange `Observable`s, so a
+  range that floats to a second copy gives them two incompatible `Observable`
+  types.
+
+  `@pikku/kysely` also drops `SqliteSerializePlugin`, an alias of
+  `SerializePlugin` that has been marked `@deprecated` in favour of it. Use
+  `SerializePlugin`.
+
+- Updated dependencies [7406bfe]
+- Updated dependencies [6794681]
+  - @pikku/core@0.12.84
+
 ## 0.13.15
 
 ### Patch Changes

package/dist/src/coercion-plugin.d.ts

@@ -0,0 +1,41 @@
+import type { KyselyPlugin } from 'kysely';
+/**
+ * The kinds a column can be coerced *to* at runtime. This is the value type of
+ * the generated `CoercionMap`, so it is a public artifact contract — a kind may
+ * only appear here if `fromDb` below actually does something with it.
+ *
+ * `uuid` is deliberately absent: it is an annotation kind (it selects the `Uuid`
+ * TypeScript type in the generated schema) but not a coercion kind, and the
+ * codegen filters it out of `coercion.gen.ts` for exactly that reason — a UUID
+ * is a string in both Postgres and SQLite.
+ */
+export type ColumnKind = 'date' | 'bool' | 'json';
+/**
+ * Per-table column kind map. Keys are the table names queries are written
+ * against; inner keys are snake_case column names.
+ * Generated into `outDir/db/coercion.gen.ts` by `pikku db migrate` from the
+ * explicit `kind` entries in `db/annotations.ts`.
+ */
+export type CoercionMap = Record<string, Record<string, ColumnKind>>;
+export interface CreateCoercionPluginOptions {
+    map: CoercionMap;
+}
+/**
+ * Convert values stored in a dialect's on-disk representation back into the
+ * logical types app code expects (Date / boolean / parsed JSON).
+ *
+ * SQLite is what makes this necessary — it stores dates as TEXT, booleans as
+ * INTEGER and JSON as TEXT — but the plugin is dialect-neutral: on Postgres the
+ * driver already returns Date/boolean/object, and every branch of `fromDb`
+ * passes a non-string, non-number value straight through. That is why it lives
+ * in `@pikku/kysely` next to `SerializePlugin` rather than in a SQLite package:
+ * the CLI installs it on its local Postgres database too.
+ *
+ * Write-side coercion (Date → ISO string, boolean → 0/1, object → JSON) is
+ * handled in the SQLite database adapters (always-on), so this plugin is
+ * read-only.
+ *
+ * Place AFTER CamelCasePlugin in the plugin array (or it handles both
+ * orderings via the dual-keyed maps).
+ */
+export declare function createCoercionPlugin(options: CreateCoercionPluginOptions): KyselyPlugin;

package/dist/src/coercion-plugin.js

@@ -0,0 +1,150 @@
+function fromDb(value, kind) {
+    if (value == null)
+        return value;
+    switch (kind) {
+        case 'date':
+            if (typeof value === 'string') {
+                const d = new Date(value);
+                return Number.isNaN(d.getTime()) ? value : d;
+            }
+            return value;
+        case 'bool':
+            if (typeof value === 'number')
+                return value !== 0;
+            if (typeof value === 'bigint')
+                return value !== 0n;
+            return value;
+        case 'json':
+            if (typeof value !== 'string')
+                return value;
+            try {
+                return JSON.parse(value);
+            }
+            catch {
+                return value;
+            }
+    }
+}
+function snakeToCamel(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+/**
+ * Flatten the per-table map into a table-qualified lookup plus a bare
+ * column-name fallback. Both are indexed by BOTH snake_case and camelCase so
+ * they work regardless of CamelCasePlugin ordering in the plugin array.
+ *
+ * When two tables disagree on the kind for the same column name, the bare name
+ * is ambiguous (a joined/aliased query could carry either) and is dropped from
+ * the flat map rather than letting whichever table was processed last win. The
+ * qualified map still resolves it whenever the query names its tables.
+ */
+function buildMaps(map) {
+    const qualified = {};
+    const flat = {};
+    const ambiguous = new Set();
+    const assignFlat = (key, kind) => {
+        const existing = flat[key];
+        if (existing !== undefined && existing !== kind) {
+            ambiguous.add(key);
+            return;
+        }
+        flat[key] = kind;
+    };
+    for (const [table, cols] of Object.entries(map)) {
+        for (const [col, kind] of Object.entries(cols)) {
+            const camel = snakeToCamel(col);
+            qualified[`${table}.${col}`] = kind;
+            qualified[`${table}.${camel}`] = kind;
+            assignFlat(col, kind);
+            assignFlat(camel, kind);
+        }
+    }
+    for (const key of ambiguous)
+        delete flat[key];
+    return { qualified, flat };
+}
+/**
+ * Collect every table named anywhere in the query's operation node, so a result
+ * column can be resolved against the tables the query actually touched instead
+ * of against every table in the schema.
+ */
+function collectQueryTables(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    const op = node;
+    if (op.kind === 'TableNode') {
+        const tableName = op.table?.identifier?.name;
+        if (typeof tableName === 'string' && tableName.length > 0)
+            out.add(tableName);
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const item of value)
+                collectQueryTables(item, out);
+        }
+        else {
+            collectQueryTables(value, out);
+        }
+    }
+}
+/**
+ * Resolve a result column's kind against the query's tables, falling back to
+ * the bare column name. Tables that disagree with each other are as ambiguous
+ * as two schema tables are, so they fall back too.
+ */
+function lookupKind(maps, tables, col) {
+    let matchedKind;
+    for (const table of tables) {
+        const kind = maps.qualified[`${table}.${col}`];
+        if (!kind)
+            continue;
+        if (matchedKind && matchedKind !== kind)
+            return maps.flat[col];
+        matchedKind = kind;
+    }
+    return matchedKind ?? maps.flat[col];
+}
+/**
+ * Convert values stored in a dialect's on-disk representation back into the
+ * logical types app code expects (Date / boolean / parsed JSON).
+ *
+ * SQLite is what makes this necessary — it stores dates as TEXT, booleans as
+ * INTEGER and JSON as TEXT — but the plugin is dialect-neutral: on Postgres the
+ * driver already returns Date/boolean/object, and every branch of `fromDb`
+ * passes a non-string, non-number value straight through. That is why it lives
+ * in `@pikku/kysely` next to `SerializePlugin` rather than in a SQLite package:
+ * the CLI installs it on its local Postgres database too.
+ *
+ * Write-side coercion (Date → ISO string, boolean → 0/1, object → JSON) is
+ * handled in the SQLite database adapters (always-on), so this plugin is
+ * read-only.
+ *
+ * Place AFTER CamelCasePlugin in the plugin array (or it handles both
+ * orderings via the dual-keyed maps).
+ */
+export function createCoercionPlugin(options) {
+    const maps = buildMaps(options.map);
+    const queryTables = new WeakMap();
+    return {
+        transformQuery(args) {
+            const tables = new Set();
+            collectQueryTables(args.node, tables);
+            queryTables.set(args.queryId, [...tables]);
+            return args.node;
+        },
+        async transformResult(args) {
+            const tables = queryTables.get(args.queryId) ?? [];
+            const out = [];
+            for (const row of args.result.rows) {
+                const next = { ...row };
+                for (const [col, val] of Object.entries(row)) {
+                    const kind = lookupKind(maps, tables, col);
+                    if (kind)
+                        next[col] = fromDb(val, kind);
+                }
+                out.push(next);
+            }
+            return { ...args.result, rows: out };
+        },
+    };
+}

package/dist/src/create-audited-kysely.d.ts

@@ -1,4 +1,4 @@
-import type { AuditLog } from '@pikku/core';
+import type { AuditLog } from '@pikku/core/services';
 import type { Kysely } from 'kysely';
 export interface CreateAuditedKyselyOptions {
     audit: AuditLog;

package/dist/src/index.d.ts

@@ -4,9 +4,9 @@ export { KyselyWorkflowService } from './kysely-workflow-service.js';
 export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 export { KyselyWorkflowMirror } from './kysely-workflow-mirror.js';
 export { KyselyDeploymentService } from './kysely-deployment-service.js';
-export { KyselyAIStorageService } from './kysely-ai-storage-service.js';
-export { KyselyAgentRunService } from './kysely-ai-agent-run-service.js';
-export { KyselyAIRunStateService } from './kysely-ai-run-state-service.js';
+export { KyselyAgentStorageService } from './kysely-agent-storage-service.js';
+export { KyselyAgentRunService } from './kysely-agent-run-service.js';
+export { KyselyAgentRunStateService } from './kysely-agent-run-state-service.js';
 export { KyselySecretService } from './kysely-secret-service.js';
 export { KyselyCredentialService } from './kysely-credential-service.js';
 export { KyselySessionStore } from './kysely-session-store.js';
@@ -15,9 +15,10 @@ export { KyselyWebhookService } from './kysely-webhook-service.js';
 export { createAuditedKysely, type CreateAuditedKyselyOptions, } from './create-audited-kysely.js';
 export { KyselyAuditService } from './kysely-audit-service.js';
 export { KyselyVirtualUserRunStore } from './kysely-virtual-user-run-store.js';
-export { SerializePlugin, SqliteSerializePlugin, BaseSerializePlugin, type Serializer, type Deserializer, } from './serialize-plugin.js';
+export { SerializePlugin, BaseSerializePlugin, type Serializer, type Deserializer, } from './serialize-plugin.js';
+export { createCoercionPlugin, type ColumnKind, type CoercionMap, type CreateCoercionPluginOptions, } from './coercion-plugin.js';
 export { auditSchema, pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, type EnsureOutcome, resolveRequirements, type PikkuSchema, type RequiredTypes, type UnmetRequirement, type SchemaStatementFactory, } from './schema/index.js';
 export type { KyselyPikkuDB } from './kysely-tables.js';
 export type { WorkflowRunService } from '@pikku/core/workflow';
-export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent';
+export type { AgentRunService, AgentRunRow } from '@pikku/core/agent';
 export type { VirtualUserRunStore, VirtualUserRunRecord, } from '@pikku/core/virtual-user';

package/dist/src/index.js

@@ -4,9 +4,9 @@ export { KyselyWorkflowService } from './kysely-workflow-service.js';
 export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 export { KyselyWorkflowMirror } from './kysely-workflow-mirror.js';
 export { KyselyDeploymentService } from './kysely-deployment-service.js';
-export { KyselyAIStorageService } from './kysely-ai-storage-service.js';
-export { KyselyAgentRunService } from './kysely-ai-agent-run-service.js';
-export { KyselyAIRunStateService } from './kysely-ai-run-state-service.js';
+export { KyselyAgentStorageService } from './kysely-agent-storage-service.js';
+export { KyselyAgentRunService } from './kysely-agent-run-service.js';
+export { KyselyAgentRunStateService } from './kysely-agent-run-state-service.js';
 export { KyselySecretService } from './kysely-secret-service.js';
 export { KyselyCredentialService } from './kysely-credential-service.js';
 export { KyselySessionStore } from './kysely-session-store.js';
@@ -15,5 +15,6 @@ export { KyselyWebhookService } from './kysely-webhook-service.js';
 export { createAuditedKysely, } from './create-audited-kysely.js';
 export { KyselyAuditService } from './kysely-audit-service.js';
 export { KyselyVirtualUserRunStore } from './kysely-virtual-user-run-store.js';
-export { SerializePlugin, SqliteSerializePlugin, BaseSerializePlugin, } from './serialize-plugin.js';
+export { SerializePlugin, BaseSerializePlugin, } from './serialize-plugin.js';
+export { createCoercionPlugin, } from './coercion-plugin.js';
 export { auditSchema, pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, resolveRequirements, } from './schema/index.js';

package/dist/src/{kysely-ai-run-scores.d.ts → kysely-agent-run-scores.d.ts}

@@ -1,10 +1,10 @@
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
+import type { AgentRunScore } from '@pikku/core/agent-scorer';
 import type { SaveScoreInput } from '@pikku/core/services';
-import type { AIRunScore } from '@pikku/core/ai-scorer';
 /**
- * Shared by the two Kysely services that implement `AIRunStateService` — they
+ * Shared by the two Kysely services that implement `AgentRunStateService` — they
  * differ in how they store approvals, not in how they store grades.
  */
 export declare const saveRunScore: (db: Kysely<KyselyPikkuDB>, score: SaveScoreInput) => Promise<void>;
-export declare const getRunScores: (db: Kysely<KyselyPikkuDB>, runId: string) => Promise<AIRunScore[]>;
+export declare const getRunScores: (db: Kysely<KyselyPikkuDB>, runId: string) => Promise<AgentRunScore[]>;

package/dist/src/{kysely-ai-run-scores.js → kysely-agent-run-scores.js}

@@ -1,11 +1,11 @@
 import { parseJson } from './kysely-json.js';
 /**
- * Shared by the two Kysely services that implement `AIRunStateService` — they
+ * Shared by the two Kysely services that implement `AgentRunStateService` — they
  * differ in how they store approvals, not in how they store grades.
  */
 export const saveRunScore = async (db, score) => {
     await db
-        .insertInto('aiRunScore')
+        .insertInto('agentRunScore')
         .values({
         id: crypto.randomUUID(),
         runId: score.runId,
@@ -18,7 +18,7 @@ export const saveRunScore = async (db, score) => {
 };
 export const getRunScores = async (db, runId) => {
     const rows = await db
-        .selectFrom('aiRunScore')
+        .selectFrom('agentRunScore')
         .selectAll()
         .where('runId', '=', runId)
         .orderBy('createdAt', 'asc')

package/dist/src/{kysely-ai-agent-run-service.d.ts → kysely-agent-run-service.d.ts}

@@ -1,4 +1,4 @@
-import type { AIThread, AIMessage, AgentRunRow, AgentRunService } from '@pikku/core/ai-agent';
+import type { AgentThread, AgentMessage, AgentRunRow, AgentRunService } from '@pikku/core/agent';
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
 export declare class KyselyAgentRunService implements AgentRunService {
@@ -10,9 +10,9 @@ export declare class KyselyAgentRunService implements AgentRunService {
         owners?: string[];
         limit?: number;
         offset?: number;
-    }): Promise<AIThread[]>;
-    getThread(threadId: string): Promise<AIThread | null>;
-    getThreadMessages(threadId: string): Promise<AIMessage[]>;
+    }): Promise<AgentThread[]>;
+    getThread(threadId: string): Promise<AgentThread | null>;
+    getThreadMessages(threadId: string): Promise<AgentMessage[]>;
     getThreadRuns(threadId: string): Promise<AgentRunRow[]>;
     deleteThread(threadId: string): Promise<boolean>;
     getDistinctAgentNames(): Promise<string[]>;

package/dist/src/{kysely-ai-agent-run-service.js → kysely-agent-run-service.js}

@@ -15,7 +15,7 @@ export class KyselyAgentRunService {
         if (owners && owners.length === 0)
             return [];
         let query = this.db
-            .selectFrom('aiThreads as t')
+            .selectFrom('agentThreads as t')
             .select([
             't.id',
             't.resourceId',
@@ -26,7 +26,7 @@ export class KyselyAgentRunService {
         ]);
         if (agentName) {
             query = query.where('t.id', 'in', this.db
-                .selectFrom('aiRun')
+                .selectFrom('agentRun')
                 .select('threadId')
                 .where('agentName', '=', agentName)
                 .distinct());
@@ -49,7 +49,7 @@ export class KyselyAgentRunService {
     }
     async getThread(threadId) {
         const row = await this.db
-            .selectFrom('aiThreads')
+            .selectFrom('agentThreads')
             .select([
             'id',
             'resourceId',
@@ -67,13 +67,13 @@ export class KyselyAgentRunService {
     async getThreadMessages(threadId) {
         const [msgResult, tcResult] = await Promise.all([
             this.db
-                .selectFrom('aiMessage')
+                .selectFrom('agentMessage')
                 .select(['id', 'role', 'content', 'createdAt'])
                 .where('threadId', '=', threadId)
                 .orderBy('createdAt', 'asc')
                 .execute(),
             this.db
-                .selectFrom('aiToolCall')
+                .selectFrom('agentToolCall')
                 .select(['id', 'messageId', 'toolName', 'args', 'result'])
                 .where('threadId', '=', threadId)
                 .orderBy('createdAt', 'asc')
@@ -123,7 +123,7 @@ export class KyselyAgentRunService {
     }
     async getThreadRuns(threadId) {
         const result = await this.db
-            .selectFrom('aiRun')
+            .selectFrom('agentRun')
             .select([
             'runId',
             'agentName',
@@ -146,14 +146,14 @@ export class KyselyAgentRunService {
     }
     async deleteThread(threadId) {
         const result = await this.db
-            .deleteFrom('aiThreads')
+            .deleteFrom('agentThreads')
             .where('id', '=', threadId)
             .executeTakeFirst();
         return BigInt(result.numDeletedRows) > 0n;
     }
     async getDistinctAgentNames() {
         const result = await this.db
-            .selectFrom('aiRun')
+            .selectFrom('agentRun')
             .select('agentName')
             .distinct()
             .orderBy('agentName')

package/dist/src/{kysely-ai-run-state-service.d.ts → kysely-agent-run-state-service.d.ts}

@@ -1,9 +1,10 @@
 import type { Kysely } from 'kysely';
 import type { KyselyPikkuDB } from './kysely-tables.js';
-import type { AIRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
-import type { AgentRunState, PendingApproval } from '@pikku/core/ai-agent';
-import type { AIRunScore } from '@pikku/core/ai-scorer';
-export declare class KyselyAIRunStateService implements AIRunStateService {
+import type { AgentRunState } from '@pikku/core/agent';
+import type { AgentRunScore } from '@pikku/core/agent-scorer';
+import type { AgentRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
+import type { PendingApproval } from '@pikku/core/agent';
+export declare class KyselyAgentRunStateService implements AgentRunStateService {
     private db;
     private initialized;
     constructor(db: Kysely<KyselyPikkuDB>);
@@ -18,6 +19,6 @@ export declare class KyselyAIRunStateService implements AIRunStateService {
         approval: PendingApproval;
     } | null>;
     saveScore(score: SaveScoreInput): Promise<void>;
-    getScores(runId: string): Promise<AIRunScore[]>;
+    getScores(runId: string): Promise<AgentRunScore[]>;
     private toRunState;
 }