@matatbread/matbot-core 0.4.16 → 0.4.18

package/src/session.ts

@@ -1,13 +1,14 @@
-import type { Session, Message } from './types.js';
+import type { Session, SessionStatus, Message } from './types.js';
 
 // `createMessage` lives in plugin-api, where the hook registry can also reach it (core is downstream of
 // that package). Re-exported here so it stays where every consumer already imports it from.
 export { createMessage } from '@matatbread/matbot-plugin-api';
 
 export interface CreateSessionOpts {
-  title?:                string;
-  parentSessionId?:      string;
-  branchPointMessageId?: string;
+  title?:  string;
+  /** Defaults to `'active'`. `'archived'` creates it hidden: off the default session list from the
+   *  start, rather than created visible and hidden by a second write. */
+  status?: SessionStatus;
 }
 
 export function createSession(opts: CreateSessionOpts = {}): Session {
@@ -15,10 +16,8 @@ export function createSession(opts: CreateSessionOpts = {}): Session {
   return {
     id:               crypto.randomUUID(),
     version:          crypto.randomUUID(),
-    ...(opts.title                !== undefined ? { title:                opts.title                } : {}),
-    ...(opts.parentSessionId      !== undefined ? { parentSessionId:      opts.parentSessionId      } : {}),
-    ...(opts.branchPointMessageId !== undefined ? { branchPointMessageId: opts.branchPointMessageId } : {}),
-    status:    'active',
+    ...(opts.title !== undefined ? { title: opts.title } : {}),
+    status:    opts.status ?? 'active',
     messages:  [],
     createdAt: now,
     updatedAt: now,

package/src/settings.ts

@@ -148,7 +148,7 @@ export function makePluginSettings(rawStore: Store<SettingsDoc>, namespace: stri
       const doc  = await getDoc();
       const data = mutate(doc?.data ?? {});
       if (data === undefined) return;
-      const next: SettingsDoc = { id, version: Date.now().toString(), data };
+      const next: SettingsDoc = { id, version: crypto.randomUUID(), data };
       if (doc === null) { await store.set(id, next); return; }
       const r = await store.cas(id, doc.version, next);
       if (r.ok) return;

package/src/storage-base/index.ts

@@ -1,3 +1,4 @@
 export * from './query/index.js';
 export { CachingStorageBackend, type CachingOptions, type CacheNamespaceStats } from './caching-backend.js';
 export { mediumGuard } from './medium-guard.js';
+export { MemoryStore } from './memory-store.js';

package/src/storage-base/memory-store.ts

@@ -0,0 +1,34 @@
+import type { Store, CASResult, StoreQuery, QueryResult } from '@matatbread/matbot-plugin-api';
+import { executeQuery } from './query/index.js';
+
+/** A `Store` held in a `Map`: nothing persists, nothing is announced, nothing outlives the instance. */
+export class MemoryStore<T extends { id: string; version: string }> implements Store<T> {
+  private readonly items = new Map<string, T>();
+
+  async get(id: string): Promise<T | null> {
+    return this.items.get(id) ?? null;
+  }
+
+  async set(id: string, value: T): Promise<void> {
+    this.items.set(id, value);
+  }
+
+  async cas(id: string, expected: string, next: T): Promise<CASResult<T>> {
+    const current = this.items.get(id) ?? null;
+    if (current === null || current.version !== expected) return { ok: false, current };
+    this.items.set(id, next);
+    return { ok: true, doc: next };
+  }
+
+  async delete(id: string, expectedVersion?: string): Promise<boolean> {
+    if (expectedVersion !== undefined) {
+      const current = this.items.get(id);
+      if (current === undefined || current.version !== expectedVersion) return false;
+    }
+    return this.items.delete(id);
+  }
+
+  async query(q: StoreQuery): Promise<QueryResult<T>> {
+    return executeQuery([...this.items.values()], q);
+  }
+}

package/src/system-context.ts

@@ -5,6 +5,10 @@ interface TaggedContributor {
   pluginName?: string;
 }
 
+/** The system prompt as sent: the parts joined, or null when there are none. */
+export const joinSystemContext = (parts: readonly SystemContextPart[]): string | null =>
+  parts.length > 0 ? parts.map(p => p.text).join('\n\n') : null;
+
 export class SystemContextRegistryImpl implements SystemContextRegistry {
   private readonly _contributors: TaggedContributor[] = [];
 
@@ -32,9 +36,8 @@ export class SystemContextRegistryImpl implements SystemContextRegistry {
   }
 
   // The joined form is derived from the attributed one, so the prompt the model receives and the
-  // breakdown `about_matbot` reports cannot drift: there is one traversal and one filter.
+  // breakdown `about_matbot` reports cannot drift: there is one traversal, one filter and one join.
   async build(ctx: { session: Session; signal: AbortSignal }): Promise<string | null> {
-    const parts = await this.parts(ctx);
-    return parts.length > 0 ? parts.map(p => p.text).join('\n\n') : null;
+    return joinSystemContext(await this.parts(ctx));
   }
 }

package/src/usage.ts

@@ -12,12 +12,15 @@ export function addUsage(acc: Usage | undefined, next: Usage): Usage {
   const a = acc ?? { inputTokens: 0, outputTokens: 0 };
   const add = (x: number | undefined, y: number | undefined): number | undefined =>
     x === undefined && y === undefined ? undefined : (x ?? 0) + (y ?? 0);
+  const cacheReadTokens     = add(a.cacheReadTokens,     next.cacheReadTokens);
+  const cacheCreationTokens = add(a.cacheCreationTokens, next.cacheCreationTokens);
+  const reported            = addReported(a.reported, next.reported);
   return {
     inputTokens:  a.inputTokens  + next.inputTokens,
     outputTokens: a.outputTokens + next.outputTokens,
-    ...(((c) => c !== undefined ? { cacheReadTokens:     c } : {}))(add(a.cacheReadTokens,     next.cacheReadTokens)),
-    ...(((c) => c !== undefined ? { cacheCreationTokens: c } : {}))(add(a.cacheCreationTokens, next.cacheCreationTokens)),
-    ...(((r) => r !== undefined ? { reported: r } : {}))(addReported(a.reported, next.reported)),
+    ...(cacheReadTokens     !== undefined ? { cacheReadTokens }     : {}),
+    ...(cacheCreationTokens !== undefined ? { cacheCreationTokens } : {}),
+    ...(reported            !== undefined ? { reported }            : {}),
   };
 }