@link-assistant/agent 0.13.4 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "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/bun/index.ts

@@ -141,6 +141,14 @@ export namespace BunProc {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  /**
+   * Staleness threshold for 'latest' version packages (24 hours).
+   * Packages installed as 'latest' will be refreshed after this period.
+   * This ensures users get updated packages with bug fixes and new features.
+   * @see https://github.com/link-assistant/agent/issues/177
+   */
+  const LATEST_VERSION_STALE_THRESHOLD_MS = 24 * 60 * 60 * 1000;
+
   export async function install(pkg: string, version = 'latest') {
     const mod = path.join(Global.Path.cache, 'node_modules', pkg);
 
@@ -150,11 +158,41 @@ export namespace BunProc {
 
     const pkgjson = Bun.file(path.join(Global.Path.cache, 'package.json'));
     const parsed = await pkgjson.json().catch(async () => {
-      const result = { dependencies: {} };
+      const result = { dependencies: {}, _installTime: {} };
       await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2));
       return result;
     });
-    if (parsed.dependencies[pkg] === version) return mod;
+
+    // Initialize _installTime tracking if not present
+    if (!parsed._installTime) {
+      parsed._installTime = {};
+    }
+
+    // Check if package is already installed with the requested version
+    const installedVersion = parsed.dependencies[pkg];
+    const installTime = parsed._installTime[pkg] as number | undefined;
+
+    if (installedVersion === version) {
+      // For 'latest' version, check if installation is stale and needs refresh
+      // This ensures users get updated packages with important fixes
+      // @see https://github.com/link-assistant/agent/issues/177 (specificationVersion v3 support)
+      if (version === 'latest' && installTime) {
+        const age = Date.now() - installTime;
+        if (age < LATEST_VERSION_STALE_THRESHOLD_MS) {
+          return mod;
+        }
+        log.info(() => ({
+          message: 'refreshing stale latest package',
+          pkg,
+          version,
+          ageMs: age,
+          threshold: LATEST_VERSION_STALE_THRESHOLD_MS,
+        }));
+      } else if (version !== 'latest') {
+        // For explicit versions, don't reinstall
+        return mod;
+      }
+    }
 
     // Check for dry-run mode
     if (Flag.OPENCODE_DRY_RUN) {
@@ -205,6 +243,8 @@ export namespace BunProc {
           attempt,
         }));
         parsed.dependencies[pkg] = version;
