@link-assistant/agent 0.13.5 → 0.14.0

package/package.json

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

@@ -82,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

package/src/index.js

@@ -2,7 +2,6 @@
 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';
@@ -743,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
@@ -906,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/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/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/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);