@moxxy/sdk 0.14.1 → 0.14.3

package/src/mode.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { migrateModeName } from './mode.js';
+
+describe('migrateModeName', () => {
+  it('maps every legacy mode name to its current target', () => {
+    expect(migrateModeName('tool-use')).toBe('default');
+    expect(migrateModeName('deep-research')).toBe('research');
+    expect(migrateModeName('plan-execute')).toBe('default');
+    expect(migrateModeName('bmad')).toBe('default');
+    expect(migrateModeName('developer')).toBe('default');
+  });
+
+  it('passes a current/unknown name through unchanged (identity)', () => {
+    expect(migrateModeName('default')).toBe('default');
+    expect(migrateModeName('goal')).toBe('goal');
+    expect(migrateModeName('research')).toBe('research');
+    expect(migrateModeName('some-future-mode')).toBe('some-future-mode');
+    expect(migrateModeName('')).toBe('');
+  });
+});

package/src/provider-utils.ts

@@ -173,6 +173,30 @@ export function zodToJsonSchema(schema: unknown): unknown {
     const items = zodToJsonSchema((def as unknown as { type: unknown }).type);
     return { type: 'array', items };
   }
+  if (typeName === 'ZodRecord') {
+    // `z.record(keyType, valueType)` — an open-ended object whose values share
+    // one schema. Carry the value schema through `additionalProperties` rather
+    // than discarding it to the permissive fallback below.
+    const valueType = (def as unknown as { valueType: unknown }).valueType;
+    return { type: 'object', additionalProperties: zodToJsonSchema(valueType) };
+  }
+  if (typeName === 'ZodTuple') {
+    // ZodTuple._def.items is the ordered element schemas; `rest` (if set) is the
+    // variadic tail. Emit a fixed-position `items` array + an `additionalItems`
+    // schema for the rest, mirroring JSON-schema's positional-tuple form.
+    const tupleDef = def as unknown as { items: ReadonlyArray<unknown>; rest?: unknown };
+    const items = tupleDef.items.map((i) => zodToJsonSchema(i));
+    return {
+      type: 'array',
+      items,
+      ...(tupleDef.rest != null ? { additionalItems: zodToJsonSchema(tupleDef.rest) } : {}),
+    };
+  }
+  if (typeName === 'ZodAny' || typeName === 'ZodUnknown') {
+    // Genuinely unconstrained — advertise an empty (permissive) schema instead
+    // of a false `object` shape that would reject non-object values.
+    return {};
+  }
   // Truly unknown — fall back to a permissive "any object" but spell out
   // `properties: {}` and `additionalProperties: true` so strict validators
   // accept the schema instead of bailing on a missing `properties` field.

package/src/token-accounting.test.ts

@@ -4,6 +4,7 @@ import {
   asEventId,
   asSessionId,
   asTurnId,
+  summarizeSessionTokensFromEvents,
   summarizeTokensByModel,
   type ModelUsageTotals,
   type MoxxyEvent,
@@ -78,6 +79,95 @@ describe('summarizeTokensByModel', () => {
   });
 });
 
