@link-assistant/agent 0.8.5 → 0.8.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/session/index.ts

@@ -408,9 +408,38 @@ export namespace Session {
     }
 
     try {
-      // Handle undefined/null explicitly - Number() would convert these to 0 or NaN
+      // Handle undefined/null gracefully by returning 0
+      // These are expected for optional fields like cachedInputTokens, reasoningTokens
+      // See: https://github.com/link-assistant/agent/issues/127
       if (value === undefined || value === null) {
-        throw new Error(`Cannot convert ${value} to number`);
+        if (Flag.OPENCODE_VERBOSE) {
+          log.debug(() => ({
+            message: 'toNumber received undefined/null, returning 0',
+            context,
+            valueType: typeof value,
+          }));
+        }
+        return 0;
+      }
+
+      // Handle objects with a 'total' field (e.g., { total: 8707, noCache: 6339, cacheRead: 2368 })
+      // Some AI providers return token counts as objects instead of plain numbers
+      // See: https://github.com/link-assistant/agent/issues/125
+      if (
+        typeof value === 'object' &&
+        value !== null &&
+        'total' in value &&
+        typeof (value as { total: unknown }).total === 'number'
+      ) {
+        const result = (value as { total: number }).total;
+        if (Flag.OPENCODE_VERBOSE) {
+          log.debug(() => ({
+            message: 'toNumber extracted total from object',
+            context,
+            result,
+          }));
+        }
+        return result;
       }
 
       // Try to convert to number
@@ -448,6 +477,90 @@ export namespace Session {
     }
   };
 
