@aragon-agent/core 0.2.25 → 0.2.27

package/CHANGELOG.md

@@ -5,7 +5,18 @@ All notable changes to `@aragon-agent/core` are documented here. Entries at
 — those releases really were published under that name, so they are left as they
 were written.
 
-## Unreleased
+## Unreleased
+
+### Fixed
+
+- Model context resolution now reads explicit OpenAI-compatible, Anthropic and
+  Google API limits, preserves their provenance, and resolves endpoint-scoped
+  discovery before catalog/alias fallbacks. Unknown limits stay marked as such.
+  Context metadata does not imply known pricing.
+- Google/Anthropic discovery follows bounded pagination under a single 15-second
+  deadline. All three adapters accept cancellation; cancelled or invalidated
+  lookups cannot overwrite current metadata. Clearing one provider's cache leaves
+  other providers' pending discoveries intact.
 
 ### Added
 

package/dist/engine/agent-loop.js

@@ -292,7 +292,9 @@ export async function runAgentLoop(ctx) {
         //   3. INSIDE the `while`, not before it. A run that starts under the
         //      threshold and crosses it at turn 12 is the normal case, and it is the
         //      case an `agent_end`-based design cannot serve at all (D-1).
-        await runCompaction(ctx, { trigger: 'pressure', lastUsage, turnIndex });
+        if (await runCompaction(ctx, { trigger: 'pressure', lastUsage, turnIndex })) {
+            lastUsage = undefined;
+        }
         if (ctx.signal.aborted)
             break;
         // ----- Turn start -----
@@ -351,6 +353,8 @@ export async function runAgentLoop(ctx) {
                 throw err;
             overflowRecovered = true;
             const recovered = await runCompaction(ctx, { trigger: 'overflow', lastUsage, turnIndex });
+            if (recovered)
+                lastUsage = undefined;
             if (!recovered)
                 throw err;
             if (ctx.signal.aborted)

package/dist/llm/context-window.d.ts

@@ -0,0 +1,9 @@
+import type { ModelInfo } from './types.js';
+export type ContextWindowInfo = Pick<ModelInfo, 'contextWindow'> & {
+    contextWindowSource: 'api' | 'catalog' | 'fallback';
+};
+/** Never interpret output-token limits as an input/context limit. */
+export declare function reportedContextWindow(model: Record<string, unknown>): ContextWindowInfo;
+/** Recognize only explicit vendor namespaces and dated snapshots, not arbitrary aliases. */
+export declare function catalogModelId(modelId: string): string;
+export declare function catalogContextWindow(modelId: string): number | undefined;

package/dist/llm/context-window.js

@@ -0,0 +1,46 @@
+/** Never interpret output-token limits as an input/context limit. */
+export function reportedContextWindow(model) {
+    const top = model.top_provider;
+    const candidates = [top?.context_length, model.context_length, model.context_window,
+        model.max_input_tokens, model.inputTokenLimit, model.contextWindow];
+    const value = candidates.find((n) => typeof n === 'number' && Number.isSafeInteger(n) && n > 0);
+    return typeof value === 'number'
+        ? { contextWindow: value, contextWindowSource: 'api' }
+        : { contextWindow: 128_000, contextWindowSource: 'fallback' };
+}
+/** Recognize only explicit vendor namespaces and dated snapshots, not arbitrary aliases. */
+export function catalogModelId(modelId) {
+    return modelId.trim().toLowerCase()
+        .replace(/^(models|openai|anthropic|google)\//, '')
+        .replace(/-(?:\d{4}-\d{2}-\d{2}|\d{8})$/, '');
+}
+// Context-only fallbacks: do not invent prices or change the model picker.
+// https://developers.openai.com/api/docs/models/gpt-5
+// https://developers.openai.com/api/docs/models/gpt-5.1
+// https://developers.openai.com/api/docs/models/gpt-5.2
+// https://developers.openai.com/api/docs/models/gpt-5.4
+// https://developers.openai.com/api/docs/models/gpt-5.4-mini
+// https://developers.openai.com/api/docs/models/gpt-5-mini
+// https://developers.openai.com/api/docs/models/gpt-5.3-codex
+// https://developers.openai.com/api/docs/models/gpt-4.1
+// https://ai.google.dev/gemini-api/docs/models/gemini-2.5-pro
+// https://ai.google.dev/gemini-api/docs/models/gemini-2.5-flash
+// https://platform.claude.com/docs/en/models/sonnet-4-6/overview
+// Explicit IDs avoid assuming that future versions or chat variants share a limit.
+const CATALOG = {
+    'gpt-5': 400_000,
+    'gpt-5.1': 400_000,
+    'gpt-5.2': 400_000,
+    'gpt-5.4': 1_050_000,
+    'gpt-5.4-mini': 400_000,
+    'gpt-5-mini': 400_000,
+    'gpt-5.3-codex': 400_000,
+    'gpt-4.1': 1_047_576,
+    'gemini-2.5-pro': 1_048_576,
+    'gemini-2.5-flash': 1_048_576,
+    'claude-sonnet-4-6': 1_000_000,
+};
+export function catalogContextWindow(modelId) {
+    const id = catalogModelId(modelId);
+    return Object.prototype.hasOwnProperty.call(CATALOG, id) ? CATALOG[id] : undefined;
+}

package/dist/llm/model-discovery.d.ts

@@ -0,0 +1,5 @@
+/** One bounded lifetime for all pages, also cancelled when the owning session ends. */
+export declare function createModelDiscoverySignal(parent?: AbortSignal): {
+    signal: AbortSignal;
+    dispose: () => void;
+};

package/dist/llm/model-discovery.js

@@ -0,0 +1,18 @@
+/** One bounded lifetime for all pages, also cancelled when the owning session ends. */
+export function createModelDiscoverySignal(parent) {
+    const controller = new AbortController();
+    const abort = () => controller.abort(parent?.reason);
+    const timer = setTimeout(() => controller.abort(new Error('Model discovery timed out')), 15_000);
+    timer.unref();
+    if (parent?.aborted)
+        abort();
+    else
+        parent?.addEventListener('abort', abort, { once: true });
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            clearTimeout(timer);
+            parent?.removeEventListener('abort', abort);
+        },
+    };
+}

package/dist/llm/model-registry.d.ts

@@ -8,11 +8,13 @@
  */
 import type { ModelInfo } from './types.js';
 import type { ProviderRegistry } from './providers/index.js';
+import { type ContextWindowInfo } from './context-window.js';
 export declare class ModelRegistry {
     /** Static/builtin models keyed by provider id. */
     private readonly builtinModels;
     /** API-discovered models cache keyed by `${providerId}:${baseUrl}`. */
     private readonly discoveryCache;
+    private readonly pendingDiscovery;
     /** Optional reference to the provider registry for API discovery. */
     private providerRegistry;
     constructor(providerRegistry?: ProviderRegistry);
@@ -22,12 +24,15 @@ export declare class ModelRegistry {
     getModels(providerId: string): ModelInfo[];
     /** Look up a specific model by provider + model id. */
     getModel(providerId: string, modelId: string): ModelInfo | undefined;
+    /** Resolve context separately from price, scoped to the configured endpoint. */
+    getContextWindow(providerId: string, modelId: string, baseUrl?: string): ContextWindowInfo;
+    private cacheKey;
     /**
      * Discover models from the provider's API.  Results are cached for 5 min.
      *
      * Falls back to an empty array on failure — never throws.
      */
-    discoverModels(providerId: string, apiKey: string, baseUrl?: string): Promise<ModelInfo[]>;
+    discoverModels(providerId: string, apiKey: string, baseUrl?: string, signal?: AbortSignal): Promise<ModelInfo[]>;
     /** Invalidate the discovery cache for a provider (or all). */
     clearCache(providerId?: string): void;
     /**

package/dist/llm/model-registry.js

@@ -7,6 +7,7 @@
  * new LLMProvider interface for API queries.
  */
 import { DEFAULT_MAX_OUTPUT_TOKENS, learnModelCeiling } from './output-limits.js';
+import { catalogContextWindow, catalogModelId } from './context-window.js';
 /** Cache TTL: 5 minutes. */
 const CACHE_TTL_MS = 5 * 60 * 1000;
 // ---------------------------------------------------------------------------
@@ -17,6 +18,7 @@ export class ModelRegistry {
     builtinModels = new Map();
     /** API-discovered models cache keyed by `${providerId}:${baseUrl}`. */
     discoveryCache = new Map();
+    pendingDiscovery = new Map();
     /** Optional reference to the provider registry for API discovery. */
     providerRegistry;
     constructor(providerRegistry) {
@@ -39,54 +41,87 @@ export class ModelRegistry {
         const models = this.builtinModels.get(providerId);
         return models?.find((m) => m.id === modelId);
     }
+    /** Resolve context separately from price, scoped to the configured endpoint. */
+    getContextWindow(providerId, modelId, baseUrl) {
+        const discovered = this.discoveryCache.get(this.cacheKey(providerId, baseUrl))?.models
+            .find((m) => m.id.replace(/^models\//, '') === modelId.replace(/^models\//, ''));
+        if (discovered?.contextWindowSource === 'api' &&
+            Number.isSafeInteger(discovered.contextWindow) && discovered.contextWindow > 0) {
+            return { contextWindow: discovered.contextWindow, contextWindowSource: 'api' };
+        }
+        const id = catalogModelId(modelId);
+        const builtin = this.getModel(providerId, modelId) ?? this.getModels(providerId)
+            .find((m) => catalogModelId(m.id) === id) ?? [...this.builtinModels.values()]
+            .flat().find((m) => catalogModelId(m.id) === id);
+        const builtinWindow = builtin?.contextWindowSource !== 'fallback' &&
+            Number.isSafeInteger(builtin?.contextWindow) && (builtin?.contextWindow ?? 0) > 0
+            ? builtin?.contextWindow : undefined;
+        const window = builtinWindow ?? catalogContextWindow(id);
+        return window !== undefined
+            ? { contextWindow: window, contextWindowSource: 'catalog' }
+            : { contextWindow: 128_000, contextWindowSource: 'fallback' };
+    }
+    cacheKey(providerId, baseUrl) {
+        const url = baseUrl || this.providerRegistry?.get(providerId)?.defaultBaseUrl || '';
+        return `${providerId}:${url.replace(/\/+$/, '')}`;
+    }
     /**
      * Discover models from the provider's API.  Results are cached for 5 min.
      *
      * Falls back to an empty array on failure — never throws.
      */
-    async discoverModels(providerId, apiKey, baseUrl) {
-        const cacheKey = `${providerId}:${baseUrl || ''}`;
+    async discoverModels(providerId, apiKey, baseUrl, signal) {
+        if (signal?.aborted)
+            return [];
+        const cacheKey = this.cacheKey(providerId, baseUrl);
         const cached = this.discoveryCache.get(cacheKey);
         if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
             return cached.models;
         }
+        const pending = this.pendingDiscovery.get(cacheKey);
+        if (pending && !pending.signal?.aborted)
+            return pending.promise;
         if (!this.providerRegistry)
             return [];
         const provider = this.providerRegistry.get(providerId);
         if (!provider)
             return [];
-        try {
-            const models = await provider.listModels(apiKey, baseUrl);
-            // Discovery outranks the static table (§4.1.2). The adapters that can
-            // report a REAL ceiling already learn it themselves; this feeds anything
-            // reached through the registry, including third-party providers.
-            //
-            // A ceiling that is EXACTLY the product default is skipped, because that
-            // is precisely what `listModels` returns when it has nothing to report —
-            // neither the Anthropic nor the OpenAI models endpoint carries an output
-            // ceiling, so both fall back to it (see the notes in their adapters).
-            // Learning it here at `'discovery'` rank would launder that placeholder
-            // into an assertion that outranks the static table, and would collapse the
-            // distinction `staticCeilingFor`'s `undefined` return exists to keep:
-            // "unknown" would become "capped at 64000", silently clamping an explicit
-            // larger request the user is entitled to make against a proxy. Skipping it
-            // costs nothing — AUTO tops out at the default anyway, and a genuinely
-            // over-large request is repaired by `output-limit-recovery.ts`.
-            for (const model of models) {
-                if (model.maxOutputTokens === DEFAULT_MAX_OUTPUT_TOKENS)
-                    continue;
-                learnModelCeiling(providerId, model.id, model.maxOutputTokens, 'discovery');
+        const token = Symbol();
+        const work = (async () => {
+            try {
+                const models = await provider.listModels(apiKey, baseUrl, signal);
+                if (signal?.aborted || this.pendingDiscovery.get(cacheKey)?.token !== token)
+                    return [];
+                // An output placeholder must not outrank the static ceiling table.
+                // Context provenance is resolved separately by getContextWindow().
+                for (const model of models) {
+                    if (model.maxOutputTokens === DEFAULT_MAX_OUTPUT_TOKENS)
+                        continue;
+                    learnModelCeiling(providerId, model.id, model.maxOutputTokens, 'discovery');
+                }
+                this.discoveryCache.set(cacheKey, { models, timestamp: Date.now() });
+                return models;
+            }
+            catch {
+                return [];
             }
-            this.discoveryCache.set(cacheKey, { models, timestamp: Date.now() });
-            return models;
+        })();
+        this.pendingDiscovery.set(cacheKey, { promise: work, signal, token });
+        try {
+            return await work;
         }
-        catch {
-            return [];
+        finally {
+            if (this.pendingDiscovery.get(cacheKey)?.promise === work)
+                this.pendingDiscovery.delete(cacheKey);
         }
     }
     /** Invalidate the discovery cache for a provider (or all). */
     clearCache(providerId) {
         if (providerId) {
+            for (const key of this.pendingDiscovery.keys()) {
+                if (key.startsWith(`${providerId}:`))
+                    this.pendingDiscovery.delete(key);
+            }
             for (const key of this.discoveryCache.keys()) {
                 if (key.startsWith(`${providerId}:`)) {
                     this.discoveryCache.delete(key);
@@ -94,6 +129,7 @@ export class ModelRegistry {
             }
         }
         else {
+            this.pendingDiscovery.clear();
             this.discoveryCache.clear();
         }
     }
@@ -108,6 +144,7 @@ export class ModelRegistry {
             name: modelId,
             provider: providerId,
             contextWindow: 128_000,
+            contextWindowSource: 'fallback',
             // The PRODUCT DEFAULT, not a private guess. An unknown model that claims a
             // ceiling nothing else agrees with is how one part of the system clamps
             // output the rest of it never asked for.
@@ -168,7 +205,8 @@ const ANTHROPIC_MODELS = [
         id: 'claude-opus-4-6',
         name: 'Claude Opus 4.6',
         provider: 'anthropic',
-        contextWindow: 200_000,
+        // https://platform.claude.com/docs/en/models/opus-4-6/overview
+        contextWindow: 1_000_000,
         maxOutputTokens: 64_000,
         supportsThinking: true,
         supportsTools: true,

package/dist/llm/provider.d.ts

@@ -71,7 +71,7 @@ export interface LLMProvider {
      * Implementations should apply a reasonable timeout (15 s) and return an
      * empty array on failure rather than throwing.
      */
-    listModels(apiKey: string, baseUrl?: string): Promise<ModelInfo[]>;
+    listModels(apiKey: string, baseUrl?: string, signal?: AbortSignal): Promise<ModelInfo[]>;
 }
 export type LLMErrorType = 'auth_error' | 'rate_limit' | 'overloaded' | 'invalid_request' | 'context_overflow' | 'network_error' | 'timeout' | 'server_error' | 'unknown';
 export declare class LLMError extends Error {

package/dist/llm/providers/anthropic.d.ts

@@ -19,5 +19,5 @@ export declare class AnthropicProvider implements LLMProvider {
     readonly defaultBaseUrl = "https://api.anthropic.com";
     stream(request: LLMRequest): AsyncIterableIterator<StreamEvent>;
     complete(request: LLMRequest): Promise<AssistantMessage>;
-    listModels(apiKey: string, baseUrl?: string): Promise<ModelInfo[]>;
+    listModels(apiKey: string, baseUrl?: string, signal?: AbortSignal): Promise<ModelInfo[]>;
 }

package/dist/llm/providers/anthropic.js

@@ -11,6 +11,8 @@
  * - Multimodal user messages (text + image)
  * - Model list via `GET /v1/models`
  */
+import { reportedContextWindow } from '../context-window.js';
+import { createModelDiscoverySignal } from '../model-discovery.js';
 import { THINKING_BUDGET } from '../types.js';
 import { LLMError, classifyHttpError, wrapFetchError } from '../provider.js';
 import { DEFAULT_MAX_OUTPUT_TOKENS, resolveOutputTokens, staticCeilingFor, } from '../output-limits.js';
@@ -282,30 +284,49 @@ export class AnthropicProvider {
     // -----------------------------------------------------------------------
     // listModels
     // -----------------------------------------------------------------------
-    async listModels(apiKey, baseUrl) {
+    async listModels(apiKey, baseUrl, signal) {
         const base = (baseUrl || this.defaultBaseUrl).replace(/\/+$/, '');
         const url = `${base}/v1/models`;
+        const scope = createModelDiscoverySignal(signal);
         try {
-            const res = await fetch(url, {
-                method: 'GET',
-                headers: {
-                    'x-api-key': apiKey,
-                    'anthropic-version': ANTHROPIC_VERSION,
-                },
-                signal: AbortSignal.timeout(15_000),
-            });
-            if (!res.ok)
+            const models = [];
+            const seen = new Set();
+            let cursor;
+            for (let page = 0; page < 20 && !scope.signal.aborted; page++) {
+                try {
+                    const pageUrl = cursor === undefined ? url : `${url}?after_id=${encodeURIComponent(cursor)}`;
+                    const res = await fetch(pageUrl, {
+                        method: 'GET',
+                        headers: { 'x-api-key': apiKey, 'anthropic-version': ANTHROPIC_VERSION },
+                        signal: scope.signal,
+                    });
+                    if (!res.ok)
+                        break;
+                    const data = await res.json();
+                    if (!Array.isArray(data.data))
+                        break;
+                    models.push(...data.data);
+                    const next = data.last_id;
+                    if (data.has_more !== true || typeof next !== 'string' || next.length === 0 || seen.has(next))
+                        break;
+                    seen.add(next);
+                    cursor = next;
+                }
+                catch {
+                    break; // Preserve metadata from earlier pages when continuation fails.
+                }
+            }
+            if (signal?.aborted)
                 return [];
-            const data = await res.json();
             // The Anthropic models endpoint does NOT report an output ceiling, so this
             // maps through the static table and deliberately does NOT call
             // `learnModelCeiling`: asserting 64000 here is how `claude-3-5-haiku` ends
             // up with a "discovered" ceiling that outranks its correct table entry.
-            return (data.data || []).map((m) => ({
+            return models.map((m) => ({
                 id: String(m.id || ''),
                 name: String(m.display_name || m.id || ''),
                 provider: this.id,
-                contextWindow: 200_000,
+                ...reportedContextWindow(m),
                 maxOutputTokens: staticCeilingFor(this.id, String(m.id || '')) ?? DEFAULT_MAX_OUTPUT_TOKENS,
                 supportsThinking: /claude-(sonnet-4|opus-4)/i.test(String(m.id)),
                 supportsTools: true,
@@ -316,6 +337,9 @@ export class AnthropicProvider {
         catch {
             return [];
         }
+        finally {
+            scope.dispose();
+        }
     }
 }
 // ---------------------------------------------------------------------------

package/dist/llm/providers/google.d.ts

@@ -18,5 +18,5 @@ export declare class GoogleProvider implements LLMProvider {
     readonly defaultBaseUrl = "https://generativelanguage.googleapis.com";
     stream(request: LLMRequest): AsyncIterableIterator<StreamEvent>;
     complete(request: LLMRequest): Promise<AssistantMessage>;
-    listModels(apiKey: string, baseUrl?: string): Promise<ModelInfo[]>;
+    listModels(apiKey: string, baseUrl?: string, signal?: AbortSignal): Promise<ModelInfo[]>;
 }

package/dist/llm/providers/google.js

@@ -11,6 +11,8 @@
  * - The API key is passed as a query parameter, not a header.
  */
 import { randomUUID } from 'node:crypto';
+import { reportedContextWindow } from '../context-window.js';
+import { createModelDiscoverySignal } from '../model-discovery.js';
 import { LLMError, classifyHttpError, wrapFetchError } from '../provider.js';
 import { DEFAULT_MAX_OUTPUT_TOKENS, learnModelCeiling, resolveOutputTokens, } from '../output-limits.js';
 import { sendWithOutputLimitRecovery } from '../output-limit-recovery.js';
@@ -199,18 +201,39 @@ export class GoogleProvider {
     // -----------------------------------------------------------------------
     // listModels
     // -----------------------------------------------------------------------
-    async listModels(apiKey, baseUrl) {
+    async listModels(apiKey, baseUrl, signal) {
         const base = (baseUrl || this.defaultBaseUrl).replace(/\/+$/, '');
         const url = `${base}/v1beta/models?key=${encodeURIComponent(apiKey)}`;
+        const scope = createModelDiscoverySignal(signal);
         try {
-            const res = await fetch(url, {
-                method: 'GET',
-                signal: AbortSignal.timeout(15_000),
-            });
-            if (!res.ok)
+            const models = [];
+            const seen = new Set();
+            let cursor;
+            for (let page = 0; page < 20 && !scope.signal.aborted; page++) {
+                try {
+                    const pageUrl = cursor === undefined ? url : `${url}&pageToken=${encodeURIComponent(cursor)}`;
+                    const res = await fetch(pageUrl, { method: 'GET', signal: scope.signal });
+                    if (!res.ok)
+                        break;
+                    const data = await res.json();
+                    if (!Array.isArray(data.models))
+                        break;
+                    models.push(...data.models);
+                    const next = data.nextPageToken;
+                    if (typeof next !== 'string' || next.length === 0 || seen.has(next))
+                        break;
+                    seen.add(next);
+                    cursor = next;
+                }
+                catch {
+                    break; // Preserve metadata from earlier pages when continuation fails.
+                }
+            }
+            // Explicit session cancellation must not publish partial results or learn ceilings.
+            // The internal timeout still permits useful metadata from completed pages.
+            if (signal?.aborted)
                 return [];
-            const data = await res.json();
-            return (data.models || [])
+            return models
                 .filter((m) => {
                 const methods = (m.supportedGenerationMethods || []);
                 return methods.includes('generateContent') || methods.includes('streamGenerateContent');
@@ -228,7 +251,7 @@ export class GoogleProvider {
                     id,
                     name: String(m.displayName || id),
                     provider: this.id,
-                    contextWindow: m.inputTokenLimit || 128_000,
+                    ...reportedContextWindow(m),
                     maxOutputTokens: reported || DEFAULT_MAX_OUTPUT_TOKENS,
                     supportsThinking: false,
                     supportsTools: true,
@@ -240,6 +263,9 @@ export class GoogleProvider {
         catch {
             return [];
         }
+        finally {
+            scope.dispose();
+        }
     }
 }
 // ---------------------------------------------------------------------------

package/dist/llm/providers/openai.d.ts

@@ -28,5 +28,5 @@ export declare class OpenAIProvider implements LLMProvider {
     readonly defaultBaseUrl = "https://api.openai.com/v1";
     stream(request: LLMRequest): AsyncIterableIterator<StreamEvent>;
     complete(request: LLMRequest): Promise<AssistantMessage>;
-    listModels(apiKey: string, baseUrl?: string): Promise<ModelInfo[]>;
+    listModels(apiKey: string, baseUrl?: string, signal?: AbortSignal): Promise<ModelInfo[]>;
 }

package/dist/llm/providers/openai.js

@@ -18,6 +18,8 @@ import { consumeStream } from '../stream-utils.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
+import { reportedContextWindow } from '../context-window.js';
+import { createModelDiscoverySignal } from '../model-discovery.js';
 const DEFAULT_BASE_URL = 'https://api.openai.com/v1';
 export const OPENAI_TERMINAL_DRAIN_MS = 750;
 /** Reasoning-family models reject `max_tokens` in favour of `max_completion_tokens`. */
@@ -111,20 +113,25 @@ export class OpenAIProvider {
     // -----------------------------------------------------------------------
     // listModels
     // -----------------------------------------------------------------------
-    async listModels(apiKey, baseUrl) {
+    async listModels(apiKey, baseUrl, signal) {
         const base = (baseUrl || this.defaultBaseUrl).replace(/\/+$/, '');
         const url = `${base}/models`;
+        const scope = createModelDiscoverySignal(signal);
         try {
+            if (scope.signal.aborted)
+                return [];
             const res = await fetch(url, {
                 method: 'GET',
                 headers: {
                     'Authorization': `Bearer ${apiKey}`,
                 },
-                signal: AbortSignal.timeout(15_000),
+                signal: scope.signal,
             });
             if (!res.ok)
                 return [];
             const data = await res.json();
+            if (signal?.aborted)
+                return [];
             // The OpenAI models endpoint does NOT report an output ceiling, so this
             // maps through the static table and deliberately does NOT call
             // `learnModelCeiling` — claiming knowledge we do not have would outrank
@@ -135,7 +142,7 @@ export class OpenAIProvider {
                 id: String(m.id || ''),
                 name: String(m.id || ''),
                 provider: this.id,
-                contextWindow: 128_000,
+                ...reportedContextWindow(m),
                 maxOutputTokens: staticCeilingFor(this.id, String(m.id || '')) ?? DEFAULT_MAX_OUTPUT_TOKENS,
                 supportsThinking: false,
                 supportsTools: true,
@@ -146,6 +153,9 @@ export class OpenAIProvider {
         catch {
             return [];
         }
+        finally {
+            scope.dispose();
+        }
     }
 }
 /** Owns the request signal and the absolute, non-renewable terminal deadline. */

package/dist/llm/types.d.ts

@@ -160,6 +160,8 @@ export interface ModelInfo {
     name: string;
     provider: string;
     contextWindow: number;
+    /** Provenance of the context limit; omitted by legacy/custom providers. */
+    contextWindowSource?: 'api' | 'catalog' | 'fallback';
     maxOutputTokens: number;
     supportsThinking: boolean;
     supportsTools: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/core",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "AragonAgent core engine — LLM provider adapters, streaming, tool registry/execution, steering, idle watchdog, and an optional isolated-vm sandbox.",
   "license": "MIT",
   "author": "AragonAgent contributors",