@link-assistant/agent 0.16.5 → 0.16.8

package/package.json

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

@@ -687,7 +687,7 @@ export namespace Provider {
     },
   };
 
-  const state = Instance.state(async () => {
+  export const state = Instance.state(async () => {
     using _ = log.time('state');
     const config = await Config.get();
     const database = await ModelsDev.get();
@@ -1201,6 +1201,113 @@ export namespace Provider {
         sessionID: provider.id,
       });
 
+      // Wrap fetch with verbose HTTP logging when --verbose is enabled
+      // This logs raw HTTP request/response details for debugging provider issues
+      // See: https://github.com/link-assistant/agent/issues/200
+      if (Flag.OPENCODE_VERBOSE) {
+        const innerFetch = options['fetch'];
+        options['fetch'] = async (
+          input: RequestInfo | URL,
+          init?: RequestInit
+        ): Promise<Response> => {
+          const url =
+            typeof input === 'string'
+              ? input
+              : input instanceof URL
+                ? input.toString()
+                : input.url;
+          const method = init?.method ?? 'GET';
+
+          // Sanitize headers - mask authorization values
+          const sanitizedHeaders: Record<string, string> = {};
+          const rawHeaders = init?.headers;
+          if (rawHeaders) {
+            const entries =
+              rawHeaders instanceof Headers
+                ? Array.from(rawHeaders.entries())
+                : Array.isArray(rawHeaders)
+                  ? rawHeaders
+                  : Object.entries(rawHeaders);
+            for (const [key, value] of entries) {
+              const lower = key.toLowerCase();
+              if (
+                lower === 'authorization' ||
+                lower === 'x-api-key' ||
+                lower === 'api-key'
+              ) {
+                sanitizedHeaders[key] =
+                  typeof value === 'string' && value.length > 8
+                    ? value.slice(0, 4) + '...' + value.slice(-4)
+                    : '[REDACTED]';
+              } else {
+                sanitizedHeaders[key] = String(value);
+              }
+            }
+          }
+
+          // Log request body preview (truncated)
+          let bodyPreview: string | undefined;
+          if (init?.body) {
+            const bodyStr =
+              typeof init.body === 'string'
+                ? init.body
+                : init.body instanceof ArrayBuffer ||
+                    init.body instanceof Uint8Array
+                  ? `[binary ${(init.body as ArrayBuffer).byteLength ?? (init.body as Uint8Array).length} bytes]`
+                  : undefined;
+            if (bodyStr && typeof bodyStr === 'string') {
+              bodyPreview =
+                bodyStr.length > 2000
+                  ? bodyStr.slice(0, 2000) +
+                    `... [truncated, total ${bodyStr.length} chars]`
+                  : bodyStr;
+            }
+          }
+
+          log.info(() => ({
+            message: 'HTTP request',
+            providerID: provider.id,
+            method,
+            url,
+            headers: sanitizedHeaders,
+            bodyPreview,
+          }));
+
+          const startMs = Date.now();
+          try {
+            const response = await innerFetch(input, init);
+            const durationMs = Date.now() - startMs;
+
+            log.info(() => ({
+              message: 'HTTP response',
+              providerID: provider.id,
+              method,
+              url,
+              status: response.status,
+              statusText: response.statusText,
+              durationMs,
+              responseHeaders: Object.fromEntries(response.headers.entries()),
+            }));
+
+            return response;
+          } catch (error) {
+            const durationMs = Date.now() - startMs;
+            log.error(() => ({
+              message: 'HTTP request failed',
+              providerID: provider.id,
+              method,
+              url,
+              durationMs,
+              error:
+                error instanceof Error
+                  ? { name: error.name, message: error.message }
+                  : String(error),
+            }));
+            throw error;
+          }
+        };
+      }
+
       // Check if we have a bundled provider first - this avoids runtime package installation
       // which can hang or timeout due to known Bun issues
       // @see https://github.com/link-assistant/agent/issues/173
@@ -1310,8 +1417,21 @@ export namespace Provider {
 
     // 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 });
+    if (!isSyntheticProvider && !info) {
+      const availableInProvider = Object.keys(provider.info.models).slice(
+        0,
+        10
+      );
+      const suggestion = `Model "${modelID}" not found in provider "${providerID}". Available models: ${availableInProvider.join(', ')}${Object.keys(provider.info.models).length > 10 ? ` (and ${Object.keys(provider.info.models).length - 10} more)` : ''}.`;
+      log.error(() => ({
+        message: 'model not found in provider',
+        providerID,
+        modelID,
+        availableModels: availableInProvider,
+        totalModels: Object.keys(provider.info.models).length,
+      }));
+      throw new ModelNotFoundError({ providerID, modelID, suggestion });
+    }
 
     try {
       const keyReal = `${providerID}/${modelID}`;

package/src/session/processor.ts

@@ -298,6 +298,32 @@ export namespace SessionProcessor {
                   input.assistantMessage.cost += usage.cost;
                   input.assistantMessage.tokens = usage.tokens;
 
+                  // Log warning when provider returns zero tokens (#198)
+                  if (
+                    usage.tokens.input === 0 &&
+                    usage.tokens.output === 0 &&
+                    usage.tokens.reasoning === 0 &&
+                    finishReason === 'unknown'
+                  ) {
+                    log.warn(() => ({
+                      message:
+                        'provider returned zero tokens with unknown finish reason at step level',
+                      providerID: input.providerID,
+                      requestedModelID: input.model.id,
+                      respondedModelID:
+                        (value as any).response?.modelId ?? 'none',
+                      rawFinishReason: String(
+                        value.finishReason ?? 'undefined'
+                      ),
+                      rawUsage: JSON.stringify(value.usage ?? null),
+                      providerMetadata: JSON.stringify(
+                        value.providerMetadata ?? null
+                      ),
+                      issue:
+                        'https://github.com/link-assistant/agent/issues/198',
+                    }));
+                  }
+
                   // Build model info if --output-response-model flag is enabled
                   // @see https://github.com/link-assistant/agent/issues/179
                   const modelInfo: MessageV2.ModelInfo | undefined =

package/src/session/prompt.ts

@@ -297,17 +297,29 @@ export namespace SessionPrompt {
             tokens.output === 0 &&
             tokens.reasoning === 0
           ) {
+            const errorMessage =
+              `Provider returned zero tokens with unknown finish reason. ` +
+              `Requested model: ${lastAssistant.model?.requestedModelID ?? 'unknown'} ` +
+              `(provider: ${lastAssistant.model?.providerID ?? 'unknown'}). ` +
+              `Responded model: ${lastAssistant.model?.respondedModelID ?? 'unknown'}. ` +
+              `This usually indicates the provider failed to process the request. ` +
+              `Check provider status, model availability, and API keys.`;
             log.error(() => ({
-              message:
-                'provider returned zero tokens with unknown finish reason - possible API failure',
+              message: errorMessage,
               sessionID,
               finishReason: lastAssistant.finish,
               tokens,
               cost: lastAssistant.cost,
               model: lastAssistant.model,
-              hint: 'This usually indicates the provider failed to process the request. Check provider status, model availability, and API keys.',
-              issue: 'https://github.com/link-assistant/agent/issues/196',
+              issue: 'https://github.com/link-assistant/agent/issues/198',
             }));
+            // Publish error event so JSON standard output includes it (#198)
+            Bus.publish(Session.Event.Error, {
+              sessionID,
+              error: new NamedError.Unknown({
+                message: errorMessage,
+              }).toObject(),
+            });
             break;
           }
 
@@ -637,6 +649,8 @@ export namespace SessionPrompt {
         log.info(() => ({
           message: 'Model',
           model: `${model.providerID}/${model.modelID}`,
+          apiModelID: model.info?.id ?? model.modelID,
+          npm: model.npm,
         }));
         log.info(() => ({ message: 'Session ID', sessionID }));
         log.info(() => ({ message: 'Agent', agent: agent.name }));