@open-autonomy/sdk 2.3.1 → 2.3.3

package/README.md

@@ -29,8 +29,8 @@ await s.end({ outcome: 'done', report: 'Done. add — committed 7d30729.', commi
   page parses through the same code. There is no write API: the file in git is the only roadmap surface.
   Adapters that mirror it to a tracker are what the shape is for.
 
-Spend is attributed by the platform: a metered call settles on the one session live at that moment, so
-an item's page shows every session, update and settled cent that touched it.
+Spend is attributed by the platform: Hermes names its session on each model request, so overlapping sessions
+each receive their own settled calls and cents and an item's page shows everything that touched it.
 
 ## Drivers
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-autonomy/sdk",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "The Open Autonomy SDK: the roadmap model and its codec, the development-stream client (sessions, turns, updates), and the key helpers. Everything it does is a documented HTTP wire any language can speak without it.",
   "license": "Apache-2.0",
   "repository": {

package/src/client.ts

@@ -19,7 +19,7 @@ export type TurnRole = 'user' | 'assistant' | 'tool' | 'system';
 export interface Turn { ts?: string; role: TurnRole; text?: string; tool?: string; args?: string; result?: string }
 export type SessionOutcome = 'done' | 'failed';
 
-export interface SessionStart { key: string; kind?: string; title?: string; item?: string; source?: string; startedAt?: string }
+export interface SessionStart { key: string; kind?: string; title?: string; item?: string; source?: string; modelProvider?: string; startedAt?: string }
 export interface SessionEnd { key: string; outcome?: SessionOutcome; report?: string; commit?: string; item?: string; endedAt?: string }
 export interface Update { item: string; text: string; session?: string; at?: string }
 // The board's state for a roadmap item, as the agent's harness keeps it: the task's lane, every attempt at
@@ -57,7 +57,7 @@ export const EVENT_TYPES = {
 } as const;
 
 export function sessionStartedEvent(s: SessionStart, source = 'open-autonomy-sdk'): CloudEvent {
-  return event(EVENT_TYPES.started, s.key, { session_kind: s.kind, title: s.title, item_id: s.item, source: s.source }, s.startedAt, source);
+  return event(EVENT_TYPES.started, s.key, { session_kind: s.kind, title: s.title, item_id: s.item, source: s.source, model_provider: s.modelProvider }, s.startedAt, source);
 }
 export function sessionTurnsEvent(key: string, seq: number, turns: Turn[], item?: string, source = 'open-autonomy-sdk'): CloudEvent {
   return event(EVENT_TYPES.turns, key, { seq, turns, item_id: item }, undefined, source);
@@ -76,7 +76,7 @@ function event(type: string, subject: string, data: Record<string, unknown>, tim
 export interface EventResult { id?: string; ok: boolean; error?: string; idempotent?: boolean; session?: SessionSummary; update?: UpdateRecord }
 export interface SessionSummary {
   key: string; account: string; kind: string; status: 'live' | 'ended'; outcome?: SessionOutcome; title?: string; item_id?: string; source?: string;
-  started_at: string; ended_at?: string; report?: string; commit_sha?: string; turn_count: number; next_seq: number; tool_calls: number; usd_cents: number; calls: number; updated_at: string;
+  model_provider?: string; started_at: string; ended_at?: string; report?: string; commit_sha?: string; turn_count: number; next_seq: number; tool_calls: number; usd_cents: number; calls: number; updated_at: string;
 }
 export interface SessionRecord extends Omit<SessionSummary, 'tool_calls'> { turns: Array<Turn & { seq?: number }> }
 export interface UpdateRecord { id: string; account: string; item_id: string; ts: string; text: string; session?: string }

package/src/rails.ts

@@ -72,21 +72,56 @@ export function parseModelsBound(yaml: string): string[] {
   return out;
 }
 
-// The most the project's funds may spend on the model rail in a day (UTC), from the same file:
+// The limits the project's funds run under on the model rail, from the same file — the shape a provider's rate
+// limits and a budget's period share: each limit is one measure over one window, rolling.
 //   spend:
-//     daily_usd_cents: 500
-// 0 or absent: no bound of the project's own beyond the platform's global rail.
-export function parseSpendBound(yaml: string): { daily_usd_cents: number } {
-  let block = '';
-  let daily = 0;
+//     limits:
+//       - { window: 1d, usd_cents: 500 }                    # the money: cents over the window
+//       - { window: 30d, usd_cents: 6000 }
+//       - { window: 1m, calls: 60 }                         # the pace: requests over the window
+//       - { window: 1h, tokens: 2000000 }                   # the volume: tokens in and out over the window
+//       - { window: 1d, usd_cents: 100, model: openai/gpt-5 } # one model's own budget
+// Windows: N m (minutes, up to 60), N h (hours, up to 24), N d (days, up to 31). Every limit holds at once; the platform
+// refuses the call that would cross one and says which. None: no bound of the project's own beyond the platform's rail.
+export interface SpendLimit { window: string; window_seconds: number; usd_cents?: number; calls?: number; tokens?: number; model?: string }
+export function parseWindow(spec: string): number | undefined {
+  const m = /^(\d+)\s*(m|h|d)$/.exec(spec.trim());
+  if (!m) return undefined;
+  const n = Number(m[1]); const unit = { m: 60, h: 3600, d: 86400 }[m[2] as 'm' | 'h' | 'd'];
+  const max = { m: 60, h: 24, d: 31 }[m[2] as 'm' | 'h' | 'd'];
+  return n >= 1 && n <= max ? n * unit : undefined;
+}
+export function parseSpendLimits(yaml: string): SpendLimit[] {
+  const out: SpendLimit[] = [];
+  let block = ''; let inLimits = false; let item: Record<string, string> | null = null;
+  const flush = () => {
+    if (!item) return;
+    const seconds = item.window ? parseWindow(item.window) : undefined;
+    const num = (k: string) => (item![k] !== undefined && /^\d+$/.test(item![k]) ? Number(item![k]) : undefined);
+    const limit: SpendLimit = { window: (item.window ?? '').trim(), window_seconds: seconds ?? 0 };
+    if (num('usd_cents') !== undefined) limit.usd_cents = num('usd_cents');
+    if (num('calls') !== undefined) limit.calls = num('calls');
+    if (num('tokens') !== undefined) limit.tokens = num('tokens');
+    if (item.model) limit.model = item.model.trim().replace(/^["']|["']$/g, '');
+    if (seconds && (limit.usd_cents !== undefined || limit.calls !== undefined || limit.tokens !== undefined)) out.push(limit);
+    item = null;
+  };
+  const pairs = (text: string): Record<string, string> => Object.fromEntries(text.split(',').map((kv) => kv.split(':')).filter((kv) => kv.length >= 2).map(([k, ...v]) => [k.trim(), v.join(':').trim().replace(/^["']|["']$/g, '')]));
   for (const raw of yaml.split('\n')) {
     const line = raw.replace(/\s+#.*$/, '').trimEnd();
     if (!line.trim() || line.trim().startsWith('#')) continue;
     const top = /^([a-z_]+):\s*(.*)$/.exec(line);
-    if (top) { block = top[2] === '' ? top[1] : ''; continue; }
+    if (top) { flush(); block = top[2] === '' ? top[1] : ''; inLimits = false; continue; }
     if (block !== 'spend') continue;
-    const kv = /^\s+daily_usd_cents:\s*(\d+)\s*$/.exec(line);
-    if (kv) daily = Math.max(0, Math.floor(Number(kv[1])));
+    if (/^  limits:\s*$/.test(line)) { flush(); inLimits = true; continue; }
+    if (!inLimits) continue;
+    const flow = /^\s+-\s*\{(.*)\}\s*$/.exec(line);
+    if (flow) { flush(); item = pairs(flow[1]); flush(); continue; }
+    const start = /^\s+-\s+([a-z_]+):\s*(.+)$/.exec(line);
+    if (start) { flush(); item = { [start[1]]: start[2].trim() }; continue; }
+    const more = item ? /^\s+([a-z_]+):\s*(.+)$/.exec(line) : null;
+    if (more) item![more[1]] = more[2].trim();
   }
-  return { daily_usd_cents: daily };
+  flush();
+  return out;
 }