+  /**
+   * Safely converts a finishReason value to a string.
+   * Some AI providers return finishReason as an object instead of a string.
+   *
+   * For example, OpenCode provider on certain Bun versions may return:
+   * - { type: "stop" } instead of "stop"
+   * - { finishReason: "tool-calls" } instead of "tool-calls"
+   *
+   * This function handles these cases gracefully.
+   *
+   * @param value - The finishReason value (string, object, or undefined)
+   * @returns A string representing the finish reason, or 'unknown' if conversion fails
+   * @see https://github.com/link-assistant/agent/issues/125
+   */
+  export const toFinishReason = (value: unknown): string => {
+    // Log input data in verbose mode to help identify issues
+    if (Flag.OPENCODE_VERBOSE) {
+      log.debug(() => ({
+        message: 'toFinishReason input',
+        valueType: typeof value,
+        value:
+          typeof value === 'object' ? JSON.stringify(value) : String(value),
+      }));
+    }
+
+    // If it's already a string, return it
+    if (typeof value === 'string') {
+      return value;
+    }
+
+    // If it's undefined or null, return 'unknown'
+    if (value === undefined || value === null) {
+      return 'unknown';
+    }
+
+    // If it's an object, try to extract a meaningful string
+    if (typeof value === 'object') {
+      const obj = value as Record<string, unknown>;
+
+      // Try common field names that might contain the reason
+      if (typeof obj.type === 'string') {
+        if (Flag.OPENCODE_VERBOSE) {
+          log.debug(() => ({
+            message: 'toFinishReason extracted type from object',
+            result: obj.type,
+          }));
+        }
+        return obj.type;
+      }
+
+      if (typeof obj.finishReason === 'string') {
+        if (Flag.OPENCODE_VERBOSE) {
+          log.debug(() => ({
+            message: 'toFinishReason extracted finishReason from object',
+            result: obj.finishReason,
+          }));
+        }
+        return obj.finishReason;
+      }
+
+      if (typeof obj.reason === 'string') {
+        if (Flag.OPENCODE_VERBOSE) {
+          log.debug(() => ({
+            message: 'toFinishReason extracted reason from object',
+            result: obj.reason,
+          }));
+        }
+        return obj.reason;
+      }
+
+      // If we can't extract a specific field, return JSON representation
+      if (Flag.OPENCODE_VERBOSE) {
+        log.debug(() => ({
+          message: 'toFinishReason could not extract string, using JSON',
+          result: JSON.stringify(value),
+        }));
+      }
+      return JSON.stringify(value);
+    }
+
+    // For any other type, convert to string
+    return String(value);
+  };
+
   export const getUsage = fn(
     z.object({
       model: z.custom<ModelsDev.Model>(),
@@ -468,9 +581,28 @@ export namespace Session {
       const safeNum = (n: number): number =>
         Number.isNaN(n) || !Number.isFinite(n) ? 0 : n;
 
-      const cachedInputTokens = safeNum(
+      // Extract top-level cachedInputTokens
+      const topLevelCachedInputTokens = safeNum(
         toNumber(input.usage.cachedInputTokens, 'cachedInputTokens')
       );
+
+      // Some providers (e.g., opencode/grok-code) nest cacheRead inside inputTokens object
+      // e.g., inputTokens: { total: 12703, noCache: 12511, cacheRead: 192 }
+      // See: https://github.com/link-assistant/agent/issues/127
+      const inputTokensObj = input.usage.inputTokens;
+      const nestedCacheRead =
+        typeof inputTokensObj === 'object' && inputTokensObj !== null
+          ? safeNum(
+              toNumber(
+                (inputTokensObj as { cacheRead?: unknown }).cacheRead,
+                'inputTokens.cacheRead'
+              )
+            )
+          : 0;
+
+      // Use top-level if available, otherwise fall back to nested
+      const cachedInputTokens = topLevelCachedInputTokens || nestedCacheRead;
+
       const excludesCachedTokens = !!(
         input.metadata?.['anthropic'] || input.metadata?.['bedrock']
       );
@@ -491,12 +623,28 @@ export namespace Session {
         )
       );
 
+      // Extract reasoning tokens - some providers nest it inside outputTokens
+      // e.g., outputTokens: { total: 562, text: -805, reasoning: 1367 }
+      // See: https://github.com/link-assistant/agent/issues/127
+      const topLevelReasoningTokens = safeNum(
+        toNumber(input.usage?.reasoningTokens, 'reasoningTokens')
+      );
+      const outputTokensObj = input.usage.outputTokens;
+      const nestedReasoning =
+        typeof outputTokensObj === 'object' && outputTokensObj !== null
+          ? safeNum(
+              toNumber(
+                (outputTokensObj as { reasoning?: unknown }).reasoning,
+                'outputTokens.reasoning'
+              )
+            )
+          : 0;
+      const reasoningTokens = topLevelReasoningTokens || nestedReasoning;
+
       const tokens = {
         input: Math.max(0, adjustedInputTokens), // Ensure non-negative
         output: safeNum(toNumber(input.usage.outputTokens, 'outputTokens')),
-        reasoning: safeNum(
-          toNumber(input.usage?.reasoningTokens, 'reasoningTokens')
-        ),
+        reasoning: reasoningTokens,
         cache: {
           write: cacheWriteTokens,
           read: cachedInputTokens,

package/src/session/processor.ts

@@ -224,12 +224,17 @@ export namespace SessionProcessor {
                     usage: value.usage,
                     metadata: value.providerMetadata,
                   });
-                  input.assistantMessage.finish = value.finishReason;
+                  // Use toFinishReason to safely convert object/string finishReason to string
+                  // See: https://github.com/link-assistant/agent/issues/125
+                  const finishReason = Session.toFinishReason(
+                    value.finishReason
+                  );
+                  input.assistantMessage.finish = finishReason;
                   input.assistantMessage.cost += usage.cost;
                   input.assistantMessage.tokens = usage.tokens;
                   await Session.updatePart({
                     id: Identifier.ascending('part'),
-                    reason: value.finishReason,
+                    reason: finishReason,
                     snapshot: await Snapshot.track(),
                     messageID: input.assistantMessage.id,
                     sessionID: input.assistantMessage.sessionID,
@@ -274,13 +279,19 @@ export namespace SessionProcessor {
 
                 case 'text-delta':
                   if (currentText) {
-                    currentText.text += value.text;
+                    // Handle case where value.text might be an object instead of string
+                    // See: https://github.com/link-assistant/agent/issues/125
+                    const textDelta =
+                      typeof value.text === 'string'
+                        ? value.text
+                        : String(value.text);
+                    currentText.text += textDelta;
                     if (value.providerMetadata)
                       currentText.metadata = value.providerMetadata;
                     if (currentText.text)
                       await Session.updatePart({
                         part: currentText,
-                        delta: value.text,
+                        delta: textDelta,
                       });
                   }
                   break;