v3.7.0: dynamic model fetching + ADR-001 tiered tool-payload reduction

Author: Abbalochdev

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [3.7.0](https://github.com/abbalochdev/opencode-for-copilot/compare/v3.6.0...v3.7.0) (2026-07-26)
+
+### Features
+
+* **models:** dynamic model fetching — model catalogue extracted from `consts.ts` into `provider/opencode-models.ts` (METADATA_OVERLAY as single source of truth); models are fetched asynchronously from the OpenCode Go/Zen APIs with a 5-minute cache and static fallback on network failure; unknown model IDs from the API get auto-generated defaults so they appear in the picker before a new extension release
+* **tools:** implement tiered tool-payload reduction for free-tier models (ADR-001) — deterministic stable sort + soft-cap trimming (`preferredToolLimit: 32`) for eligible request kinds (`main-agent`, `background`), preventing HTTP 500 errors when free models receive more tools than their server-side limit
+* **tools:** add reactive retry on HTTP 500 — when a request with >8 tools fails, retry once with half the tools before propagating the error (mirrors Claude Code's `hasAttemptedReactiveCompact` pattern)
+* **error:** improve HTTP 500 error message to include tool count when the request carried many tools, helping users diagnose payload-size issues
+
 ## [3.6.0](https://github.com/abbalochdev/opencode-for-copilot/compare/v3.5.0...v3.6.0) (2026-07-21)
 
 ### Features

package.json

@@ -3,7 +3,7 @@
   "displayName": "OpenCode for Copilot",
   "description": "Use OpenCode Go & Zen coding models (GLM, Kimi, DeepSeek, Claude, Grok, Qwen, free models) in the Copilot Chat model picker. Vision, thinking mode, agent tools — zero config, BYOK.",
   "icon": "resources/icon.png",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "packageManager": "pnpm@11.7.0",
   "publisher": "abbalochdev",
   "license": "MIT",

src/client/core.ts

@@ -10,7 +10,7 @@ import type {
 	StreamCallbacks,
 } from '../types';
 import { convertToAnthropicRequest, parseAnthropicStream } from './anthropic';
-import { createHttpError, formatRequestError, normalizeRequestError } from './error';
+import { createHttpError, formatRequestError, GLMRequestError, normalizeRequestError } from './error';
 
 /**
  * Lightweight SSE-streaming GLM API client.
@@ -29,16 +29,59 @@ export class GLMClient {
 	/**
 	 * Stream a chat completion from the GLM API.
 	 * Parses SSE chunks and dispatches callbacks for content, thinking, and tool calls.
+	 *
+	 * Tier 3 (reactive retry): if the first attempt fails with HTTP 500 and the
+	 * request carries more than 8 tools, retry once with half the tools — mirroring
+	 * Claude Code's `hasAttemptedReactiveCompact` pattern.  This covers the case
+	 * where a free-tier model's actual tool limit is lower than advertised.
 	 */
 	async streamChatCompletion(
 		request: GLMRequest,
 		callbacks: StreamCallbacks,
 		cancellationToken?: CancellationToken,
 	): Promise<void> {
-		if (this.protocol === 'anthropic') {
-			return this.streamAnthropicCompletion(request, callbacks, cancellationToken);
+		const dispatch = (req: GLMRequest) =>
+			this.protocol === 'anthropic'
+				? this.streamAnthropicCompletion(req, callbacks, cancellationToken)
+				: this.streamOpenAIChatCompletion(req, callbacks, cancellationToken);
+
+		try {
+			await dispatch(request);
+		} catch (error) {
+			if (isAbortError(error) && cancellationToken?.isCancellationRequested) {
+				return;
+			}
+			if (
+				error instanceof GLMRequestError
+				&& error.status === 500
+				&& (request.tools?.length ?? 0) > 8
+			) {
+				const halvedTools = request.tools!.slice(0, Math.ceil(request.tools!.length / 2));
+				logger.warn(
+					`Reactive retry: HTTP 500 with ${request.tools!.length} tools, retrying with ${halvedTools.length} tools`,
+				);
+				const retriedRequest = { ...request, tools: halvedTools };
+				try {
+					await dispatch(retriedRequest);
+				} catch (retryError) {
+					// Retry exhausted — propagate the retry error, not the original.
+					const normalizedRetry = normalizeRequestError(retryError, {
+						baseUrl: this.baseUrl,
+						request: retriedRequest,
+					});
+					logger.error('GLM reactive retry failed:', formatRequestError(normalizedRetry));
+					callbacks.onError(normalizedRetry);
+				}
+				return;
+			}
+			// Not retryable — propagate as before.
+			const normalizedError = normalizeRequestError(error, {
+				baseUrl: this.baseUrl,
+				request,
+			});
+			logger.error('GLM request failed:', formatRequestError(normalizedError));
+			callbacks.onError(normalizedError);
 		}
-		return this.streamOpenAIChatCompletion(request, callbacks, cancellationToken);
 	}
 
 	/**
@@ -232,16 +275,6 @@ export class GLMClient {
 			pendingToolCalls.clear();
 			reportFinalUsage(callbacks, latestUsage);
 			callbacks.onDone();
-		} catch (error) {
-			if (isAbortError(error) && cancellationToken?.isCancellationRequested) {
-				return;
-			}
-			const normalizedError = normalizeRequestError(error, {
-				baseUrl: this.baseUrl,
-				request,
-			});
-			logger.error('GLM request failed:', formatRequestError(normalizedError));
-			callbacks.onError(normalizedError);
 		} finally {
 			// Release the response stream lock on every exit path (`[DONE]`
 			// early-return, cancellation, normal completion and errors). On the
@@ -313,16 +346,6 @@ export class GLMClient {
 					}
 				});
 			}
-		} catch (error) {
-			if (isAbortError(error) && cancellationToken?.isCancellationRequested) {
-				return;
-			}
-			const normalizedError = normalizeRequestError(error, {
-				baseUrl: this.baseUrl,
-				request,
-			});
-			logger.error('GLM Anthropic request failed:', formatRequestError(normalizedError));
-			callbacks.onError(normalizedError);
 		} finally {
 			cancelListener?.dispose();
 			controller.abort();

src/client/error/index.ts

@@ -2,18 +2,18 @@ import { isOfficialGLMBaseUrl } from '../../endpoint';
 import { t } from '../../i18n';
 import { safeStringify } from '../../json';
 import {
-	API_PROVIDER_HTTP_ERROR_LINKS,
-	GLM_BUSINESS_ERROR_CODES,
-	MAX_DIAGNOSTIC_FIELD_LENGTH,
+    API_PROVIDER_HTTP_ERROR_LINKS,
+    GLM_BUSINESS_ERROR_CODES,
+    MAX_DIAGNOSTIC_FIELD_LENGTH,
 } from '../consts';
 import type {
-	ApiProviderId,
-	ErrorActionLink,
-	ErrorActionUrls,
-	GLMRequestErrorKind,
-	HttpErrorLinkDefinition,
-	HttpErrorLinkStatusKey,
-	RequestErrorContext,
+    ApiProviderId,
+    ErrorActionLink,
+    ErrorActionUrls,
+    GLMRequestErrorKind,
+    HttpErrorLinkDefinition,
+    HttpErrorLinkStatusKey,
+    RequestErrorContext,
 } from '../types';
 import { getNetworkErrorCauseInfo, getNetworkErrorCode, getNetworkErrorMessage } from './network';
 export type { ErrorActionUrls, GLMRequestErrorKind } from '../types';
@@ -82,6 +82,7 @@ export async function createHttpError(
 		baseUrl,
 		businessCode,
 		serverMessage,
+		toolCount: context.request.tools?.length,
 	});
 
 	return new GLMRequestError({
@@ -179,8 +180,9 @@ function getHttpErrorMessage(params: {
 	baseUrl: string;
 	businessCode?: string;
 	serverMessage?: string;
+	toolCount?: number;
 }): string {
-	const { status, baseUrl, businessCode, serverMessage } = params;
+	const { status, baseUrl, businessCode, serverMessage, toolCount } = params;
 	const isOfficialGlm = isOfficialGLMBaseUrl(baseUrl);
 
 	// 1) 已知业务错误码 → 使用官方错误表对应的精确文案。GLM 的服务端消息通常
@@ -209,7 +211,12 @@ function getHttpErrorMessage(params: {
 	}
 
 	// 4) 兜底：仅有 HTTP 状态码时，使用原有的状态码泛化文案。
-	return getHttpStatusMessage(status, baseUrl);
+	//    For 500 errors with many tools, suggest the payload may be too large.
+	const baseMessage = getHttpStatusMessage(status, baseUrl);
+	if (status === 500 && toolCount !== undefined && toolCount > 8) {
+		return `${baseMessage} — the request included ${toolCount} tools, which may exceed this model's limit`;
+	}
+	return baseMessage;
 }
 
 /**

src/config.ts

@@ -1,20 +1,23 @@
 import vscode from 'vscode';
 import { CONFIG_SECTION, MODELS } from './consts';
 import {
-    deriveEndpointPreset,
-    normalizeBaseUrl,
-    resolveApiKeyUrl,
-    resolveEndpointApiKeyUrl,
-    resolveEndpointBaseUrl,
-    resolveEndpointProtocol,
+	deriveEndpointPreset,
+	normalizeBaseUrl,
+	resolveApiKeyUrl,
+	resolveEndpointApiKeyUrl,
+	resolveEndpointBaseUrl,
+	resolveEndpointProtocol,
 } from './endpoint';
+import {
+	getDynamicModels
+} from './provider/opencode-models';
 import type {
-    ApiMode,
-    ApiProtocol,
-    ApiRegion,
-    CustomModelConfig,
-    EndpointPreset,
-    ModelDefinition,
+	ApiMode,
+	ApiProtocol,
+	ApiRegion,
+	CustomModelConfig,
+	EndpointPreset,
+	ModelDefinition,
 } from './types';
 
 export type DebugMode = 'minimal' | 'metadata' | 'verbose';
@@ -187,14 +190,39 @@ export function getCustomModels(): ModelDefinition[] {
 	return [...byId.values()];
 }
 
+/**
+ * Dynamic model list override. When set by `refreshDynamicModels()`, this is
+ * used instead of the static `MODELS` array. This lets us serve live model
+ * lists from the OpenCode API while keeping the static array as a fallback.
+ */
+let dynamicModelsOverride: readonly ModelDefinition[] | undefined;
+
+/**
+ * Synchronous model list — used by the model picker, request handler, and tests.
+ * Returns dynamic models if available, otherwise falls back to static MODELS.
+ */
 export function listProviderModels(): ModelDefinition[] {
-	const byId = new Map(MODELS.map((model) => [model.id, model]));
+	const source = dynamicModelsOverride ?? MODELS;
+	const byId = new Map(source.map((model) => [model.id, model]));
 	for (const model of getCustomModels()) {
 		byId.set(model.id, model);
 	}
 	return [...byId.values()];
 }
 
+/**
+ * Asynchronously refresh the model list from the OpenCode API.
+ * Updates `dynamicModelsOverride` and invalidates the cache so the next call
+ * to `listProviderModels()` returns fresh data.
+ *
+ * On network failure the existing list (or static fallback) stays in place.
+ */
+export async function refreshDynamicModels(): Promise<void> {
+	const customModels = getCustomModels();
+	const fallback = dynamicModelsOverride ?? MODELS;
+	dynamicModelsOverride = await getDynamicModels(customModels, fallback);
+}
+
 export function findModelDefinition(modelId: string): ModelDefinition | undefined {
 	return listProviderModels().find((model) => model.id === modelId);
 }