+        // Track installation time for 'latest' version staleness checks
+        parsed._installTime[pkg] = Date.now();
         await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2));
         return mod;
       } catch (e) {

package/src/flag/flag.ts

@@ -4,6 +4,11 @@ export namespace Flag {
     return process.env[newKey] ?? process.env[oldKey];
   }
 
+  function truthy(key: string) {
+    const value = process.env[key]?.toLowerCase();
+    return value === 'true' || value === '1';
+  }
+
   function truthyCompat(newKey: string, oldKey: string): boolean {
     const value = (getEnv(newKey, oldKey) ?? '').toLowerCase();
     return value === 'true' || value === '1';
@@ -77,6 +82,40 @@ export namespace Flag {
     GENERATE_TITLE = value;
   }
 
+  // Output response model information in step-finish parts
+  // Enabled by default - includes model info (providerID, requestedModelID, respondedModelID) in output
+  // Can be disabled with AGENT_OUTPUT_RESPONSE_MODEL=false
+  // See: https://github.com/link-assistant/agent/issues/179
+  export let OUTPUT_RESPONSE_MODEL = (() => {
+    const value = (
+      getEnv(
+        'LINK_ASSISTANT_AGENT_OUTPUT_RESPONSE_MODEL',
+        'AGENT_OUTPUT_RESPONSE_MODEL'
+      ) ?? ''
+    ).toLowerCase();
+    if (value === 'false' || value === '0') return false;
+    return true; // Default to true
+  })();
+
+  // Allow setting output-response-model mode programmatically (e.g., from CLI --output-response-model flag)
+  export function setOutputResponseModel(value: boolean) {
+    OUTPUT_RESPONSE_MODEL = value;
+  }
+
+  // Session summarization configuration
+  // When disabled, session summaries will not be generated
+  // This saves tokens and prevents rate limit issues with free tier models
+  // See: https://github.com/link-assistant/agent/issues/179
+  export let SUMMARIZE_SESSION = truthyCompat(
+    'LINK_ASSISTANT_AGENT_SUMMARIZE_SESSION',
+    'AGENT_SUMMARIZE_SESSION'
+  );
+
+  // Allow setting summarize-session mode programmatically (e.g., from CLI --summarize-session flag)
+  export function setSummarizeSession(value: boolean) {
+    SUMMARIZE_SESSION = value;
+  }
+
   // Retry timeout configuration
   // Maximum total time to keep retrying for the same error type (default: 7 days in seconds)
   // For different error types, the timer resets
@@ -155,9 +194,4 @@ export namespace Flag {
   export function setCompactJson(value: boolean) {
     _compactJson = value;
   }
-
-  function truthy(key: string) {
-    const value = process.env[key]?.toLowerCase();
-    return value === 'true' || value === '1';
-  }
 }

package/src/index.js

@@ -1,9 +1,7 @@
 #!/usr/bin/env bun
-
+import { Flag } from './flag/flag.ts';
 import { setProcessName } from './cli/process-name.ts';
-
 setProcessName('agent');
-
 import { Server } from './server/server.ts';
 import { Instance } from './project/instance.ts';
 import { Log } from './util/log.ts';
@@ -19,7 +17,6 @@ import {
 } from './json-standard/index.ts';
 import { McpCommand } from './cli/cmd/mcp.ts';
 import { AuthCommand } from './cli/cmd/auth.ts';
-import { Flag } from './flag/flag.ts';
 import { FormatError } from './cli/error.ts';
 import { UI } from './cli/ui.ts';
 import {
@@ -745,6 +742,16 @@ async function main() {
               type: 'number',
               description:
                 'Maximum total retry time in seconds for rate limit errors (default: 604800 = 7 days)',
+            })
+            .option('output-response-model', {
+              type: 'boolean',
+              description: 'Include model info in step_finish output',
+              default: true,
+            })
+            .option('summarize-session', {
+              type: 'boolean',
+              description: 'Generate AI session summaries',
+              default: false,
             }),
         handler: async (argv) => {
           // Check both CLI flag and environment variable for compact JSON mode
@@ -908,37 +915,30 @@ async function main() {
           await runAgentMode(argv, request);
         },
       })
-      // Initialize logging early for all CLI commands
-      // This prevents debug output from appearing in CLI unless --verbose is used
+      // Initialize logging and flags early for all CLI commands
       .middleware(async (argv) => {
-        // Set global compact JSON setting (CLI flag or environment variable)
         const isCompact = argv['compact-json'] === true || Flag.COMPACT_JSON();
         if (isCompact) {
           setCompactJson(true);
         }
-
-        // Set verbose flag if requested
         if (argv.verbose) {
           Flag.setVerbose(true);
         }
-
-        // Set dry-run flag if requested
         if (argv['dry-run']) {
           Flag.setDryRun(true);
         }
-
-        // Set generate-title flag if explicitly enabled
-        // Default is false to save tokens and prevent rate limit issues
-        // See: https://github.com/link-assistant/agent/issues/157
         if (argv['generate-title'] === true) {
           Flag.setGenerateTitle(true);
         }
-
-        // Initialize logging system
-        // - Print logs to stdout only when verbose for clean CLI output
-        // - Use verbose flag to enable DEBUG level logging
+        // output-response-model is enabled by default, only set if explicitly disabled
+        if (argv['output-response-model'] === false) {
+          Flag.setOutputResponseModel(false);
+        }
+        if (argv['summarize-session'] === true) {
+          Flag.setSummarizeSession(true);
+        }
         await Log.init({
-          print: Flag.OPENCODE_VERBOSE, // Output logs only when verbose for clean CLI output
+          print: Flag.OPENCODE_VERBOSE,
           level: Flag.OPENCODE_VERBOSE ? 'DEBUG' : 'INFO',
           compactJson: isCompact,
         });

package/src/provider/models.ts

@@ -131,8 +131,11 @@ export namespace ModelsDev {
     if (result) return result as Record<string, Provider>;
 
     // Fallback to bundled data if cache read failed
-    log.warn(() => ({
-      message: 'cache read failed, using bundled data',
+    // This is expected behavior when the cache is unavailable or corrupted
+    // Using info level since bundled data is a valid fallback mechanism
+    // @see https://github.com/link-assistant/agent/issues/177
+    log.info(() => ({
+      message: 'cache unavailable, using bundled data',
       path: filepath,
     }));
     const json = await data();

package/src/provider/provider.ts

@@ -1297,11 +1297,25 @@ export namespace Provider {
     }
   }
 
+  /**
+   * Get a small/cheap model for auxiliary tasks like title generation and summarization.
+   * This is NOT the primary model for user requests - it's used for background tasks.
+   *
+   * Note: Logs from this function may show a different model than what the user specified.
+   * This is by design - we use cheaper models for auxiliary tasks to save tokens/costs.
+   *
+   * @see https://github.com/link-assistant/agent/issues/179
+   */
   export async function getSmallModel(providerID: string) {
     const cfg = await Config.get();
 
     if (cfg.small_model) {
       const parsed = parseModel(cfg.small_model);
+      log.info(() => ({
+        message: 'using configured small_model for auxiliary task',
+        modelID: parsed.modelID,
+        providerID: parsed.providerID,
+      }));
       return getModel(parsed.providerID, parsed.modelID);
     }
 
@@ -1339,7 +1353,15 @@ export namespace Provider {
     }
     for (const item of priority) {
       for (const model of Object.keys(provider.info.models)) {
-        if (model.includes(item)) return getModel(providerID, model);
+        if (model.includes(item)) {
+          log.info(() => ({
+            message: 'selected small model for auxiliary task',
+            modelID: model,
+            providerID,
+            hint: 'This model is used for title/summary generation, not primary requests',
+          }));
+          return getModel(providerID, model);
+        }
       }
     }
   }

package/src/provider/retry-fetch.ts

@@ -130,8 +130,8 @@ export namespace RetryFetch {
       log.info(() => ({
         message: 'using retry-after value',
         retryAfterMs,
-        delay,
-        minInterval,
+        delayMs: delay,
+        minIntervalMs: minInterval,
       }));
       return addJitter(delay);
     }
@@ -145,10 +145,10 @@ export namespace RetryFetch {
     log.info(() => ({
       message: 'no retry-after header, using exponential backoff',
       attempt,
-      backoffDelay,
-      delay,
-      minInterval,
-      maxBackoffDelay,
+      backoffDelayMs: backoffDelay,
+      delayMs: delay,
+      minIntervalMs: minInterval,
+      maxBackoffDelayMs: maxBackoffDelay,
     }));
     return addJitter(delay);
   }
@@ -334,8 +334,8 @@ export namespace RetryFetch {
                 message:
                   'network error retry timeout exceeded, re-throwing error',
                 sessionID,
-                elapsed,
-                maxRetryTimeout,
+                elapsedMs: elapsed,
+                maxRetryTimeoutMs: maxRetryTimeout,
                 error: (error as Error).message,
               }));
               throw error;
@@ -350,7 +350,7 @@ export namespace RetryFetch {
               message: 'network error, retrying',
               sessionID,
               attempt,
-              delay,
+              delayMs: delay,
               error: (error as Error).message,
             }));
             await sleep(delay, init?.signal ?? undefined);
@@ -370,8 +370,8 @@ export namespace RetryFetch {
           log.warn(() => ({
             message: 'retry timeout exceeded in fetch wrapper, returning 429',
             sessionID,
-            elapsed,
-            maxRetryTimeout,
+            elapsedMs: elapsed,
+            maxRetryTimeoutMs: maxRetryTimeout,
           }));
           return response; // Let higher-level handling take over
         }
@@ -390,8 +390,8 @@ export namespace RetryFetch {
             message:
               'retry-after exceeds remaining timeout, returning 429 response',
             sessionID,
-            elapsed,
-            remainingTimeout: maxRetryTimeout - elapsed,
+            elapsedMs: elapsed,
+            remainingTimeoutMs: maxRetryTimeout - elapsed,
           }));
           return response;
         }
