@link-assistant/agent 0.5.2 → 0.6.0

package/src/provider/echo.ts

@@ -0,0 +1,174 @@
+/**
+ * Echo Provider - A synthetic provider for testing dry-run mode
+ *
+ * This provider echoes back the user's input message without making actual API calls.
+ * It's designed to enable robust testing of round-trips and multi-turn conversations
+ * without incurring API costs.
+ *
+ * Usage:
+ *   agent --dry-run -p "hello"  # Uses echo provider automatically
+ *   agent --model link-assistant/echo -p "hello"  # Explicit usage
+ *
+ * The echo behavior follows the issue #89 specification:
+ *   Input: "hi" -> Output: "hi"
+ *   Input: "How are you?" -> Output: "How are you?"
+ */
+
+import type { LanguageModelV2, LanguageModelV2CallOptions } from 'ai';
+import { Log } from '../util/log';
+
+const log = Log.create({ service: 'provider.echo' });
+
+/**
+ * Extract text content from the prompt messages
+ */
+function extractTextFromPrompt(
+  prompt: LanguageModelV2CallOptions['prompt']
+): string {
+  const textParts: string[] = [];
+
+  for (const message of prompt) {
+    if (message.role === 'user') {
+      for (const part of message.content) {
+        if (part.type === 'text') {
+          textParts.push(part.text);
+        }
+      }
+    }
+  }
+
+  // Return the last user message or a default response
+  return textParts.length > 0
+    ? textParts[textParts.length - 1]
+    : 'Echo: No user message found';
+}
+
+/**
+ * Generate a unique ID for streaming parts
+ */
+function generatePartId(): string {
+  return `echo_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+
+/**
+ * Creates an echo language model that echoes back the user's input
+ * Implements LanguageModelV2 interface for AI SDK 6.x compatibility
+ */
+export function createEchoModel(modelId: string = 'echo'): LanguageModelV2 {
+  const model: LanguageModelV2 = {
+    specificationVersion: 'v2',
+    provider: 'link-assistant',
+    modelId,
+
+    // No external URLs are supported by this synthetic provider
+    supportedUrls: {},
+
+    async doGenerate(options: LanguageModelV2CallOptions) {
+      const echoText = extractTextFromPrompt(options.prompt);
+      log.info('echo generate', { modelId, echoText });
+
+      // Simulate token usage
+      const promptTokens = Math.ceil(echoText.length / 4);
+      const completionTokens = Math.ceil(echoText.length / 4);
+
+      return {
+        content: [
+          {
+            type: 'text' as const,
+            text: echoText,
+          },
+        ],
+        finishReason: 'stop' as const,
+        usage: {
+          promptTokens,
+          completionTokens,
+        },
+        warnings: [],
+        providerMetadata: undefined,
+        request: undefined,
+        response: undefined,
+      };
+    },
+
+    async doStream(options: LanguageModelV2CallOptions) {
+      const echoText = extractTextFromPrompt(options.prompt);
+      log.info('echo stream', { modelId, echoText });
+
+      // Simulate token usage
+      const promptTokens = Math.ceil(echoText.length / 4);
+      const completionTokens = Math.ceil(echoText.length / 4);
+
+      const textPartId = generatePartId();
+
+      // Create a ReadableStream with LanguageModelV2StreamPart format
+      // V2 format uses: text-start -> text-delta (with delta) -> text-end -> finish
+      const stream = new ReadableStream({
+        async start(controller) {
+          // Emit text-start
+          controller.enqueue({
+            type: 'text-start',
+            id: textPartId,
+            providerMetadata: undefined,
+          });
+
+          // Emit the text in chunks for realistic streaming behavior
+          const chunkSize = 10;
+          for (let i = 0; i < echoText.length; i += chunkSize) {
+            const chunk = echoText.slice(i, i + chunkSize);
+            controller.enqueue({
+              type: 'text-delta',
+              id: textPartId,
+              delta: chunk,
+              providerMetadata: undefined,
+            });
+          }
+
+          // Emit text-end
+          controller.enqueue({
+            type: 'text-end',
+            id: textPartId,
+            providerMetadata: undefined,
+          });
+
+          // Emit finish event with usage information
+          controller.enqueue({
+            type: 'finish',
+            finishReason: 'stop',
+            usage: {
+              promptTokens,
+              completionTokens,
+            },
+            providerMetadata: undefined,
+          });
+
+          controller.close();
+        },
+      });
+
+      return {
+        stream,
+        request: undefined,
+        response: undefined,
+        warnings: [],
+      };
+    },
+  };
+
+  return model;
+}
+
+/**
+ * Echo provider factory function - follows AI SDK provider pattern
+ */
+export function createEchoProvider(options?: { name?: string }) {
+  return {
+    languageModel(modelId: string): LanguageModelV2 {
+      return createEchoModel(modelId);
+    },
+    textEmbeddingModel() {
+      throw new Error('Echo provider does not support text embeddings');
+    },
+  };
+}
+
+export const echoProvider = createEchoProvider();

package/src/provider/models.ts

@@ -78,18 +78,17 @@ export namespace ModelsDev {
 
   export async function refresh() {
     const file = Bun.file(filepath);
-    log.info('refreshing', {
-      file,
-    });
+    log.info(() => ({ message: 'refreshing', file }));
     const result = await fetch('https://models.dev/api.json', {
       headers: {
         'User-Agent': 'agent-cli/1.0.0',
       },
       signal: AbortSignal.timeout(10 * 1000),
     }).catch((e) => {
-      log.error('Failed to fetch models.dev', {
+      log.error(() => ({
+        message: 'Failed to fetch models.dev',
         error: e,
-      });
+      }));
     });
     if (result && result.ok) await Bun.write(file, await result.text());
   }

package/src/provider/provider.ts

@@ -14,6 +14,8 @@ import { Instance } from '../project/instance';
 import { Global } from '../global';
 import { Flag } from '../flag/flag';
 import { iife } from '../util/iife';
+import { createEchoModel } from './echo';
+import { createCacheModel } from './cache';
 
 export namespace Provider {
   const log = Log.create({ service: 'provider' });
@@ -35,7 +37,7 @@ export namespace Provider {
       // Check if OAuth credentials are available via the auth plugin
       const auth = await Auth.get('anthropic');
       if (auth?.type === 'oauth') {
-        log.info('using anthropic oauth credentials');
+        log.info(() => ({ message: 'using anthropic oauth credentials' }));
         const loaderFn = await AuthPlugins.getLoader('anthropic');
         if (loaderFn) {
           const result = await loaderFn(() => Auth.get('anthropic'), input);
@@ -328,7 +330,7 @@ export namespace Provider {
     google: async (input) => {
       const auth = await Auth.get('google');
       if (auth?.type === 'oauth') {
-        log.info('using google oauth credentials');
+        log.info(() => ({ message: 'using google oauth credentials' }));
         const loaderFn = await AuthPlugins.getLoader('google');
         if (loaderFn) {
           const result = await loaderFn(() => Auth.get('google'), input);
@@ -353,7 +355,9 @@ export namespace Provider {
     'github-copilot': async (input) => {
       const auth = await Auth.get('github-copilot');
       if (auth?.type === 'oauth') {
-        log.info('using github copilot oauth credentials');
+        log.info(() => ({
+          message: 'using github copilot oauth credentials',
+        }));
         const loaderFn = await AuthPlugins.getLoader('github-copilot');
         if (loaderFn) {
           const result = await loaderFn(
@@ -381,7 +385,9 @@ export namespace Provider {
     'github-copilot-enterprise': async (input) => {
       const auth = await Auth.get('github-copilot-enterprise');
       if (auth?.type === 'oauth') {
-        log.info('using github copilot enterprise oauth credentials');
+        log.info(() => ({
+          message: 'using github copilot enterprise oauth credentials',
+        }));
         const loaderFn = await AuthPlugins.getLoader('github-copilot');
         if (loaderFn) {
           const result = await loaderFn(
@@ -433,7 +439,10 @@ export namespace Provider {
         return { autoload: false };
       }
 
-      log.info('using claude oauth credentials', { source: tokenSource });
+      log.info(() => ({
+        message: 'using claude oauth credentials',
+        source: tokenSource,
+      }));
 
       // Create authenticated fetch with Bearer token and OAuth beta header
       const customFetch = ClaudeOAuth.createAuthenticatedFetch(oauthToken);
@@ -452,6 +461,56 @@ export namespace Provider {
         },
       };
     },
+    /**
+     * Echo provider - synthetic provider for dry-run testing
+     * Echoes back the user's input without making actual API calls.
+     *
+     * This provider is automatically enabled when --dry-run mode is active.
+     * It can also be used explicitly with: --model link-assistant/echo
+     *
+     * @see https://github.com/link-assistant/agent/issues/89
+     */
+    'link-assistant': async () => {
+      // Echo provider is always available - no external dependencies needed
+      return {
+        autoload: Flag.OPENCODE_DRY_RUN, // Auto-load only in dry-run mode
+        async getModel(_sdk: any, modelID: string) {
+          // Return our custom echo model that implements LanguageModelV1
+          return createEchoModel(modelID);
+        },
+        options: {},
+      };
+    },
+    /**
+     * Cache provider - synthetic provider for caching API responses
+     * Caches responses using links notation for deterministic testing.
+     *
+     * This provider caches API responses and falls back to echo behavior.
+     * It can be used explicitly with: --model link-assistant/cache/opencode/grok-code
+     *
+     * @see https://github.com/link-assistant/agent/issues/89
+     */
+    'link-assistant/cache': async () => {
+      // Cache provider is always available - no external dependencies needed
+      return {
+        autoload: false, // Not auto-loaded
+        async getModel(_sdk: any, modelID: string) {
+          // modelID should be in format "provider/model" like "opencode/grok-code"
+          const parts = modelID.split('/');
+          if (parts.length < 2) {
+            throw new Error(
+              `Invalid cache model ID: ${modelID}. Expected format: provider/model`
+            );
+          }
+          const [providerId, ...modelParts] = parts;
+          const actualModelId = modelParts.join('/');
+
+          // Return our custom cache model that implements LanguageModelV1
+          return createCacheModel(providerId, actualModelId);
+        },
+        options: {},
+      };
+    },
   };
 
   const state = Instance.state(async () => {
@@ -485,7 +544,7 @@ export namespace Provider {
     // Maps `${provider}/${key}` to the provider’s actual model ID for custom aliases.
     const realIdByKey = new Map<string, string>();
 
-    log.info('init');
+    log.info(() => ({ message: 'init' }));
 
     function mergeProvider(
       id: string,
@@ -555,6 +614,51 @@ export namespace Provider {
       realIdByKey.set('google/gemini-3-pro', 'gemini-3-pro-preview');
     }
 
+    // Add link-assistant echo provider for dry-run testing
+    // This synthetic provider echoes back user input without API calls
+    // @see https://github.com/link-assistant/agent/issues/89
+    database['link-assistant'] = {
+      id: 'link-assistant',
+      name: 'Link Assistant (Echo)',
+      env: [], // No environment variables needed - synthetic provider
+      models: {
+        echo: {
+          id: 'echo',
+          name: 'Echo Model',
+          release_date: '2024-01-01',
+          attachment: false,
+          reasoning: false,
+          temperature: false,
+          tool_call: true,
+          cost: {
+            input: 0,
+            output: 0,
+            cache_read: 0,
+            cache_write: 0,
+          },
+          limit: {
+            context: 1000000, // Virtually unlimited
+            output: 100000,
+          },
+          modalities: {
+            input: ['text'],
+            output: ['text'],
+          },
+          options: {},
+        },
+      },
+    };
+
+    // Add link-assistant/cache provider for caching API responses
+    // This synthetic provider caches responses and falls back to echo
+    // @see https://github.com/link-assistant/agent/issues/89
+    database['link-assistant/cache'] = {
+      id: 'link-assistant/cache',
+      name: 'Link Assistant (Cache)',
+      env: [], // No environment variables needed - synthetic provider
+      models: {}, // Models are dynamically created based on the provider/model syntax
+    };
+
     for (const [providerID, provider] of configProviders) {
       const existing = database[providerID];
       const parsed: ModelsDev.Provider = {
@@ -686,7 +790,7 @@ export namespace Provider {
         delete providers[providerID];
         continue;
       }
-      log.info('found', { providerID });
+      log.info(() => ({ message: 'found', providerID }));
     }
 
     return {
@@ -721,19 +825,21 @@ export namespace Provider {
 
       let installedPath: string;
       if (!pkg.startsWith('file://')) {
-        log.info('installing provider package', {
+        log.info(() => ({
+          message: 'installing provider package',
           providerID: provider.id,
           pkg,
           version: 'latest',
-        });
+        }));
         installedPath = await BunProc.install(pkg, 'latest');
-        log.info('provider package installed successfully', {
+        log.info(() => ({
+          message: 'provider package installed successfully',
           providerID: provider.id,
           pkg,
           installedPath,
-        });
+        }));
       } else {
-        log.info('loading local provider', { pkg });
+        log.info(() => ({ message: 'loading local provider', pkg }));
         installedPath = pkg;
       }
 
@@ -779,13 +885,14 @@ export namespace Provider {
       s.sdk.set(key, loaded);
       return loaded as SDK;
     })().catch((e) => {
-      log.error('provider initialization failed', {
+      log.error(() => ({
+        message: 'provider initialization failed',
         providerID: provider.id,
         pkg: model.provider?.npm ?? provider.npm ?? provider.id,
         error: e instanceof Error ? e.message : String(e),
         stack: e instanceof Error ? e.stack : undefined,
         cause: e instanceof Error && e.cause ? String(e.cause) : undefined,
-      });
+      }));
       throw new InitError({ providerID: provider.id }, { cause: e });
     });
   }
@@ -799,30 +906,45 @@ export namespace Provider {
     const s = await state();
     if (s.models.has(key)) return s.models.get(key)!;
 
-    log.info('getModel', {
-      providerID,
-      modelID,
-    });
+    log.info(() => ({ message: 'getModel', providerID, modelID }));
 
     const provider = s.providers[providerID];
     if (!provider) throw new ModelNotFoundError({ providerID, modelID });
-    const info = provider.info.models[modelID];
-    if (!info) throw new ModelNotFoundError({ providerID, modelID });
-    const sdk = await getSDK(provider.info, info);
+
+    // For synthetic providers (like link-assistant/echo and link-assistant/cache), skip SDK loading
+    // These providers have a custom getModel function that creates the model directly
+    const isSyntheticProvider =
+      providerID === 'link-assistant' || providerID === 'link-assistant/cache';
+
+    // For synthetic providers, we don't need model info from the database
+    const info = isSyntheticProvider ? null : provider.info.models[modelID];
+    if (!isSyntheticProvider && !info)
+      throw new ModelNotFoundError({ providerID, modelID });
 
     try {
       const keyReal = `${providerID}/${modelID}`;
-      const realID = s.realIdByKey.get(keyReal) ?? info.id;
-      const language = provider.getModel
-        ? await provider.getModel(sdk, realID, provider.options)
-        : sdk.languageModel(realID);
-      log.info('found', { providerID, modelID });
+      const realID = s.realIdByKey.get(keyReal) ?? (info ? info.id : modelID);
+
+      let language: LanguageModel;
+      if (isSyntheticProvider && provider.getModel) {
+        // For synthetic providers, call getModel directly without SDK
+        language = await provider.getModel(null, realID, provider.options);
+      } else {
+        // For regular providers, load the SDK first
+        const sdk = await getSDK(provider.info, info!);
+        language = provider.getModel
+          ? await provider.getModel(sdk, realID, provider.options)
+          : sdk.languageModel(realID);
+      }
+      log.info(() => ({ message: 'found', providerID, modelID }));
       s.models.set(key, {
         providerID,
         modelID,
         info,
         language,
-        npm: info.provider?.npm ?? provider.info.npm,
+        npm: isSyntheticProvider
+          ? provider.info.npm
+          : (info.provider?.npm ?? provider.info.npm),
       });
       return {
         modelID,
@@ -897,6 +1019,18 @@ export namespace Provider {
 
   export async function defaultModel() {
     const cfg = await Config.get();
+
+    // In dry-run mode, use the echo provider by default
+    // This allows testing round-trips and multi-turn conversations without API costs
+    // @see https://github.com/link-assistant/agent/issues/89
+    if (Flag.OPENCODE_DRY_RUN) {
+      log.info('dry-run mode enabled, using echo provider as default');
+      return {
+        providerID: 'link-assistant',
+        modelID: 'echo',
+      };
+    }
+
     if (cfg.model) return parseModel(cfg.model);
 
     // Prefer opencode provider if available
@@ -905,10 +1039,11 @@ export namespace Provider {
     if (opencodeProvider) {
       const [model] = sort(Object.values(opencodeProvider.info.models));
       if (model) {
-        log.info('using opencode provider as default', {
+        log.info(() => ({
+          message: 'using opencode provider as default',
           provider: opencodeProvider.info.id,
           model: model.id,
-        });
+        }));
         return {
           providerID: opencodeProvider.info.id,
           modelID: model.id,

package/src/server/server.ts

@@ -55,9 +55,7 @@ export namespace Server {
   export const App = lazy(() =>
     app
       .onError((err, c) => {
-        log.error('failed', {
-          error: err,
-        });
+        log.error(() => ({ message: 'failed', error: err }));
         if (err instanceof NamedError) {
           let status: ContentfulStatusCode;
           if (err instanceof Storage.NotFoundError) status = 404;
@@ -71,10 +69,11 @@ export namespace Server {
         });
       })
       .use(async (c, next) => {
-        log.info('request', {
+        log.info(() => ({
+          message: 'request',
           method: c.req.method,
           path: c.req.path,
-        });
+        }));
         const timer = log.time('request', {
           method: c.req.method,
           path: c.req.path,

package/src/session/agent.js

@@ -96,8 +96,22 @@ export class Agent {
             const errorTime = Date.now();
             const callID = `call_${Math.floor(Math.random() * 100000000)}`;
 
-            // Log full error to stderr for debugging
-            console.error('Tool execution error:', error);
+            // Log full error to stderr for debugging in JSON format
+            console.error(
+              JSON.stringify({
+                log: {
+                  level: 'error',
+                  timestamp: new Date().toISOString(),
+                  message: 'Tool execution error',
+                  tool: tool.name,
+                  error: {
+                    name: error.name,
+                    message: error.message,
+                    stack: error.stack,
+                  },
+                },
+              })
+            );
 
             // Emit tool_use event with error
             this.emitEvent('tool_use', {

package/src/session/compaction.ts

@@ -52,7 +52,7 @@ export namespace SessionCompaction {
   // tool calls that are no longer relevant.
   export async function prune(input: { sessionID: string }) {
     if (Flag.OPENCODE_DISABLE_PRUNE) return;
-    log.info('pruning');
+    log.info(() => ({ message: 'pruning' }));
     const msgs = await Session.messages({ sessionID: input.sessionID });
     let total = 0;
     let pruned = 0;
@@ -78,7 +78,7 @@ export namespace SessionCompaction {
           }
       }
     }
-    log.info('found', { pruned, total });
+    log.info(() => ({ message: 'found', pruned, total }));
     if (pruned > PRUNE_MINIMUM) {
       for (const part of toPrune) {
         if (part.state.status === 'completed') {
@@ -86,7 +86,7 @@ export namespace SessionCompaction {
           await Session.updatePart(part);
         }
       }
-      log.info('pruned', { count: toPrune.length });
+      log.info(() => ({ message: 'pruned', count: toPrune.length }));
     }
   }
 
@@ -139,9 +139,7 @@ export namespace SessionCompaction {
     const result = await processor.process(() =>
       streamText({
         onError(error) {
-          log.error('stream error', {
-            error,
-          });
+          log.error(() => ({ message: 'stream error', error }));
         },
         // set to 0, we handle loop
         maxRetries: 0,

package/src/session/index.ts

@@ -178,7 +178,7 @@ export namespace Session {
         updated: Date.now(),
       },
     };
-    log.info('created', result);
+    log.info(() => ({ message: 'created', ...result }));
     await Storage.write(['session', Instance.project.id, result.id], result);
     Bus.publish(Event.Created, {
       info: result,
@@ -273,7 +273,7 @@ export namespace Session {
         info: session,
       });
     } catch (e) {
-      log.error(e);
+      log.error(() => ({ error: e }));
     }
   });
 

package/src/session/processor.ts

@@ -39,7 +39,7 @@ export namespace SessionProcessor {
         return toolcalls[toolCallID];
       },
       async process(fn: () => StreamTextResult<Record<string, AITool>, never>) {
-        log.info('process');
+        log.info(() => ({ message: 'process' }));
         while (true) {
           try {
             let currentText: MessageV2.TextPart | undefined;
@@ -305,16 +305,12 @@ export namespace SessionProcessor {
                   break;
 
                 default:
-                  log.info('unhandled', {
-                    ...value,
-                  });
+                  log.info(() => ({ message: 'unhandled', ...value }));
                   continue;
               }
             }
           } catch (e) {
-            log.error('process', {
-              error: e,
-            });
+            log.error(() => ({ message: 'process', error: e }));
             const error = MessageV2.fromError(e, {
               providerID: input.providerID,
             });