@nuvin/nuvin-core 1.6.1 → 1.7.0

package/dist/VERSION

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.1",
-  "commit": "3d1a9e0"
+  "version": "1.7.0",
+  "commit": "4c993c8"
 }

package/dist/index.d.ts

@@ -17,6 +17,7 @@ type AgentTemplate = {
     topP?: number;
     timeoutMs?: number;
     shareContext?: boolean;
+    stream?: boolean;
     metadata?: Record<string, unknown>;
 };
 /**
@@ -40,6 +41,7 @@ type SpecialistAgentConfig = {
     topP?: number;
     timeoutMs?: number;
     shareContext?: boolean;
+    stream?: boolean;
     delegatingMemory?: Message[];
     delegationDepth: number;
     conversationId?: string;
@@ -1691,6 +1693,7 @@ type FileNewSuccessResult$1 = {
     metadata: {
         file_path: string;
         bytes: number;
+        lines: number;
         created: string;
         overwritten?: boolean;
     };
@@ -2096,6 +2099,7 @@ type AnthropicAISDKOptions = {
     apiUrl?: string;
     baseURL?: string;
     httpLogFile?: string;
+    retry?: Partial<RetryConfig>;
     onTokenUpdate?: (newCredentials: {
         access: string;
         refresh: string;
@@ -2105,12 +2109,11 @@ type AnthropicAISDKOptions = {
 declare class AnthropicAISDKLLM {
     private readonly opts;
     private provider?;
-    private refreshPromise;
+    private transport?;
+    private authTransport?;
     constructor(opts?: AnthropicAISDKOptions);
-    private refreshAccessToken;
-    private updateCredentials;
-    private ensureValidToken;
-    private createFetchWithRetry;
+    private getAuthTransport;
+    private getTransport;
     private getProvider;
     private getModel;
     private transformMessages;

package/dist/index.js

@@ -964,6 +964,20 @@ var AgentOrchestrator = class {
       };
       turnHistory.push(toolMsg);
       toolResultMsgs.push(toolMsg);
+      await this.events?.emit({
+        type: AgentEventTypes.ToolResult,
+        conversationId,
+        messageId,
+        result: {
+          id: toolCall.id,
+          name: toolCall.function.name,
+          status: "error",
+          type: "text",
+          result: toolDenialResult,
+          durationMs: 0,
+          metadata: { errorReason: "denied" /* Denied */ }
+        }
+      });
     }
     await this.memory.append(conversationId, [assistantMsg, ...toolResultMsgs]);
     await this.events?.emit({
@@ -1205,7 +1219,10 @@ var AgentOrchestrator = class {
           content: contentStr,
           timestamp: this.clock.iso(),
           tool_call_id: tr.id,
-          name: tr.name
+          name: tr.name,
+          status: tr.status,
+          durationMs: tr.durationMs,
+          metadata: tr.metadata
         });
         this.metrics?.recordToolCall?.();
         await this.events?.emit({
@@ -2648,10 +2665,12 @@ var FileNewTool = class {
       const existsBefore = await fs4.stat(abs).then(() => true).catch(() => false);
       await fs4.mkdir(path4.dirname(abs), { recursive: true });
       const bytes = Buffer.from(p.content, "utf8");
+      const lines = p.content.split(/\r?\n/).length;
       await this.writeAtomic(abs, bytes);
       return okText(`File written at ${p.file_path}.`, {
         file_path: p.file_path,
         bytes: bytes.length,
+        lines,
         created: (/* @__PURE__ */ new Date()).toISOString(),
         overwritten: existsBefore
       });
@@ -3671,6 +3690,7 @@ var DefaultSpecialistAgentFactory = class {
       topP: template.topP,
       timeoutMs: template.timeoutMs,
       shareContext: template.shareContext ?? false,
+      stream: template.stream ?? true,
       delegatingMemory: void 0,
       // TODO: provide delegating memory when available
       delegationDepth: input.currentDepth + 1,
@@ -3827,7 +3847,7 @@ var AgentManager = class {
     this.activeAgents.set(agentId, specialistOrchestrator);
     try {
       const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-      const response = await this.executeWithTimeout(specialistOrchestrator, config.taskDescription, timeoutMs, signal);
+      const response = await this.executeWithTimeout(specialistOrchestrator, config.taskDescription, timeoutMs, signal, config.stream);
       const executionTimeMs = Date.now() - startTime;
       const conversationHistory = await memory.get("default");
       const toolCallsExecuted = events.filter((e) => e.type === "tool_calls").length;
@@ -3909,7 +3929,7 @@ var AgentManager = class {
   /**
    * Execute agent task with timeout
    */
-  async executeWithTimeout(orchestrator, taskDescription, timeoutMs, signal) {
+  async executeWithTimeout(orchestrator, taskDescription, timeoutMs, signal, stream) {
     const timeoutController = new AbortController();
     const combinedSignal = signal ? AbortSignal.any([signal, timeoutController.signal]) : timeoutController.signal;
     let timer;
@@ -3917,7 +3937,8 @@ var AgentManager = class {
       return await Promise.race([
         orchestrator.send(taskDescription, {
           conversationId: "default",
-          signal: combinedSignal
+          signal: combinedSignal,
+          stream
         }),
         new Promise((_, reject) => {
           if (signal?.aborted) {
@@ -4722,9 +4743,9 @@ var BaseLLM = class {
       model: enhancedParams.model,
       messages: enhancedParams.messages,
       temperature: enhancedParams.temperature,
-      max_tokens: enhancedParams.maxTokens,
       top_p: enhancedParams.topP,
       stream: false,
+      ...enhancedParams.maxTokens !== void 0 && { max_tokens: enhancedParams.maxTokens },
       ...enhancedParams.reasoning && { reasoning: enhancedParams.reasoning },
       ...enhancedParams.usage && { usage: enhancedParams.usage }
     };
@@ -4748,9 +4769,9 @@ var BaseLLM = class {
       model: enhancedParams.model,
       messages: enhancedParams.messages,
       temperature: enhancedParams.temperature,
-      max_tokens: enhancedParams.maxTokens,
       top_p: enhancedParams.topP,
       stream: true,
+      ...enhancedParams.maxTokens !== void 0 && { max_tokens: enhancedParams.maxTokens },
       ...enhancedParams.reasoning && { reasoning: enhancedParams.reasoning },
       ...enhancedParams.usage && { usage: enhancedParams.usage }
     };
@@ -5234,66 +5255,6 @@ var GithubAuthTransport = class {
   }
 };
 
-// src/transports/base-bearer-auth-transport.ts
-var BaseBearerAuthTransport = class {
-  inner;
-  apiKey;
-  baseUrl;
-  version;
-  customHeaders;
-  constructor(inner, apiKey, baseUrl, version, customHeaders) {
-    this.inner = inner;
-    this.apiKey = apiKey;
-    this.baseUrl = baseUrl ?? this.getDefaultBaseUrl();
-    this.version = version;
-    this.customHeaders = customHeaders;
-  }
-  buildFullUrl(path9) {
-    if (path9.startsWith("/")) {
-      return `${this.baseUrl}${path9}`;
-    }
-    return path9;
-  }
-  makeAuthHeaders(headers) {
-    const base = headers ? { ...headers } : {};
-    if (!base["User-Agent"] && this.version) {
-      base["User-Agent"] = `nuvin-cli/${this.version}`;
-    }
-    if (this.apiKey && this.apiKey.trim() !== "" && !this.customHeaders?.Authorization) {
-      base.Authorization = `Bearer ${this.apiKey}`;
-    }
-    if (this.customHeaders) {
-      Object.assign(base, this.customHeaders);
-    }
-    return base;
-  }
-  async get(url, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.get(fullUrl, this.makeAuthHeaders(headers), signal);
-  }
-  async post(url, body, headers, signal) {
-    const fullUrl = this.buildFullUrl(url);
-    return this.inner.post(fullUrl, body, this.makeAuthHeaders(headers), signal);
-  }
-};
-
-// src/transports/simple-bearer-transport.ts
-var SimpleBearerAuthTransport = class extends BaseBearerAuthTransport {
-  defaultUrl;
-  constructor(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders) {
-    super(inner, apiKey, baseUrl ?? defaultBaseUrl, version, customHeaders);
-    this.defaultUrl = defaultBaseUrl;
-  }
-  getDefaultBaseUrl() {
-    return this.defaultUrl;
-  }
-};
-
-// src/transports/transport-factory.ts
-function createTransport(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders) {
-  return new SimpleBearerAuthTransport(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders);
-}
-
 // src/transports/backoff.ts
 function calculateBackoff(attempt, baseDelayMs, maxDelayMs, multiplier, jitterFactor) {
   const exponentialDelay = baseDelayMs * multiplier ** attempt;
@@ -5494,6 +5455,247 @@ var RetryTransport = class {
   }
 };
 
+// src/transports/anthropic-transport.ts
+var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+var DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
+var AnthropicAuthTransport = class {
+  inner;
+  baseUrl;
+  retryConfig;
+  apiKey;
+  oauth;
+  onTokenUpdate;
+  refreshPromise = null;
+  constructor(inner, opts) {
+    this.inner = inner;
+    this.apiKey = opts.apiKey;
+    this.oauth = opts.oauth;
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.onTokenUpdate = opts.onTokenUpdate;
+    this.retryConfig = opts.retry;
+  }
+  async refreshAccessToken() {
+    if (!this.oauth) {
+      return { type: "failed" };
+    }
+    try {
+      const response = await fetch("https://console.anthropic.com/v1/oauth/token", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          grant_type: "refresh_token",
+          refresh_token: this.oauth.refresh,
+          client_id: CLIENT_ID
+        })
+      });
+      if (!response.ok) {
+        return { type: "failed" };
+      }
+      const json = await response.json();
+      return {
+        type: "success",
+        access: json.access_token,
+        refresh: json.refresh_token,
+        expires: Date.now() + json.expires_in * 1e3
+      };
+    } catch {
+      return { type: "failed" };
+    }
+  }
+  updateCredentials(result) {
+    if (result.type === "success" && result.access && result.refresh && result.expires) {
+      if (this.oauth) {
+        this.oauth.access = result.access;
+        this.oauth.refresh = result.refresh;
+        this.oauth.expires = result.expires;
+      }
+      this.onTokenUpdate?.({
+        access: result.access,
+        refresh: result.refresh,
+        expires: result.expires
+      });
+    }
+  }
+  async ensureValidToken() {
+    if (!this.oauth) return;
+    if (this.refreshPromise) {
+      const result = await this.refreshPromise;
+      if (result.type === "failed") {
+        throw new Error("Token refresh failed");
+      }
+      return;
+    }
+    this.refreshPromise = this.refreshAccessToken();
+    try {
+      const result = await this.refreshPromise;
+      if (result.type === "success") {
+        this.updateCredentials(result);
+      } else {
+        throw new Error("Token refresh failed");
+      }
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  buildFullUrl(path9) {
+    if (path9.startsWith("/")) {
+      return `${this.baseUrl}${path9}`;
+    }
+    return path9;
+  }
+  makeAuthHeaders(headers) {
+    const base = {
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": "oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14",
+      ...headers || {}
+    };
+    if (this.oauth) {
+      base.authorization = `Bearer ${this.oauth.access}`;
+    } else if (this.apiKey) {
+      base["x-api-key"] = this.apiKey;
+    }
+    return base;
+  }
+  async get(url, headers, signal) {
+    const fullUrl = this.buildFullUrl(url);
+    let res = await this.inner.get(fullUrl, this.makeAuthHeaders(headers), signal);
+    if ((res.status === 401 || res.status === 403) && this.oauth) {
+      await this.ensureValidToken();
+      res = await this.inner.get(fullUrl, this.makeAuthHeaders(headers), signal);
+    }
+    return res;
+  }
+  async post(url, body, headers, signal) {
+    const fullUrl = this.buildFullUrl(url);
+    let res = await this.inner.post(fullUrl, body, this.makeAuthHeaders(headers), signal);
+    if ((res.status === 401 || res.status === 403) && this.oauth) {
+      await this.ensureValidToken();
+      res = await this.inner.post(fullUrl, body, this.makeAuthHeaders(headers), signal);
+    }
+    return res;
+  }
+  createRetryTransport() {
+    return new RetryTransport(this, this.retryConfig);
+  }
+  createFetchFunction() {
+    const makeRequest = async (url, init) => {
+      let currentInit = init;
+      if (this.oauth) {
+        const headers = new Headers(currentInit?.headers);
+        headers.delete("x-api-key");
+        headers.set("authorization", `Bearer ${this.oauth.access}`);
+        headers.set("user-agent", "ai-sdk/anthropic/2.0.30 ai-sdk/provider-utils/3.0.12");
+        currentInit = { ...currentInit, headers };
+      }
+      const response = await fetch(url, currentInit);
+      if ((response.status === 401 || response.status === 403) && this.oauth) {
+        await this.ensureValidToken();
+        const headers = new Headers(currentInit?.headers);
+        headers.set("authorization", `Bearer ${this.oauth.access}`);
+        currentInit = { ...currentInit, headers };
+        return fetch(url, currentInit);
+      }
+      return response;
+    };
+    const retryTransport = new RetryTransport(
+      {
+        get: async (url, headers, signal) => {
+          return makeRequest(url, { method: "GET", headers, signal });
+        },
+        post: async (url, body, headers, signal) => {
+          return makeRequest(url, {
+            method: "POST",
+            headers,
+            body: typeof body === "string" ? body : JSON.stringify(body),
+            signal
+          });
+        }
+      },
+      this.retryConfig
+    );
+    return async (url, init) => {
+      const urlStr = typeof url === "string" ? url : url instanceof URL ? url.toString() : url.url;
+      const method = init?.method?.toUpperCase() ?? "GET";
+      const headers = init?.headers ? Object.fromEntries(new Headers(init.headers).entries()) : void 0;
+      if (method === "GET") {
+        return retryTransport.get(urlStr, headers, init?.signal ?? void 0);
+      }
+      return retryTransport.post(urlStr, init?.body, headers, init?.signal ?? void 0);
+    };
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  getOAuth() {
+    return this.oauth;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+};
+
+// src/transports/base-bearer-auth-transport.ts
+var BaseBearerAuthTransport = class {
+  inner;
+  apiKey;
+  baseUrl;
+  version;
+  customHeaders;
+  constructor(inner, apiKey, baseUrl, version, customHeaders) {
+    this.inner = inner;
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl ?? this.getDefaultBaseUrl();
+    this.version = version;
+    this.customHeaders = customHeaders;
+  }
+  buildFullUrl(path9) {
+    if (path9.startsWith("/")) {
+      return `${this.baseUrl}${path9}`;
+    }
+    return path9;
+  }
+  makeAuthHeaders(headers) {
+    const base = headers ? { ...headers } : {};
+    if (!base["User-Agent"] && this.version) {
+      base["User-Agent"] = `nuvin-cli/${this.version}`;
+    }
+    if (this.apiKey && this.apiKey.trim() !== "" && !this.customHeaders?.Authorization) {
+      base.Authorization = `Bearer ${this.apiKey}`;
+    }
+    if (this.customHeaders) {
+      Object.assign(base, this.customHeaders);
+    }
+    return base;
+  }
+  async get(url, headers, signal) {
+    const fullUrl = this.buildFullUrl(url);
+    return this.inner.get(fullUrl, this.makeAuthHeaders(headers), signal);
+  }
+  async post(url, body, headers, signal) {
+    const fullUrl = this.buildFullUrl(url);
+    return this.inner.post(fullUrl, body, this.makeAuthHeaders(headers), signal);
+  }
+};
+
+// src/transports/simple-bearer-transport.ts
+var SimpleBearerAuthTransport = class extends BaseBearerAuthTransport {
+  defaultUrl;
+  constructor(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders) {
+    super(inner, apiKey, baseUrl ?? defaultBaseUrl, version, customHeaders);
+    this.defaultUrl = defaultBaseUrl;
+  }
+  getDefaultBaseUrl() {
+    return this.defaultUrl;
+  }
+};
+
+// src/transports/transport-factory.ts
+function createTransport(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders) {
+  return new SimpleBearerAuthTransport(inner, defaultBaseUrl, apiKey, baseUrl, version, customHeaders);
+}
+
 // src/llm-providers/model-limits.ts
 function normalizeModelLimits(provider, model) {
   switch (provider.toLowerCase()) {
@@ -5696,126 +5898,68 @@ import {
   jsonSchema,
   APICallError
 } from "ai";
-var CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
 var AnthropicAISDKLLM = class {
   opts;
   provider;
-  refreshPromise = null;
+  transport;
+  authTransport;
   constructor(opts = {}) {
     this.opts = opts;
   }
-  async refreshAccessToken() {
-    if (!this.opts.oauth) {
-      return { type: "failed" };
-    }
-    try {
-      const response = await fetch("https://console.anthropic.com/v1/oauth/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          grant_type: "refresh_token",
-          refresh_token: this.opts.oauth.refresh,
-          client_id: CLIENT_ID
-        })
+  getAuthTransport() {
+    if (!this.authTransport) {
+      const base = new FetchTransport({
+        persistFile: this.opts.httpLogFile,
+        logLevel: "INFO",
+        enableConsoleLog: false,
+        maxFileSize: 5 * 1024 * 1024,
+        captureResponseBody: true
       });
-      if (!response.ok) {
-        return { type: "failed" };
-      }
-      const json = await response.json();
-      return {
-        type: "success",
-        access: json.access_token,
-        refresh: json.refresh_token,
-        expires: Date.now() + json.expires_in * 1e3
-      };
-    } catch (_error) {
-      return { type: "failed" };
-    }
-  }
-  updateCredentials(result) {
-    if (result.type === "success" && result.access && result.refresh && result.expires) {
-      if (this.opts.oauth) {
-        this.opts.oauth.access = result.access;
-        this.opts.oauth.refresh = result.refresh;
-        this.opts.oauth.expires = result.expires;
-      }
-      this.opts.onTokenUpdate?.({
-        access: result.access,
-        refresh: result.refresh,
-        expires: result.expires
+      this.authTransport = new AnthropicAuthTransport(base, {
+        apiKey: this.opts.apiKey,
+        oauth: this.opts.oauth ? {
+          access: this.opts.oauth.access,
+          refresh: this.opts.oauth.refresh,
+          expires: this.opts.oauth.expires
+        } : void 0,
+        baseUrl: this.opts.baseURL || this.opts.apiUrl,
+        retry: this.opts.retry,
+        onTokenUpdate: this.opts.onTokenUpdate
       });
     }
+    return this.authTransport;
   }
-  async ensureValidToken() {
-    if (!this.opts.oauth) return;
-    if (this.refreshPromise) {
-      const result = await this.refreshPromise;
-      if (result.type === "failed") {
-        throw new Error("Token refresh failed");
-      }
-      return;
-    }
-    this.refreshPromise = this.refreshAccessToken();
-    try {
-      const result = await this.refreshPromise;
-      if (result.type === "success") {
-        this.updateCredentials(result);
-        this.provider = void 0;
-      } else {
-        throw new Error("Token refresh failed");
-      }
-    } finally {
-      this.refreshPromise = null;
+  getTransport() {
+    if (!this.transport) {
+      this.transport = this.getAuthTransport().createRetryTransport();
     }
+    return this.transport;
   }
-  createFetchWithRetry() {
-    return async (url, init) => {
-      if (init?.headers && this.opts.oauth) {
-        const headers = new Headers(init.headers);
-        headers.delete("x-api-key");
-        headers.set("authorization", `Bearer ${this.opts.oauth.access}`);
-        headers.set("user-agent", "ai-sdk/anthropic/2.0.30 ai-sdk/provider-utils/3.0.12");
-        init = { ...init, headers };
-      }
-      const response = await fetch(url, init);
-      if ((response.status === 401 || response.status === 403) && this.opts.oauth) {
-        await this.ensureValidToken();
-        if (init?.headers) {
-          const headers = new Headers(init.headers);
-          headers.set("authorization", `Bearer ${this.opts.oauth.access}`);
-          init = { ...init, headers };
-        }
-        return fetch(url, init);
-      }
-      return response;
-    };
-  }
-  async getProvider() {
+  getProvider() {
     if (this.provider) {
       return this.provider;
     }
+    const authTransport = this.getAuthTransport();
     if (this.opts.oauth) {
       this.provider = createAnthropic({
         apiKey: "sk-ant-oauth-placeholder",
-        baseURL: this.opts.baseURL || this.opts.apiUrl,
+        baseURL: authTransport.getBaseUrl(),
         headers: {
           authorization: `Bearer ${this.opts.oauth.access}`,
           "anthropic-beta": "oauth-2025-04-20,claude-code-20250219,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
         },
-        fetch: this.createFetchWithRetry()
+        fetch: authTransport.createFetchFunction()
       });
     } else {
       this.provider = createAnthropic({
         apiKey: this.opts.apiKey,
-        baseURL: this.opts.baseURL || this.opts.apiUrl
+        baseURL: authTransport.getBaseUrl()
       });
     }
     return this.provider;
   }
-  async getModel(modelName) {
-    const provider = await this.getProvider();
+  getModel(modelName) {
+    const provider = this.getProvider();
     return provider(modelName);
   }
   transformMessages(messages) {
@@ -6049,7 +6193,7 @@ var AnthropicAISDKLLM = class {
   }
   async generateCompletion(params, signal) {
     try {
-      const model = await this.getModel(params.model);
+      const model = this.getModel(params.model);
       const messages = this.transformMessages(params.messages);
       const tools = this.transformTools(params.tools);
       const toolChoice = tools ? this.transformToolChoice(params.tool_choice) : void 0;
@@ -6083,7 +6227,7 @@ var AnthropicAISDKLLM = class {
   }
   async streamCompletion(params, handlers = {}, signal) {
     let streamError = null;
-    const model = await this.getModel(params.model);
+    const model = this.getModel(params.model);
     const messages = this.transformMessages(params.messages);
     const tools = this.transformTools(params.tools);
     const toolChoice = tools ? this.transformToolChoice(params.tool_choice) : void 0;
@@ -6134,45 +6278,17 @@ var AnthropicAISDKLLM = class {
     }
   }
   async getModels(signal) {
-    const baseURL = this.opts.baseURL || this.opts.apiUrl || "https://api.anthropic.com/v1";
-    const url = `${baseURL}/models`;
-    const headers = {
-      "anthropic-version": "2023-06-01",
-      "anthropic-beta": " oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14"
-    };
-    if (this.opts.oauth) {
-      headers.authorization = `Bearer ${this.opts.oauth.access}`;
-    } else if (this.opts.apiKey) {
-      headers["x-api-key"] = this.opts.apiKey;
-    } else {
+    const authTransport = this.getAuthTransport();
+    if (!authTransport.getApiKey() && !authTransport.getOAuth()) {
       throw new LLMError("No API key or OAuth credentials provided", 401, false);
     }
     try {
-      const response = await fetch(url, {
-        method: "GET",
-        headers,
-        signal
-      });
-      if (!response.ok) {
-        if ((response.status === 401 || response.status === 403) && this.opts.oauth) {
-          await this.ensureValidToken();
-          headers.authorization = `Bearer ${this.opts.oauth.access}`;
-          const retryResponse = await fetch(url, {
-            method: "GET",
-            headers,
-            signal
-          });
-          if (!retryResponse.ok) {
-            const text2 = await retryResponse.text();
-            throw new LLMError(text2 || `Failed to fetch models: ${retryResponse.status}`, retryResponse.status);
-          }
-          const data2 = await retryResponse.json();
-          return data2.data.map((model) => normalizeModelInfo("anthropic", model));
-        }
-        const text = await response.text();
-        throw new LLMError(text || `Failed to fetch models: ${response.status}`, response.status);
+      const res = await this.getTransport().get("/models", void 0, signal);
+      if (!res.ok) {
+        const text = await res.text();
+        throw new LLMError(text || `Failed to fetch models: ${res.status}`, res.status);
       }
-      const data = await response.json();
+      const data = await res.json();
       return data.data.map((model) => normalizeModelInfo("anthropic", model));
     } catch (error) {
       if (error instanceof LLMError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuvin/nuvin-core",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "",
   "private": false,
   "main": "dist/index.js",