@matatbread/matbot-core 0.4.15 → 0.4.17

package/src/session.ts

@@ -1,4 +1,8 @@
-import type { Session, Message, MessageContent, MessageRole } from './types.js';
+import type { Session, 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;
@@ -32,20 +36,3 @@ export function appendMessage(session: Session, message: Message): Session {
   };
 }
 
-export function createMessage(opts: {
-  role:           MessageRole;
-  content:        MessageContent[];
-  traceId:        string;
-  providerName?:  string;
-  metadata?:      Record<string, unknown>;
-}): Message {
-  return {
-    id:        crypto.randomUUID(),
-    role:      opts.role,
-    content:   opts.content,
-    createdAt: new Date().toISOString(),
-    traceId:   opts.traceId,
-    ...(opts.providerName !== undefined ? { providerName: opts.providerName } : {}),
-    ...(opts.metadata     !== undefined ? { metadata:     opts.metadata     } : {}),
-  };
-}

package/src/settings.ts

@@ -70,6 +70,9 @@ export function settingsDefaultNamespaces(): readonly string[] {
  *  consumer filters `kind === ItemChangeKind && namespace === SETTINGS_NAMESPACE && id === slug(mine)`. */
 export const SETTINGS_NAMESPACE = 'settings';
 
+/** How many times a settings write re-reads and re-compares before giving up. See `update` below. */
+const SETTINGS_CAS_ATTEMPTS = 8;
+
 /**
  * The bus settings writes announce on, installed by the host at boot alongside {@link installSettingsDefaults}.
  *
@@ -134,15 +137,28 @@ export function makePluginSettings(rawStore: Store<SettingsDoc>, namespace: stri
 
   // One CAS retry loop for both writers: read, apply `mutate`, write. A document that vanished between
   // read and write (or never existed) is a plain `set`; otherwise `cas` guards the version we read.
+  //
+  // Bounded, because the loop cannot tell a lost race from a `cas` that will never succeed: a backend
+  // whose compare always fails (a version it does not mint, a medium generation it cannot reconcile)
+  // turned this into a hot spin with no error and no exit. A settings namespace is one document with few
+  // writers, so real contention resolves in one or two passes; exhausting the budget is a fault to
+  // report, not a state to keep retrying.
   const update = async (mutate: (data: Record<string, unknown>) => Record<string, unknown> | undefined): Promise<void> => {
-    for (;;) {
+    for (let attempt = 1; ; attempt++) {
       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;
+      if (attempt >= SETTINGS_CAS_ATTEMPTS) {
+        throw new Error(
+          `Settings for "${namespace}" could not be written: ${SETTINGS_CAS_ATTEMPTS} compare-and-swap ` +
+          'attempts all lost. Either something is writing this namespace continuously, or the storage ' +
+          'backend is rejecting every compare.',
+        );
+      }
     }
   };
 

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 }            : {}),
   };
 }