@msm-core/mini 0.5.0 → 0.5.2

package/CHANGELOG.md

@@ -5,6 +5,31 @@ Follows [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [0.5.2] — 2026-07-01
+
+### Fixed
+
+- **The Gemini brain now reports token usage + cost on the tool-call path.** It
+  previously returned a bare `{ orchestration }` there (only the text path carried
+  usage/cost), so the loop's `costCapPerTask` accrued $0 on exactly the iterations
+  that dominate an agentic run — the cost cap never fired on the primary provider.
+  Both paths now compute usage + cost once, via the shared pricing table
+  (`computeCostUsd`) instead of hardcoded Flash rates, so non-Flash models bill
+  correctly. Locked with `tests/gemini-usage.test.ts`.
+
+### Added
+
+- Pricing table entry for `gemini-2.5-pro` (Pro agents previously had no cost tracking).
+
+## [0.5.1] — 2026-06-30
+
+### Added
+
+- **Array tool-parameters.** `ToolParameter.items` is now forwarded to every
+  provider (Gemini included), so an array-typed tool parameter (e.g. a list of
+  template variables) is described to the model instead of being dropped — which
+  had caused arrays to 400 on Gemini.
+
 ## [0.5.0] — 2026-06-30
 
 Brain-parity + guard-integrity release from the 2026-06 SDK audit (H1, H2, H10, M1).

package/dist/brain/gemini.js

@@ -4,6 +4,7 @@
  */
 import { withRetry } from "./retry.js";
 import { foldToolResults } from "./tool-context.js";
+import { computeCostUsd } from "./pricing.js";
 export function createGeminiBrain(opts) {
     const model = opts.model ?? "gemini-2.5-flash";
     return {
@@ -41,6 +42,7 @@ export function createGeminiBrain(opts) {
                                         type: v.type.toUpperCase(),
                                         description: v.description,
                                         ...(v.enum ? { enum: v.enum } : {}),
+                                        ...(v.items ? { items: { type: v.items.type.toUpperCase() } } : {}),
                                     },
                                 ])),
                                 required: Object.entries(t.parameters)
@@ -61,6 +63,20 @@ export function createGeminiBrain(opts) {
             const result = await withRetry(() => geminiModel.generateContent(request, input.signal ? { signal: input.signal } : {}), input.signal ? { signal: input.signal } : {});
             const response = result.response;
             const parts = response?.candidates?.[0]?.content?.parts ?? [];
+            // Token usage + cost — computed ONCE and returned on BOTH the tool-call and text
+            // paths. Most iterations of an agentic run are tool calls, so omitting usage/cost
+            // there (as before) left the loop's cost cap seeing $0 and never firing. Price via
+            // the shared table (not hardcoded Flash rates) so gemini-2.5-pro bills correctly.
+            const usageMeta = response?.usageMetadata;
+            const inputTokens = usageMeta?.promptTokenCount;
+            const outputTokens = usageMeta?.candidatesTokenCount;
+            const usage = inputTokens !== undefined || outputTokens !== undefined
+                ? {
+                    ...(inputTokens !== undefined ? { inputTokens } : {}),
+                    ...(outputTokens !== undefined ? { outputTokens } : {}),
+                }
+                : undefined;
+            const costUsd = computeCostUsd(model, inputTokens, outputTokens);
             // Check for function call
             const fnCallPart = parts.find((p) => "functionCall" in p && p.functionCall);
             if (fnCallPart &&
@@ -73,31 +89,16 @@ export function createGeminiBrain(opts) {
                     tool_name: fc.name,
                     tool_params: fc.args,
                 };
-                return { orchestration };
+                return { orchestration, costUsd, ...(usage ? { usage } : {}) };
             }
             // Text response
             const textPart = parts.find((p) => "text" in p && typeof p.text === "string");
             const text = textPart && "text" in textPart ? textPart.text : "";
-            // Token usage
-            const usage = response?.usageMetadata;
-            const inputTokens = usage?.promptTokenCount;
-            const outputTokens = usage?.candidatesTokenCount;
             return {
                 generation: { response_text: text },
                 orchestration: { action: "respond", confidence: 0.95 },
-                // Gemini 2.5 Flash pricing: $0.075/1M input, $0.30/1M output
-                costUsd: usage
-                    ? (usage.promptTokenCount ?? 0) * 0.000_000_075 +
-                        (usage.candidatesTokenCount ?? 0) * 0.0000003
-                    : 0,
-                ...(inputTokens !== undefined || outputTokens !== undefined
-                    ? {
-                        usage: {
-                            ...(inputTokens !== undefined ? { inputTokens } : {}),
-                            ...(outputTokens !== undefined ? { outputTokens } : {}),
-                        },
-                    }
-                    : {}),
+                costUsd,
+                ...(usage ? { usage } : {}),
             };
         },
     };

package/dist/brain/pricing.js

@@ -24,6 +24,7 @@ export const PRICE_PER_MILLION = {
     "gpt-4o": { input: 2.5, output: 10 },
     // Google Gemini (public pricing)
     "gemini-2.5-flash": { input: 0.075, output: 0.3 },
+    "gemini-2.5-pro": { input: 1.25, output: 10 },
 };
 /**
  * Cost in USD for one call. Returns 0 when the model is unknown or usage is

package/dist/brain/tool-context.d.ts

@@ -26,6 +26,9 @@ export interface JsonSchemaObject {
         type: string;
         description: string;
         enum?: string[];
+        items?: {
+            type: string;
+        };
     }>;
     required: string[];
 }

package/dist/brain/tool-context.js

@@ -24,6 +24,7 @@ export function toolParamsToJsonSchema(parameters) {
             type: v.type,
             description: v.description,
             ...(v.enum ? { enum: v.enum } : {}),
+            ...(v.items ? { items: { type: v.items.type } } : {}),
         };
     }
     return {

package/dist/core/types.d.ts

@@ -90,6 +90,11 @@ export interface ToolParameter {
     required?: boolean;
     enum?: string[];
     default?: unknown;
+    /** Element type for `type: "array"` params. Required by Gemini's function-calling
+     *  schema (an array without `items` is rejected); forwarded to every provider. */
+    items?: {
+        type: "string" | "number" | "boolean" | "object";
+    };
 }
 /** Input the loop hands to every brain call */
 export interface BrainRunInput {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@msm-core/mini",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Portable AI agent execution loop — brain-agnostic, zero embedded databases",
   "type": "module",
   "main": "./dist/index.js",