@juspay/neurolink 9.92.1 → 9.92.3

package/dist/lib/providers/sagemaker/language-model.d.ts

@@ -105,11 +105,24 @@ export declare class SageMakerLanguageModel implements SageMakerAsLanguageModel
      */
     private convertToSageMakerRequest;
     /**
-     * Convert Vercel AI SDK tools to SageMaker format
+     * Convert AI SDK tools (`LanguageModelV3FunctionTool | LanguageModelV3ProviderTool`,
+     * the same union every other provider's tool converter accepts — see
+     * `v3ToolsToOpenAI` in openaiChatCompletionsClient.ts) into the SageMaker
+     * wire format, which mirrors the OpenAI Chat Completions nested
+     * `{ function: { name, description, parameters } }` convention.
+     *
+     * Function tools carry their fields flat (`tool.name`, `tool.inputSchema`,
+     * etc.) — there is no `tool.function` sub-object on the AI SDK side.
+     * `type: "provider"` tools (provider-defined tools like web search) have
+     * no SageMaker equivalent; they're dropped explicitly with a debug log
+     * rather than crashing or being sent malformed.
      */
     private convertToolsToSageMakerFormat;
     /**
-     * Convert Vercel AI SDK tool choice to SageMaker format
+     * Convert an AI SDK tool choice (`LanguageModelV3ToolChoice`) into the
+     * SageMaker/OpenAI-style wire format. The AI SDK shape is
+     * `{ type: "auto" | "none" | "required" }` or `{ type: "tool", toolName }`
+     * — never the nested `{ type: "function", function: { name } }` shape.
      */
     private convertToolChoiceToSageMakerFormat;
     /**

package/dist/lib/providers/sagemaker/language-model.js

@@ -370,12 +370,19 @@ export class SageMakerLanguageModel {
                 stop: options.stopSequences || [],
             },
         };
-        // Add tool support if tools are present
+        // Add tool support if tools are present. `options.tools` arrives here in
+        // the AI SDK's LanguageModelV2/V3 call-options shape — a flat
+        // `{ type: "function", name, description?, inputSchema }` per tool (see
+        // `LanguageModelV3FunctionTool` in @ai-sdk/provider), the same shape
+        // every other provider's tool converter consumes (compare
+        // `v3ToolsToOpenAI` in openaiChatCompletionsClient.ts). It is NOT the
+        // nested OpenAI Chat Completions wire format.
         const tools = options.tools;
         if (tools && Array.isArray(tools) && tools.length > 0) {
             request.tools = this.convertToolsToSageMakerFormat(tools);
             // Add tool choice if specified
-            const toolChoice = options.toolChoice;
+            const toolChoice = options
+                .toolChoice;
             if (toolChoice) {
                 request.tool_choice =
                     this.convertToolChoiceToSageMakerFormat(toolChoice);
@@ -403,39 +410,59 @@ export class SageMakerLanguageModel {
         return request;
     }
     /**
-     * Convert Vercel AI SDK tools to SageMaker format
+     * Convert AI SDK tools (`LanguageModelV3FunctionTool | LanguageModelV3ProviderTool`,
+     * the same union every other provider's tool converter accepts — see
+     * `v3ToolsToOpenAI` in openaiChatCompletionsClient.ts) into the SageMaker
+     * wire format, which mirrors the OpenAI Chat Completions nested
+     * `{ function: { name, description, parameters } }` convention.
+     *
+     * Function tools carry their fields flat (`tool.name`, `tool.inputSchema`,
+     * etc.) — there is no `tool.function` sub-object on the AI SDK side.
+     * `type: "provider"` tools (provider-defined tools like web search) have
+     * no SageMaker equivalent; they're dropped explicitly with a debug log
+     * rather than crashing or being sent malformed.
      */
     convertToolsToSageMakerFormat(tools) {
-        return tools.map((tool) => {
-            if (tool.type === "function") {
-                return {
-                    type: "function",
-                    function: {
-                        name: tool.function.name,
-                        description: tool.function.description || "",
-                        parameters: tool.function.parameters || {},
-                    },
-                };
+        const converted = [];
+        for (const tool of tools) {
+            if (tool.type !== "function") {
+                logger.debug("SageMaker: dropping tool with no SageMaker equivalent", {
+                    toolType: tool.type,
+                    toolName: tool.name,
+                });
+                continue;
             }
-            return tool; // Pass through other tool types
-        });
+            converted.push({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description || "",
+                    parameters: tool.inputSchema || {},
+                },
+            });
+        }
+        return converted;
     }
     /**
-     * Convert Vercel AI SDK tool choice to SageMaker format
+     * Convert an AI SDK tool choice (`LanguageModelV3ToolChoice`) into the
+     * SageMaker/OpenAI-style wire format. The AI SDK shape is
+     * `{ type: "auto" | "none" | "required" }` or `{ type: "tool", toolName }`
+     * — never the nested `{ type: "function", function: { name } }` shape.
      */
     convertToolChoiceToSageMakerFormat(toolChoice) {
         if (typeof toolChoice === "string") {
-            return toolChoice; // 'auto', 'none', etc.
+            return toolChoice; // Defensive: tolerate a raw string if ever passed.
         }
-        if (toolChoice?.type === "function") {
-            return {
-                type: "function",
-                function: {
-                    name: toolChoice.function.name,
-                },
-            };
+        switch (toolChoice.type) {
+            case "auto":
+            case "none":
+            case "required":
+                return toolChoice.type;
+            case "tool":
+                return { type: "function", function: { name: toolChoice.toolName } };
+            default:
+                return "auto";
         }
-        return toolChoice;
     }
     /**
      * Convert Vercel AI SDK response format to SageMaker format (Phase 4)

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -18,12 +18,12 @@ import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAtte
  *  no key is configured or the key cannot be matched (account disabled/
  *  removed). The resolution is per-request because enabledAccounts membership
  *  can shift between requests. */
-declare function resolveHomeIndex(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey?: string | undefined): number;
+declare function resolveHomeIndex(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey: string | undefined): number;
 /** If the configured home primary is no longer cooling, reset
  *  primaryAccountIndex back to its index so traffic returns to the preferred
  *  account once its rate limit window expires. Called at the start of each
  *  request. Home is resolved fresh per call via resolveHomeIndex. */
-declare function maybeResetPrimaryToHome(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey?: string | undefined): void;
+declare function maybeResetPrimaryToHome(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey: string | undefined): void;
 declare function claimTransientRateLimitRetry(accountKey: string, coolingUntil: number, now?: number): number | undefined;
 declare function claimTransientCooldownAdmission(accountKey: string, coolingUntil: number, now?: number): number | undefined;
 declare function waitForTransientAccountAvailability(orderedAccounts: ProxyPassthroughAccount[]): Promise<ProxyPassthroughAccount[]>;
@@ -61,28 +61,30 @@ declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: nu
 declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]): Promise<void>;
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
- * spend the window that expires SOONEST first, so its about-to-reset
- * allowance isn't wasted, then move to accounts with longer-dated resets.
+ * spend the overall weekly allowance that expires SOONEST first, so quota
+ * cannot disappear while traffic is consuming a newer weekly window. The 5h
+ * window remains an availability boundary: a session at its soft limit is
+ * temporarily demoted until that session resets.
  *
  * Priority among usable accounts:
  *   1. no quota data yet — probe first: one request reveals its windows and
  *      self-corrects the ordering. (Ranking unknowns last would starve them
  *      forever: never picked → never observed → never comparable.)
  *   2. session headroom before session-saturated (>= soft limit or
- *      "throttled") — saturated accounts then follow the same bucketed
- *      session ordering below: soonest back in service first, weekly
- *      deciding same-bucket ties.
- *   3. soonest SESSION (5h) reset — the capacity expiring soonest; compared
- *      in tolerance buckets so near-simultaneous resets count as equal.
- *   4. soonest WEEKLY (7d) reset — decides between same-bucket sessions.
- *   5. highest weekly utilization — finish off the one closest to done
+ *      "throttled") — do not re-hammer an urgent weekly account while its 5h
+ *      capacity is temporarily unavailable.
+ *   3. soonest WEEKLY (7d) reset — consume the oldest overall allowance
+ *      before it expires.
+ *   4. soonest SESSION (5h) reset — decides equal-weekly or fresh-weekly ties,
+ *      using tolerance buckets for comparator stability.
+ *   5. highest weekly utilization — finish off the one closest to done.
  *   6. configured primary account, then insertion order