@@ -401,9 +401,9 @@ export namespace RetryFetch {
           log.warn(() => ({
             message: 'delay would exceed retry timeout, returning 429 response',
             sessionID,
-            elapsed,
-            delay,
-            maxRetryTimeout,
+            elapsedMs: elapsed,
+            delayMs: delay,
+            maxRetryTimeoutMs: maxRetryTimeout,
           }));
           return response;
         }
@@ -414,11 +414,11 @@ export namespace RetryFetch {
           message: 'rate limited, will retry',
           sessionID,
           attempt,
-          delay,
+          delayMs: delay,
           delayMinutes: (delay / 1000 / 60).toFixed(2),
           delayHours: (delay / 1000 / 3600).toFixed(2),
-          elapsed,
-          remainingTimeout,
+          elapsedMs: elapsed,
+          remainingTimeoutMs: remainingTimeout,
           remainingTimeoutHours: (remainingTimeout / 1000 / 3600).toFixed(2),
           isolatedSignal: true, // Indicates we're using isolated signal for this wait
         }));

package/src/session/message-v2.ts

@@ -224,6 +224,22 @@ export namespace MessageV2 {
   });
   export type StepStartPart = z.infer<typeof StepStartPart>;
 
+  /**
+   * Model information for output parts.
+   * Included when --output-response-model flag is enabled.
+   * @see https://github.com/link-assistant/agent/issues/179
+   */
+  export const ModelInfo = z
+    .object({
+      providerID: z.string(),
+      requestedModelID: z.string(),
+      respondedModelID: z.string().optional(),
+    })
+    .meta({
+      ref: 'ModelInfo',
+    });
+  export type ModelInfo = z.infer<typeof ModelInfo>;
+
   export const StepFinishPart = PartBase.extend({
     type: z.literal('step-finish'),
     reason: z.string(),
@@ -238,6 +254,9 @@ export namespace MessageV2 {
         write: z.number(),
       }),
     }),