+describe('summarizeSessionTokensFromEvents — cost fold', () => {
+  it('counts only responses that reported usage', () => {
+    const s = summarizeSessionTokensFromEvents([
+      resp(0, {}), // no token fields → not counted
+      resp(1, { inputTokens: 100, outputTokens: 10 }),
+      resp(2, { cacheReadTokens: 50 }),
+    ]);
+    expect(s.calls).toBe(2);
+    expect(s.totalInput).toBe(100);
+    expect(s.totalCacheRead).toBe(50);
+    expect(s.totalOutput).toBe(10);
+    expect(s.totalPrompt).toBe(150);
+  });
+
+  it('applies the read 0.1x / write 1.25x billing multipliers', () => {
+    const s = summarizeSessionTokensFromEvents([
+      resp(0, { inputTokens: 100, cacheReadTokens: 1000, cacheCreationTokens: 200 }),
+    ]);
+    // totalPrompt = 100 + 1000 + 200 = 1300 (== uncachedInputEq)
+    expect(s.totalPrompt).toBe(1300);
+    expect(s.uncachedInputEq).toBe(1300);
+    // billedInputEq = 100 + 1000*0.1 + 200*1.25 = 100 + 100 + 250 = 450
+    expect(s.billedInputEq).toBeCloseTo(450, 6);
+    expect(s.cacheHitRate).toBeCloseTo(1000 / 1300, 6);
+    expect(s.savedRatio).toBeCloseTo(1 - 450 / 1300, 6);
+  });
+
+  it('guards divide-by-zero when no prompt tokens were reported', () => {
+    const s = summarizeSessionTokensFromEvents([resp(0, { outputTokens: 5 })]);
+    expect(s.totalPrompt).toBe(0);
+    expect(s.cacheHitRate).toBe(0);
+    expect(s.savedRatio).toBe(0);
+    // No writes → cache considered effective (deliberately-off cache never alarms).
+    expect(s.cacheEffective).toBe(true);
+  });
+
+  it('reports cacheEffective=true for a healthy cache (high read ratio)', () => {
+    const events = Array.from({ length: 6 }, (_, i) =>
+      resp(i, { inputTokens: 10, cacheReadTokens: 1000, cacheCreationTokens: 100 }),
+    );
+    const s = summarizeSessionTokensFromEvents(events);
+    expect(s.calls).toBe(6);
+    expect(s.cacheHitRate).toBeGreaterThan(0.05);
+    expect(s.savedRatio).toBeGreaterThan(0);
+    expect(s.cacheEffective).toBe(true);
+  });
+
+  it('trips cacheEffective=false on broken cache: >=5 calls, writes>0, near-zero reads', () => {
+    // 5 calls each writing cache but never reading it → cacheHitRate 0.
+    const events = Array.from({ length: 5 }, (_, i) =>
+      resp(i, { inputTokens: 100, cacheCreationTokens: 500, cacheReadTokens: 0 }),
+    );
+    const s = summarizeSessionTokensFromEvents(events);
+    expect(s.calls).toBe(5);
+    expect(s.totalCacheCreation).toBeGreaterThan(0);
+    expect(s.cacheHitRate).toBe(0);
+    expect(s.cacheEffective).toBe(false);
+  });
+
+  it('exempts the broken-cache trip below 5 calls (boundary at calls===4 vs 5)', () => {
+    const make = (n: number) =>
+      summarizeSessionTokensFromEvents(
+        Array.from({ length: n }, (_, i) =>
+          resp(i, { inputTokens: 100, cacheCreationTokens: 500, cacheReadTokens: 0 }),
+        ),
+      );
+    expect(make(4).cacheEffective).toBe(true); // < 5 → exempt
+    expect(make(5).cacheEffective).toBe(false); // >= 5 → trips
+  });
+
+  it('exempts when there are no cache writes even with zero reads over many calls', () => {
+    const events = Array.from({ length: 8 }, (_, i) =>
+      resp(i, { inputTokens: 100, cacheCreationTokens: 0, cacheReadTokens: 0 }),
+    );
+    expect(summarizeSessionTokensFromEvents(events).cacheEffective).toBe(true);
+  });
+
+  it('does not trip when cacheHitRate sits exactly at the 0.05 threshold', () => {
+    // hitRate === 0.05 is NOT < 0.05, so the cache stays effective.
+    // read/(input+read+write) = 125 / 2500 = 0.05.
+    const events = Array.from({ length: 5 }, (_, i) =>
+      resp(i, { inputTokens: 1875, cacheReadTokens: 125, cacheCreationTokens: 500 }),
+    );
+    const s = summarizeSessionTokensFromEvents(events);
+    expect(s.cacheHitRate).toBeCloseTo(0.05, 6);
+    expect(s.cacheEffective).toBe(true);
+  });
+});
+
 describe('addModelTotals', () => {
   it('adds field-wise', () => {
     const a: ModelUsageTotals = { calls: 1, inputTokens: 10, outputTokens: 2, cacheReadTokens: 3, cacheCreationTokens: 4 };