- * An account with NO ticking session window (fresh, not yet started) has
- * nothing expiring and sorts after ticking windows in step 3.
+ * Saturated pairs are ordered by soonest 5h recovery first, then weekly reset,
+ * because neither can consume more quota until session capacity returns.
  * Cooling/rejected accounts sort last, soonest-back-to-service first, as
  * last resort.
  */
-declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey?: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
+declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
 declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>): {
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
@@ -266,10 +268,6 @@ export declare const __testHooks: {
     resetEpochToMs: typeof resetEpochToMs;
     seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
     getAccountRuntimeState: (key: string) => RuntimeAccountState | undefined;
-    setConfiguredPrimaryAccountKey: (key: string | undefined) => void;
-    getConfiguredPrimaryAccountKey: () => string | undefined;
-    setConfiguredAccountAllowlist: (allowlist: AccountAllowlist | undefined) => void;
-    getConfiguredAccountAllowlist: () => string[] | undefined;
     setPrimaryAccountIndex: (index: number) => void;
     getPrimaryAccountIndex: () => number;
     setAccountRuntimeState: (key: string, state: Partial<RuntimeAccountState>) => void;

package/dist/lib/server/routes/claudeProxyRoutes.js

@@ -53,11 +53,6 @@ const BLOCKED_UPSTREAM_HEADERS = new Set([
 let primaryAccountIndex = 0;
 /** Track account count so we can reset primaryAccountIndex when it changes. */
 let lastKnownAccountCount = 0;
-/** Stable account key used by legacy fixed-config route factories. Runtime
- *  config providers pass the request generation's primary key explicitly.
- *  When undefined, home semantics retain insertion-order behavior. */
-let configuredPrimaryAccountKey;
-let configuredAccountAllowlist;
 const MAX_AUTH_RETRIES = 5;
 const MAX_TRANSIENT_SAME_ACCOUNT_RETRIES = 2;
 const TRANSIENT_SAME_ACCOUNT_RETRY_DELAYS_MS = [250, 1_000];
@@ -129,7 +124,7 @@ function advancePrimaryIfCurrent(accountKey, enabledCount, primaryAccountKey) {
  *  no key is configured or the key cannot be matched (account disabled/
  *  removed). The resolution is per-request because enabledAccounts membership
  *  can shift between requests. */
-function resolveHomeIndex(enabledAccounts, primaryAccountKey = configuredPrimaryAccountKey) {
+function resolveHomeIndex(enabledAccounts, primaryAccountKey) {
     if (!primaryAccountKey) {
         return 0;
     }
@@ -140,7 +135,7 @@ function resolveHomeIndex(enabledAccounts, primaryAccountKey = configuredPrimary
  *  primaryAccountIndex back to its index so traffic returns to the preferred
  *  account once its rate limit window expires. Called at the start of each
  *  request. Home is resolved fresh per call via resolveHomeIndex. */
-function maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey = configuredPrimaryAccountKey) {
+function maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey) {
     if (enabledAccounts.length <= 1) {
         return;
     }
@@ -463,28 +458,30 @@ function accountSortMetrics(accountKey, now, sessionSoftLimit, sessionResetToler
 }
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
- * spend the window that expires SOONEST first, so its about-to-reset
- * allowance isn't wasted, then move to accounts with longer-dated resets.
+ * spend the overall weekly allowance that expires SOONEST first, so quota
+ * cannot disappear while traffic is consuming a newer weekly window. The 5h
+ * window remains an availability boundary: a session at its soft limit is
+ * temporarily demoted until that session resets.
  *
  * Priority among usable accounts:
  *   1. no quota data yet — probe first: one request reveals its windows and
  *      self-corrects the ordering. (Ranking unknowns last would starve them
  *      forever: never picked → never observed → never comparable.)
  *   2. session headroom before session-saturated (>= soft limit or
- *      "throttled") — saturated accounts then follow the same bucketed
- *      session ordering below: soonest back in service first, weekly
- *      deciding same-bucket ties.
- *   3. soonest SESSION (5h) reset — the capacity expiring soonest; compared
- *      in tolerance buckets so near-simultaneous resets count as equal.
- *   4. soonest WEEKLY (7d) reset — decides between same-bucket sessions.
- *   5. highest weekly utilization — finish off the one closest to done
+ *      "throttled") — do not re-hammer an urgent weekly account while its 5h
+ *      capacity is temporarily unavailable.
+ *   3. soonest WEEKLY (7d) reset — consume the oldest overall allowance
+ *      before it expires.
+ *   4. soonest SESSION (5h) reset — decides equal-weekly or fresh-weekly ties,
+ *      using tolerance buckets for comparator stability.
+ *   5. highest weekly utilization — finish off the one closest to done.
  *   6. configured primary account, then insertion order
- * An account with NO ticking session window (fresh, not yet started) has
- * nothing expiring and sorts after ticking windows in step 3.
+ * Saturated pairs are ordered by soonest 5h recovery first, then weekly reset,
+ * because neither can consume more quota until session capacity returns.
  * Cooling/rejected accounts sort last, soonest-back-to-service first, as
  * last resort.
  */
-function orderAccountsByQuota(accounts, now, primaryKey = configuredPrimaryAccountKey, sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs()) {
+function orderAccountsByQuota(accounts, now, primaryKey, sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs()) {
     const metrics = (key) => accountSortMetrics(key, now, sessionSoftLimit, sessionResetToleranceMs);
     return [...accounts].sort((a, b) => {
         const ma = metrics(a.key);
@@ -503,14 +500,21 @@ function orderAccountsByQuota(accounts, now, primaryKey = configuredPrimaryAccou
         if (ma.saturated !== mb.saturated) {
             return ma.saturated ? 1 : -1;
         }
-        // Saturated pairs fall through to the same bucketed session ordering:
-        // soonest-back-in-service at bucket granularity, weekly deciding ties —
-        // honoring the configured tolerance instead of exact-epoch comparison.
-        if (ma.sessionResetBucket !== mb.sessionResetBucket) {
-            return ma.sessionResetBucket - mb.sessionResetBucket;
+        if (ma.saturated && mb.saturated) {
+            if (ma.sessionResetBucket !== mb.sessionResetBucket) {
+                return ma.sessionResetBucket - mb.sessionResetBucket;
+            }
+            if (ma.weeklyReset !== mb.weeklyReset) {
+                return ma.weeklyReset - mb.weeklyReset;
+            }
         }
-        if (ma.weeklyReset !== mb.weeklyReset) {
-            return ma.weeklyReset - mb.weeklyReset;
+        else {
+            if (ma.weeklyReset !== mb.weeklyReset) {
+                return ma.weeklyReset - mb.weeklyReset;
+            }
+            if (ma.sessionResetBucket !== mb.sessionResetBucket) {
+                return ma.sessionResetBucket - mb.sessionResetBucket;
+            }
         }
         if (ma.weeklyUsed !== mb.weeklyUsed) {
             return mb.weeklyUsed - ma.weeklyUsed;
@@ -1538,7 +1542,7 @@ async function handleClaudePassthroughJsonResponse(args) {
     return responseJson;
 }
 async function loadClaudeProxyAccounts(args) {
-    const { ctx, body, tracer, requestStartTime, accountStrategy, primaryAccountKey = configuredPrimaryAccountKey, accountAllowlist = configuredAccountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, } = args;
+    const { ctx, body, tracer, requestStartTime, accountStrategy, primaryAccountKey, accountAllowlist, quotaRoutingEnabled = isQuotaRoutingEnabled(), sessionSoftLimit = getSessionSoftLimit(), sessionResetToleranceMs = getSessionResetToleranceMs(), buildLoggedClaudeError, } = args;
     const fs = await import("fs");
     const os = await import("os");
     const accounts = [];
@@ -1722,10 +1726,16 @@ async function loadClaudeProxyAccounts(args) {
     const quotaOrdered = accountStrategy === "fill-first" &&
         orderedAccounts.length > 1 &&
         quotaRoutingEnabled;
+    if (!quotaOrdered && accountStrategy === "fill-first") {
+        // Apply the request-scoped home before deriving this request's order. A
+        // hot-reloaded primary change must not lag by one request. Round-robin
+        // deliberately skips this reset so its rotating index remains strict.
+        maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey);
+    }
     if (quotaOrdered) {
-        // Fill-first with a smart fill order: spend the account whose window resets
-        // soonest first (max utilization), proactively skipping any whose window is
-        // rejected until its reset. Supersedes the static home/primary index.
+        // Fill-first with a smart fill order: spend the account whose weekly window
+        // expires soonest while temporarily demoting sessions without headroom.
+        // Supersedes the static home/primary index.
         orderedAccounts = orderAccountsByQuota(enabledAccounts, Date.now(), primaryAccountKey, sessionSoftLimit, sessionResetToleranceMs);
         if (logger.shouldLog("debug")) {
             logger.debug(`[proxy] quota-ordered fill sequence: ${orderedAccounts
@@ -3791,15 +3801,6 @@ async function handleAnthropicRoutedClaudeRequest(args) {
         attemptNumber: 0,
     };
     const acctSelectionSpan = tracer?.startAccountSelection();
-    // Try to return to the home primary account if its cooling has expired.
-    // Skipped under quota routing, where the fill order is derived per-request
-    // from live quota (soonest-reset-first) rather than a static home index.
-    const usingQuotaOrder = accountStrategy === "fill-first" &&
-        enabledAccounts.length > 1 &&
-        quotaRoutingEnabled;
-    if (!usingQuotaOrder) {
-        maybeResetPrimaryToHome(enabledAccounts, primaryAccountKey);
-    }
     // Never re-hammer accounts with a known active cooldown. When every account
     // is cooling, report the earliest persisted retry time without an upstream
     // call; restarting the proxy must not erase or bypass this quarantine.
@@ -4174,10 +4175,6 @@ export function createClaudeProxyRoutes(modelRouter, basePath = "", accountStrat
     const runtimeConfigProvider = isClaudeProxyRouteRuntimeOptions(accountAllowlistOrRuntimeOptions)
         ? accountAllowlistOrRuntimeOptions.runtimeConfigProvider
         : undefined;
-    configuredPrimaryAccountKey = primaryAccountKey;
-    configuredAccountAllowlist = accountAllowlist
-        ? new Set(accountAllowlist)
-        : undefined;
     return {
         prefix: `${basePath}/v1`,
         routes: [
@@ -4608,14 +4605,6 @@ export const __testHooks = {
         const state = accountRuntimeState.get(key);
         return state ? { ...state } : undefined;
     },
-    setConfiguredPrimaryAccountKey: (key) => {
-        configuredPrimaryAccountKey = key;
-    },
-    getConfiguredPrimaryAccountKey: () => configuredPrimaryAccountKey,
-    setConfiguredAccountAllowlist: (allowlist) => {
-        configuredAccountAllowlist = allowlist ? new Set(allowlist) : undefined;
-    },
-    getConfiguredAccountAllowlist: () => configuredAccountAllowlist ? [...configuredAccountAllowlist] : undefined,
     setPrimaryAccountIndex: (index) => {
         primaryAccountIndex = index;
     },
@@ -4631,8 +4620,6 @@ export const __testHooks = {
         transientCooldownAdmissionSchedules.clear();
         primaryAccountIndex = 0;
         lastKnownAccountCount = 0;
-        configuredPrimaryAccountKey = undefined;
-        configuredAccountAllowlist = undefined;
     },
     polyfillOAuthBody: (bodyStr, isClaudeClientRequest) => polyfillOAuthBody(bodyStr, "test-account-token", null, isClaudeClientRequest),
     isAntiAbuseConstruction429,

package/dist/providers/sagemaker/language-model.d.ts

@@ -105,11 +105,24 @@ export declare class SageMakerLanguageModel implements SageMakerAsLanguageModel
      */
     private convertToSageMakerRequest;
     /**
-     * Convert Vercel AI SDK tools to SageMaker format
+     * Convert AI SDK tools (`LanguageModelV3FunctionTool | LanguageModelV3ProviderTool`,
+     * the same union every other provider's tool converter accepts — see
+     * `v3ToolsToOpenAI` in openaiChatCompletionsClient.ts) into the SageMaker
+     * wire format, which mirrors the OpenAI Chat Completions nested
+     * `{ function: { name, description, parameters } }` convention.
+     *
+     * Function tools carry their fields flat (`tool.name`, `tool.inputSchema`,
+     * etc.) — there is no `tool.function` sub-object on the AI SDK side.
+     * `type: "provider"` tools (provider-defined tools like web search) have
+     * no SageMaker equivalent; they're dropped explicitly with a debug log
+     * rather than crashing or being sent malformed.
      */
     private convertToolsToSageMakerFormat;
     /**
-     * Convert Vercel AI SDK tool choice to SageMaker format
+     * Convert an AI SDK tool choice (`LanguageModelV3ToolChoice`) into the
+     * SageMaker/OpenAI-style wire format. The AI SDK shape is
+     * `{ type: "auto" | "none" | "required" }` or `{ type: "tool", toolName }`
+     * — never the nested `{ type: "function", function: { name } }` shape.
      */
     private convertToolChoiceToSageMakerFormat;
     /**

package/dist/providers/sagemaker/language-model.js

@@ -370,12 +370,19 @@ export class SageMakerLanguageModel {
                 stop: options.stopSequences || [],
             },
         };
-        // Add tool support if tools are present
+        // Add tool support if tools are present. `options.tools` arrives here in
+        // the AI SDK's LanguageModelV2/V3 call-options shape — a flat
+        // `{ type: "function", name, description?, inputSchema }` per tool (see
+        // `LanguageModelV3FunctionTool` in @ai-sdk/provider), the same shape
+        // every other provider's tool converter consumes (compare
+        // `v3ToolsToOpenAI` in openaiChatCompletionsClient.ts). It is NOT the
+        // nested OpenAI Chat Completions wire format.
         const tools = options.tools;
         if (tools && Array.isArray(tools) && tools.length > 0) {
             request.tools = this.convertToolsToSageMakerFormat(tools);
             // Add tool choice if specified
-            const toolChoice = options.toolChoice;
+            const toolChoice = options
+                .toolChoice;
             if (toolChoice) {
                 request.tool_choice =
                     this.convertToolChoiceToSageMakerFormat(toolChoice);
@@ -403,39 +410,59 @@ export class SageMakerLanguageModel {
         return request;
     }
     /**
-     * Convert Vercel AI SDK tools to SageMaker format
+     * Convert AI SDK tools (`LanguageModelV3FunctionTool | LanguageModelV3ProviderTool`,
+     * the same union every other provider's tool converter accepts — see
+     * `v3ToolsToOpenAI` in openaiChatCompletionsClient.ts) into the SageMaker
+     * wire format, which mirrors the OpenAI Chat Completions nested
+     * `{ function: { name, description, parameters } }` convention.
+     *
+     * Function tools carry their fields flat (`tool.name`, `tool.inputSchema`,
+     * etc.) — there is no `tool.function` sub-object on the AI SDK side.
+     * `type: "provider"` tools (provider-defined tools like web search) have
+     * no SageMaker equivalent; they're dropped explicitly with a debug log
+     * rather than crashing or being sent malformed.
      */
     convertToolsToSageMakerFormat(tools) {
-        return tools.map((tool) => {
-            if (tool.type === "function") {
-                return {
-                    type: "function",
-                    function: {
-                        name: tool.function.name,
-                        description: tool.function.description || "",
-                        parameters: tool.function.parameters || {},
-                    },
-                };
+        const converted = [];
+        for (const tool of tools) {
+            if (tool.type !== "function") {
+                logger.debug("SageMaker: dropping tool with no SageMaker equivalent", {
+                    toolType: tool.type,
+                    toolName: tool.name,
+                });
+                continue;
             }
-            return tool; // Pass through other tool types
-        });
+            converted.push({
+                type: "function",
+                function: {
+                    name: tool.name,
+                    description: tool.description || "",
+                    parameters: tool.inputSchema || {},
+                },
+            });
+        }
+        return converted;
     }
     /**
-     * Convert Vercel AI SDK tool choice to SageMaker format
+     * Convert an AI SDK tool choice (`LanguageModelV3ToolChoice`) into the
+     * SageMaker/OpenAI-style wire format. The AI SDK shape is
+     * `{ type: "auto" | "none" | "required" }` or `{ type: "tool", toolName }`
+     * — never the nested `{ type: "function", function: { name } }` shape.
      */
     convertToolChoiceToSageMakerFormat(toolChoice) {
         if (typeof toolChoice === "string") {
-            return toolChoice; // 'auto', 'none', etc.
+            return toolChoice; // Defensive: tolerate a raw string if ever passed.
         }
-        if (toolChoice?.type === "function") {
-            return {
-                type: "function",
-                function: {
-                    name: toolChoice.function.name,
-                },
-            };
+        switch (toolChoice.type) {
+            case "auto":
+            case "none":
+            case "required":
+                return toolChoice.type;
+            case "tool":
+                return { type: "function", function: { name: toolChoice.toolName } };
+            default:
+                return "auto";
         }
-        return toolChoice;
     }
     /**
      * Convert Vercel AI SDK response format to SageMaker format (Phase 4)

package/dist/server/routes/claudeProxyRoutes.d.ts

@@ -18,12 +18,12 @@ import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, AnthropicAtte
  *  no key is configured or the key cannot be matched (account disabled/
  *  removed). The resolution is per-request because enabledAccounts membership
  *  can shift between requests. */
-declare function resolveHomeIndex(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey?: string | undefined): number;
+declare function resolveHomeIndex(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey: string | undefined): number;
 /** If the configured home primary is no longer cooling, reset
  *  primaryAccountIndex back to its index so traffic returns to the preferred
  *  account once its rate limit window expires. Called at the start of each
  *  request. Home is resolved fresh per call via resolveHomeIndex. */
-declare function maybeResetPrimaryToHome(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey?: string | undefined): void;
+declare function maybeResetPrimaryToHome(enabledAccounts: ProxyPassthroughAccount[], primaryAccountKey: string | undefined): void;
 declare function claimTransientRateLimitRetry(accountKey: string, coolingUntil: number, now?: number): number | undefined;
 declare function claimTransientCooldownAdmission(accountKey: string, coolingUntil: number, now?: number): number | undefined;
 declare function waitForTransientAccountAvailability(orderedAccounts: ProxyPassthroughAccount[]): Promise<ProxyPassthroughAccount[]>;
@@ -61,28 +61,30 @@ declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: nu
 declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]): Promise<void>;
 /**
  * Order accounts to MAXIMIZE quota utilization (fill-first, smart order):
- * spend the window that expires SOONEST first, so its about-to-reset
- * allowance isn't wasted, then move to accounts with longer-dated resets.
+ * spend the overall weekly allowance that expires SOONEST first, so quota
+ * cannot disappear while traffic is consuming a newer weekly window. The 5h
+ * window remains an availability boundary: a session at its soft limit is
+ * temporarily demoted until that session resets.
  *
  * Priority among usable accounts:
  *   1. no quota data yet — probe first: one request reveals its windows and
  *      self-corrects the ordering. (Ranking unknowns last would starve them
  *      forever: never picked → never observed → never comparable.)
  *   2. session headroom before session-saturated (>= soft limit or
- *      "throttled") — saturated accounts then follow the same bucketed
- *      session ordering below: soonest back in service first, weekly
- *      deciding same-bucket ties.
- *   3. soonest SESSION (5h) reset — the capacity expiring soonest; compared
- *      in tolerance buckets so near-simultaneous resets count as equal.
- *   4. soonest WEEKLY (7d) reset — decides between same-bucket sessions.
- *   5. highest weekly utilization — finish off the one closest to done
+ *      "throttled") — do not re-hammer an urgent weekly account while its 5h
+ *      capacity is temporarily unavailable.
+ *   3. soonest WEEKLY (7d) reset — consume the oldest overall allowance
+ *      before it expires.
+ *   4. soonest SESSION (5h) reset — decides equal-weekly or fresh-weekly ties,
+ *      using tolerance buckets for comparator stability.
+ *   5. highest weekly utilization — finish off the one closest to done.
  *   6. configured primary account, then insertion order
- * An account with NO ticking session window (fresh, not yet started) has
- * nothing expiring and sorts after ticking windows in step 3.
+ * Saturated pairs are ordered by soonest 5h recovery first, then weekly reset,
+ * because neither can consume more quota until session capacity returns.
  * Cooling/rejected accounts sort last, soonest-back-to-service first, as
  * last resort.
  */
-declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey?: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
+declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number, primaryKey: string | undefined, sessionSoftLimit?: number, sessionResetToleranceMs?: number): ProxyPassthroughAccount[];
 declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>): {
     stream: ReadableStream<Uint8Array>;
     outcome: Promise<StreamTerminalOutcome>;
@@ -266,10 +268,6 @@ export declare const __testHooks: {
     resetEpochToMs: typeof resetEpochToMs;
     seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
     getAccountRuntimeState: (key: string) => RuntimeAccountState | undefined;
-    setConfiguredPrimaryAccountKey: (key: string | undefined) => void;
-    getConfiguredPrimaryAccountKey: () => string | undefined;
-    setConfiguredAccountAllowlist: (allowlist: AccountAllowlist | undefined) => void;
-    getConfiguredAccountAllowlist: () => string[] | undefined;
     setPrimaryAccountIndex: (index: number) => void;
     getPrimaryAccountIndex: () => number;
     setAccountRuntimeState: (key: string, state: Partial<RuntimeAccountState>) => void;