+    // Model info included when --output-response-model is enabled
+    // @see https://github.com/link-assistant/agent/issues/179
+    model: ModelInfo.optional(),
   }).meta({
     ref: 'StepFinishPart',
   });

package/src/session/processor.ts

@@ -16,6 +16,7 @@ import { SessionSummary } from './summary';
 import { Bus } from '../bus';
 import { SessionRetry } from './retry';
 import { SessionStatus } from './status';
+import { Flag } from '../flag/flag';
 
 export namespace SessionProcessor {
   const DOOM_LOOP_THRESHOLD = 3;
@@ -261,6 +262,21 @@ export namespace SessionProcessor {
                   input.assistantMessage.finish = finishReason;
                   input.assistantMessage.cost += usage.cost;
                   input.assistantMessage.tokens = usage.tokens;
+
+                  // Build model info if --output-response-model flag is enabled
+                  // @see https://github.com/link-assistant/agent/issues/179
+                  const modelInfo: MessageV2.ModelInfo | undefined =
+                    Flag.OUTPUT_RESPONSE_MODEL
+                      ? {
+                          providerID: input.providerID,
+                          requestedModelID: input.model.id,
+                          // Get respondedModelID from finish-step response if available
+                          // AI SDK includes response.modelId when available from provider
+                          respondedModelID:
+                            (value as any).response?.modelId ?? undefined,
+                        }
+                      : undefined;
+
                   await Session.updatePart({
                     id: Identifier.ascending('part'),
                     reason: finishReason,
@@ -270,6 +286,7 @@ export namespace SessionProcessor {
                     type: 'step-finish',
                     tokens: usage.tokens,
                     cost: usage.cost,
+                    model: modelInfo,
                   });
                   await Session.updateMessage(input.assistantMessage);
                   if (snapshot) {

package/src/session/retry.ts

@@ -94,8 +94,8 @@ export namespace SessionRetry {
         message: 'retry timeout exceeded',
         sessionID,
         errorType,
-        elapsedTime,
-        maxTime,
+        elapsedTimeMs: elapsedTime,
+        maxTimeMs: maxTime,
       }));
       return { shouldRetry: false, elapsedTime, maxTime };
     }
@@ -245,8 +245,8 @@ export namespace SessionRetry {
       log.info(() => ({
         message: 'no retry-after header, using exponential backoff',
         attempt,
-        backoffDelay,
-        maxBackoffDelay,
+        backoffDelayMs: backoffDelay,
+        maxBackoffDelayMs: maxBackoffDelay,
       }));
       return addJitter(backoffDelay);
     }
@@ -260,8 +260,8 @@ export namespace SessionRetry {
       message:
         'no response headers, using exponential backoff with conservative cap',
       attempt,
-      backoffDelay,
-      maxCap: RETRY_MAX_DELAY_NO_HEADERS,
+      backoffDelayMs: backoffDelay,
+      maxCapMs: RETRY_MAX_DELAY_NO_HEADERS,
     }));
     return addJitter(backoffDelay);
   }

package/src/session/summary.ts

@@ -13,6 +13,7 @@ import path from 'path';
 import { Instance } from '../project/instance';
 import { Storage } from '../storage/storage';
 import { Bus } from '../bus';
+import { Flag } from '../flag/flag';
 
 export namespace SessionSummary {
   const log = Log.create({ service: 'session.summary' });
@@ -79,6 +80,16 @@ export namespace SessionSummary {
     };
     await Session.updateMessage(userMsg);
 
+    // Skip AI-powered summarization if disabled (default)
+    // See: https://github.com/link-assistant/agent/issues/179
+    if (!Flag.SUMMARIZE_SESSION) {
+      log.info(() => ({
+        message: 'session summarization disabled',
+        hint: 'Enable with --summarize-session flag or AGENT_SUMMARIZE_SESSION=true',
+      }));
+      return;
+    }
+
     const assistantMsg = messages.find((m) => m.info.role === 'assistant')!
       .info as MessageV2.Assistant;
     const small = await Provider.getSmallModel(assistantMsg.providerID);