@link-assistant/hive-mind 1.20.0 → 1.20.1

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @link-assistant/hive-mind
 
+## 1.20.1
+
+### Patch Changes
+
+- 1689caf: Fix agent tool pricing display to show correct provider
+  - Add proper model mapping for free models (kimi-k2.5-free, gpt-4o-mini, etc.)
+  - Add getProviderName helper function to detect provider from model ID
+  - Prioritize provider from model ID over API response to fix issue #1250
+  - Display correct provider names: Moonshot AI, OpenAI, Anthropic instead of generic "OpenCode Zen"
+
 ## 1.20.0
 
 ### Minor Changes

package/README.md

@@ -481,9 +481,9 @@ Free Models (with --tool agent):
 /solve https://github.com/owner/repo/issues/123 --tool agent --model gpt-5-nano
 /solve https://github.com/owner/repo/issues/123 --tool agent --model glm-4.7-free
 /solve https://github.com/owner/repo/issues/123 --tool agent --model big-pickle
+```
 
 > **📖 Free Models Guide**: See [docs/FREE_MODELS.md](./docs/FREE_MODELS.md) for comprehensive information about all free models.
-```
 
 #### `/hive` - Run Hive Orchestration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.20.0",
+  "version": "1.20.1",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/agent.lib.mjs

@@ -79,17 +79,51 @@ export const parseAgentTokenUsage = output => {
   return usage;
 };
 
+/**
+ * Helper function to get original provider name from provider identifier
+ * Used for calculating public pricing estimates based on original provider prices
+ * @param {string} providerId - Provider identifier (e.g., 'openai', 'anthropic', 'moonshot')
+ * @returns {string} Human-readable provider name for pricing reference
+ */
+const getOriginalProviderName = providerId => {
+  if (!providerId) return null;
+
+  const providerMap = {
+    openai: 'OpenAI',
+    anthropic: 'Anthropic',
+    moonshot: 'Moonshot AI',
+    google: 'Google',
+    opencode: 'OpenCode Zen',
+    grok: 'xAI',
+  };
+
+  return providerMap[providerId] || providerId.charAt(0).toUpperCase() + providerId.slice(1);
+};
+
 /**
  * Calculate pricing for agent tool usage using models.dev API
+ * Issue #1250: Shows actual provider (OpenCode Zen) and calculates public pricing estimate
+ * based on original provider prices (Moonshot AI, OpenAI, Anthropic, etc.)
+ *
  * @param {string} modelId - The model ID used (e.g., 'opencode/grok-code')
  * @param {Object} tokenUsage - Token usage data from parseAgentTokenUsage
- * @returns {Object} Pricing information
+ * @returns {Object} Pricing information with:
+ *   - provider: Always "OpenCode Zen" (actual provider)
+ *   - originalProvider: The original model provider for pricing reference
+ *   - totalCostUSD: Public pricing estimate based on original provider prices
+ *   - opencodeCost: Actual billed cost from OpenCode Zen (free for most models)
  */
 export const calculateAgentPricing = async (modelId, tokenUsage) => {
   // Extract the model name from provider/model format
   // e.g., 'opencode/grok-code' -> 'grok-code'
   const modelName = modelId.includes('/') ? modelId.split('/').pop() : modelId;
 
+  // Extract provider from model ID to determine original provider for pricing
+  const providerFromModel = modelId.includes('/') ? modelId.split('/')[0] : null;
+
+  // Get original provider name for pricing reference
+  const originalProvider = getOriginalProviderName(providerFromModel);
+
   try {
     // Fetch model info from models.dev API
     const modelInfo = await fetchModelInfo(modelName);
@@ -97,7 +131,7 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
     if (modelInfo && modelInfo.cost) {
       const cost = modelInfo.cost;
 
-      // Calculate cost based on token usage
+      // Calculate public pricing estimate based on original provider prices
       // Prices are per 1M tokens, so divide by 1,000,000
       const inputCost = (tokenUsage.inputTokens * (cost.input || 0)) / 1_000_000;
       const outputCost = (tokenUsage.outputTokens * (cost.output || 0)) / 1_000_000;
@@ -106,10 +140,17 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
 
       const totalCost = inputCost + outputCost + cacheReadCost + cacheWriteCost;
 
+      // Determine if this is a free model from OpenCode Zen
+      // Models accessed via OpenCode Zen are free, regardless of original provider pricing
+      const isOpencodeFreeModel = providerFromModel === 'opencode' || modelName.toLowerCase().includes('free') || modelName.toLowerCase().includes('grok') || providerFromModel === 'moonshot' || providerFromModel === 'openai' || providerFromModel === 'anthropic';
+
       return {
         modelId,
         modelName: modelInfo.name || modelName,
-        provider: modelInfo.provider || 'OpenCode Zen',
+        // Issue #1250: Always show OpenCode Zen as actual provider
+        provider: 'OpenCode Zen',
+        // Store original provider for reference in pricing display
+        originalProvider: originalProvider || modelInfo.provider || null,
         pricing: {
           inputPerMillion: cost.input || 0,
           outputPerMillion: cost.output || 0,
@@ -123,18 +164,26 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
           cacheRead: cacheReadCost,
           cacheWrite: cacheWriteCost,
         },
+        // Public pricing estimate based on original provider prices
         totalCostUSD: totalCost,
+        // Actual cost from OpenCode Zen (free for supported models)
+        opencodeCost: isOpencodeFreeModel ? 0 : totalCost,
+        // Keep for backward compatibility - indicates if model has zero pricing
         isFreeModel: cost.input === 0 && cost.output === 0,
+        // New flag to indicate if OpenCode Zen provides this model for free
+        isOpencodeFreeModel,
       };
     }
-
     // Model not found in API, return what we have
     return {
       modelId,
       modelName,
-      provider: 'Unknown',
+      provider: 'OpenCode Zen',
+      originalProvider,
       tokenUsage,
       totalCostUSD: null,
+      opencodeCost: 0, // OpenCode Zen is free
+      isOpencodeFreeModel: true,
       error: 'Model not found in models.dev API',
     };
   } catch (error) {
@@ -142,8 +191,12 @@ export const calculateAgentPricing = async (modelId, tokenUsage) => {
     return {
       modelId,
       modelName,
+      provider: 'OpenCode Zen',
+      originalProvider,
       tokenUsage,
       totalCostUSD: null,
+      opencodeCost: 0, // OpenCode Zen is free
+      isOpencodeFreeModel: true,
       error: error.message,
     };
   }
@@ -163,6 +216,12 @@ export const mapModelToId = model => {
     haiku: 'anthropic/claude-3-5-haiku',
     opus: 'anthropic/claude-3-opus',
     'gemini-3-pro': 'google/gemini-3-pro',
+    // Free models mapping for issue #1250
+    'kimi-k2.5-free': 'moonshot/kimi-k2.5-free',
+    'gpt-4o-mini': 'openai/gpt-4o-mini',
+    'gpt-4o': 'openai/gpt-4o',
+    'claude-3.5-haiku': 'anthropic/claude-3.5-haiku',
+    'claude-3.5-sonnet': 'anthropic/claude-3.5-sonnet',
   };
 
   // Return mapped model ID if it's an alias, otherwise return as-is

package/src/github.lib.mjs

@@ -22,25 +22,50 @@ import { uploadLogWithGhUploadLog } from './log-upload.lib.mjs';
 
 /**
  * Build cost estimation string for log comments
+ * Issue #1250: Enhanced to show both public pricing estimate and actual provider cost
+ *
  * @param {number|null} totalCostUSD - Public pricing estimate
  * @param {number|null} anthropicTotalCostUSD - Cost calculated by Anthropic (Claude-specific)
  * @param {Object|null} pricingInfo - Pricing info from agent tool
+ *   - opencodeCost: Actual billed cost from OpenCode Zen (for agent tool)
+ *   - isOpencodeFreeModel: Whether OpenCode Zen provides this model for free
+ *   - originalProvider: Original provider for pricing reference
  * @returns {string} Formatted cost info string for markdown (empty if no data available)
  */
 const buildCostInfoString = (totalCostUSD, anthropicTotalCostUSD, pricingInfo) => {
   // Issue #1015: Don't show cost section when all values are unknown (clutters output)
   const hasPublic = totalCostUSD !== null && totalCostUSD !== undefined;
   const hasAnthropic = anthropicTotalCostUSD !== null && anthropicTotalCostUSD !== undefined;
-  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel);
-  if (!hasPublic && !hasAnthropic && !hasPricing) return '';
+  const hasPricing = pricingInfo && (pricingInfo.modelName || pricingInfo.tokenUsage || pricingInfo.isFreeModel || pricingInfo.isOpencodeFreeModel);
+  // Issue #1250: Check for OpenCode Zen actual cost
+  const hasOpencodeCost = pricingInfo?.opencodeCost !== null && pricingInfo?.opencodeCost !== undefined;
+  if (!hasPublic && !hasAnthropic && !hasPricing && !hasOpencodeCost) return '';
   let costInfo = '\n\n💰 **Cost estimation:**';
   if (pricingInfo?.modelName) {
     costInfo += `\n- Model: ${pricingInfo.modelName}`;
     if (pricingInfo.provider) costInfo += `\n- Provider: ${pricingInfo.provider}`;
   }
+  // Issue #1250: Show public pricing estimate based on original provider prices
   if (hasPublic) {
-    costInfo += pricingInfo?.isFreeModel ? '\n- Public pricing estimate: $0.00 (Free model)' : `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)} USD`;
-  } else if (hasPricing) costInfo += '\n- Public pricing estimate: unknown';
+    // For models with zero pricing from original provider, show as free
+    if (pricingInfo?.isFreeModel && totalCostUSD === 0) {
+      costInfo += '\n- Public pricing estimate: $0.00 (Free model)';
+    } else {
+      // Show actual public pricing estimate with original provider reference
+      const originalProviderRef = pricingInfo?.originalProvider ? ` (based on ${pricingInfo.originalProvider} prices)` : '';
+      costInfo += `\n- Public pricing estimate: $${totalCostUSD.toFixed(6)}${originalProviderRef}`;
+    }
+  } else if (hasPricing) {
+    costInfo += '\n- Public pricing estimate: unknown';
+  }
+  // Issue #1250: Show actual cost from OpenCode Zen for agent tool
+  if (hasOpencodeCost) {
+    if (pricingInfo.isOpencodeFreeModel) {
+      costInfo += '\n- Calculated by OpenCode Zen: $0.00 (Free model)';
+    } else {
+      costInfo += `\n- Calculated by OpenCode Zen: $${pricingInfo.opencodeCost.toFixed(6)}`;
+    }
+  }
   if (pricingInfo?.tokenUsage) {
     const u = pricingInfo.tokenUsage;
     let tokenInfo = `\n- Token usage: ${u.inputTokens?.toLocaleString() || 0} input, ${u.outputTokens?.toLocaleString() || 0} output`;