@goodandready/dsh-key-rotation 0.8.76 → 0.8.77

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.8.77 (2026-10-30)
+
+### Session Routing, Typed Error Taxonomy & Pre-First-Token Failover (Block 5 Release)
+- **Pre-First-Token Failover & Request Attempt Loop (Issue #527)**: Introduced transaction-safe pre-first-token retry loop in `lib/rotate.js` with canonical `isContentChunk` detector (distinguishes model-visible tokens from stream envelopes and metadata). Stream metadata (such as `block-start`, `response-metadata`) emitted prior to the first content chunk is securely buffered; upon upstream failures (HTTP 429, 502, 503, connection drops) before any content token yields, the buffered metadata is cleanly discarded and the request seamlessly transitions to the next available healthy key without chat UI disruption or duplicate blocks.
+- **Typed Error Taxonomy & Canonical classifyResponseError (Issue #547)**: Implemented `lib/errors.js` with structured envelope parsing for OpenAI, Anthropic, Google Gemini, Groq, and Ollama. Added robust RFC 1123 HTTP-Date and numeric seconds parser for `Retry-After` headers converting to exact millisecond cooldowns; mapped provider failures into typed `@deepseek-ai/dsh-llm` `LlmError` instances (`QUOTA`, `ACCOUNT_QUOTA`, `RATE_LIMIT`, `CONTEXT_WINDOW_EXCEEDED`, `INVALID_CREDENTIAL`, `SERVER`, `TIMEOUT`); updated `isSwitchableError` and `classifyFailure` to replace brittle text regex matching with structured JSON payload classification.
+- **Bounded SessionRouter with LRU & Proactive Unsticking (Issue #548)**: Created standalone domain service `SessionRouter` (`lib/session-router.js`) with capacity limit (`MAX_SESSIONS = 1000`) and automatic 24-hour TTL expiration (`SESSION_TTL_MS`). Integrated Least-Used Initial Assignment to distribute new incoming sessions across least-loaded keys; implemented `unstickKey(failedKey)` in `lib/pool-selection.js` and key penalization to proactively unbind all sessions pinned to failed or cooling keys, guaranteeing seamless transparent failover on consecutive prompts.
+
 ## 0.8.76 (2026-10-30)
 
 ### Security Hardening, DNS Pinning & Mutation Integrity (Block 4 Release)

package/lib/error-taxonomy.js

@@ -1,13 +1,35 @@
-import { SOFT_FAILURE_CODES } from './pool.js';
-// lib/error-taxonomy.js — complete failure classification (#267).
+// lib/error-taxonomy.js — complete failure classification (#267, #547).
 // action: 'switch' | 'surface' | 'cooldown'
 
+import { SOFT_FAILURE_CODES } from './pool.js';
+import {
+  classifyResponseError,
+  parseErrorBody,
+  retryAfterMs,
+  CONTEXT_WINDOW_EXCEEDED_CODE,
+  QUOTA_EXCEEDED_CODE,
+  ACCOUNT_QUOTA_EXCEEDED_CODE,
+  EMPTY_RESPONSE_CODE,
+  INVALID_CREDENTIAL_CODE,
+} from './errors.js';
+
+export {
+  classifyResponseError,
+  parseErrorBody,
+  retryAfterMs,
+  CONTEXT_WINDOW_EXCEEDED_CODE,
+  QUOTA_EXCEEDED_CODE,
+  ACCOUNT_QUOTA_EXCEEDED_CODE,
+  EMPTY_RESPONSE_CODE,
+  INVALID_CREDENTIAL_CODE,
+};
+
 const SWITCH_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
 const SURFACE_STATUS = new Set([400, 404, 422]);
 const AUTH_STATUS = new Set([401, 403]);
 
 const SWITCH_CODES = new Set([
-  'QUOTA', 'RATE_LIMIT', 'SERVER', 'TIMEOUT', 'TRANSPORT', 'EMPTY_RESPONSE',
+  'QUOTA', 'ACCOUNT_QUOTA', 'RATE_LIMIT', 'SERVER', 'TIMEOUT', 'TRANSPORT', 'EMPTY_RESPONSE',
   'UNKNOWN_MODEL', 'AUTH', 'RESOURCE_EXHAUSTED', 'UNAVAILABLE', 'INTERNAL',
   'DEADLINE_EXCEEDED', 'UNAUTHENTICATED', 'PERMISSION_DENIED', 'ABORTED',
 ]);
@@ -19,7 +41,7 @@ const SOCKET_SWITCH = new Set([
 /**
  * Classify a failure for rotation.
  * @param {any} failureOrPayload
- * @returns {{ action: 'switch'|'surface'|'cooldown', code: string, soft: boolean, reason: string }}
+ * @returns {{ action: 'switch'|'surface'|'cooldown', code: string, soft: boolean, reason: string, retryAfterMs?: number }}
  */
 export function classifyFailure(failureOrPayload) {
   if (!failureOrPayload) {
@@ -29,18 +51,46 @@ export function classifyFailure(failureOrPayload) {
   const status = Number(failure.status ?? failure.statusCode ?? failure.httpStatus ?? 0);
   const code = String(failure.code ?? failure.reason ?? failure.name ?? '').toUpperCase();
   const message = String(failure.message ?? failureOrPayload.message ?? '');
+  const headers = failure.headers ?? failureOrPayload.headers ?? failure.response?.headers;
+  const retryMs = retryAfterMs(headers);
+
+  // Check structured body/error through classifyResponseError if available
+  if (status || failure.body || (code && code !== 'ERROR')) {
+    const typed = classifyResponseError(status, failure.body ?? message, headers);
+    if (typed.code === CONTEXT_WINDOW_EXCEEDED_CODE) {
+      return { action: 'surface', code: CONTEXT_WINDOW_EXCEEDED_CODE, soft: false, reason: 'context_window' };
+    }
+  }
 
-  if (AUTH_STATUS.has(status) || code === 'AUTH' || code === 'UNAUTHENTICATED' || code === 'PERMISSION_DENIED') {
-    return { action: 'switch', code: status ? String(status) : (code || 'AUTH'), soft: false, reason: 'auth' };
+  if (AUTH_STATUS.has(status) || code === 'AUTH' || code === 'UNAUTHENTICATED' || code === 'PERMISSION_DENIED' || code === INVALID_CREDENTIAL_CODE) {
+    return {
+      action: 'switch',
+      code: status ? String(status) : (code || 'AUTH'),
+      soft: false,
+      reason: 'auth',
+      ...(retryMs !== undefined ? { retryAfterMs: retryMs } : {}),
+    };
   }
-  if (status === 429 || code === 'RATE_LIMIT' || code === 'RESOURCE_EXHAUSTED' || code === 'QUOTA') {
-    return { action: 'switch', code: status ? '429' : (code || 'RATE_LIMIT'), soft: false, reason: 'quota' };
+  if (status === 429 || code === 'RATE_LIMIT' || code === 'RESOURCE_EXHAUSTED' || code === 'QUOTA' || code === 'ACCOUNT_QUOTA' || code === QUOTA_EXCEEDED_CODE) {
+    return {
+      action: 'switch',
+      code: status ? '429' : (code || 'RATE_LIMIT'),
+      soft: false,
+      reason: 'quota',
+      ...(retryMs !== undefined ? { retryAfterMs: retryMs } : {}),
+    };
   }
   const numCode = Number(code);
   if (SWITCH_STATUS.has(status) || (numCode > 0 && SWITCH_STATUS.has(numCode)) || SOFT_FAILURE_CODES.has(code)) {
     const effCode = status ? String(status) : (numCode > 0 ? String(numCode) : code);
     const soft = SOFT_FAILURE_CODES.has(effCode);
-    return { action: 'switch', code: effCode, soft, reason: 'http' };
+    return {
+      action: 'switch',
+      code: effCode,
+      soft,
+      reason: 'http',
+      ...(retryMs !== undefined ? { retryAfterMs: retryMs } : {}),
+    };
   }
   if (SURFACE_STATUS.has(status)) {
     return { action: 'surface', code: String(status), soft: false, reason: 'client' };
@@ -63,4 +113,3 @@ export function classifyFailure(failureOrPayload) {
   return { action: 'surface', code: code || 'UNKNOWN', soft: false, reason: 'unclassified' };
 }
 
-/** True when classification says switch to next key. */

package/lib/errors.js

@@ -0,0 +1,302 @@
+// lib/errors.js — Canonical error classification and taxonomy for DeepSeek Harness (#547).
+// Unifies error shapes across OpenAI, Anthropic, Gemini, Ollama, Groq and OpenCode into standard LlmError.
+
+import {
+  HarnessError as DshHarnessError,
+  LlmError as DshLlmError,
+  CONTEXT_WINDOW_EXCEEDED_CODE,
+  QUOTA_EXCEEDED_CODE,
+  ACCOUNT_QUOTA_EXCEEDED_CODE,
+  EMPTY_RESPONSE_CODE,
+  INVALID_CREDENTIAL_CODE,
+  isContextWindowExceededError,
+  isQuotaExceededError,
+} from '@deepseek-ai/dsh-llm';
+
+export {
+  CONTEXT_WINDOW_EXCEEDED_CODE,
+  QUOTA_EXCEEDED_CODE,
+  ACCOUNT_QUOTA_EXCEEDED_CODE,
+  EMPTY_RESPONSE_CODE,
+  INVALID_CREDENTIAL_CODE,
+  isContextWindowExceededError,
+  isQuotaExceededError,
+};
+
+// Fallback HarnessError and LlmError if ever decoupled from runtime
+export class HarnessError extends (DshHarnessError || Error) {
+  constructor(message, code, options) {
+    super(message, code, options);
+    this.code = code;
+    this.name = this.constructor.name;
+  }
+}
+
+export class LlmError extends (DshLlmError || HarnessError) {
+  constructor(message, code, options) {
+    super(message, code, options);
+    this.status = options?.status;
+    this.providerRetryAfterMs = options?.providerRetryAfterMs;
+    this.code = code;
+    this.name = this.constructor.name;
+  }
+}
+
+/**
+ * Robust parser for structured error bodies (JSON, object, text).
+ * Handles OpenAI, Anthropic, Gemini, Groq, Ollama envelopes.
+ *
+ * @param {unknown} body
+ * @returns {{ message?: string, type?: string, code?: string, status?: number, raw?: unknown }}
+ */
+export function parseErrorBody(body) {
+  if (!body) return {};
+  if (typeof body === 'object') {
+    return extractErrorFields(body);
+  }
+  if (typeof body === 'string') {
+    const trimmed = body.trim();
+    if (!trimmed) return {};
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        return extractErrorFields(parsed);
+      } catch {
+        // Not valid JSON, return as plain message
+      }
+    }
+    return { message: trimmed.slice(0, 1000) };
+  }
+  return { message: String(body).slice(0, 1000) };
+}
+
+function extractErrorFields(obj) {
+  if (!obj || typeof obj !== 'object') return {};
+  const outer = obj;
+  const nested = outer.error;
+
+  let message = outer.message;
+  let type = outer.type;
+  let code = outer.code;
+  let status = outer.status;
+
+  if (typeof nested === 'string') {
+    message = nested;
+  } else if (nested && typeof nested === 'object' && !Array.isArray(nested)) {
+    if (typeof nested.message === 'string') message = nested.message;
+    if (typeof nested.type === 'string') type = nested.type;
+    if (nested.code !== undefined && nested.code !== null) code = String(nested.code);
+    if (typeof nested.status === 'number' || typeof nested.status === 'string') {
+      const s = Number(nested.status);
+      if (Number.isFinite(s)) status = s;
+    }
+  }
+
+  // Handle gRPC style status object: { code: 8, message: "Resource exhausted", details: [...] }
+  if (outer.details && Array.isArray(outer.details) && outer.details.length > 0) {
+    const firstDetail = outer.details[0];
+    if (firstDetail && typeof firstDetail === 'object') {
+      if (!message && typeof firstDetail.message === 'string') message = firstDetail.message;
+      if (!type && typeof firstDetail.reason === 'string') type = firstDetail.reason;
+    }
+  }
+
+  return {
+    ...(message ? { message: String(message) } : {}),
+    ...(type ? { type: String(type) } : {}),
+    ...(code !== undefined && code !== null ? { code: String(code) } : {}),
+    ...(typeof status === 'number' ? { status } : {}),
+    raw: obj,
+  };
+}
+
+/**
+ * Parse Retry-After value from Headers, headers object, or string into milliseconds.
+ *
+ * @param {Headers | Record<string, string | string[]> | string | null | undefined} headers
+ * @param {number} [now=Date.now()]
+ * @returns {number | undefined}
+ */
+export function retryAfterMs(headers, now = Date.now()) {
+  if (!headers) return undefined;
+  let raw = '';
+  if (typeof headers === 'string') {
+    const m = headers.match(/retry-after\s*[:=]\s*(.+)/i);
+    raw = m ? m[1].trim().split(/[\n\r;]/)[0].trim() : headers.trim();
+  } else if (typeof headers.get === 'function') {
+    raw = headers.get('retry-after') || headers.get('x-ratelimit-reset-after') || '';
+  } else if (typeof headers === 'object') {
+    for (const [k, v] of Object.entries(headers)) {
+      if (k.toLowerCase() === 'retry-after' || k.toLowerCase() === 'x-ratelimit-reset-after') {
+        raw = Array.isArray(v) ? v[0] : String(v || '');
+        break;
+      }
+    }
+  }
+
+  raw = String(raw).trim();
+  if (!raw) return undefined;
+
+  // 1. Seconds format: integer or float
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds) && seconds >= 0 && seconds <= 86400 * 7) {
+    return Math.trunc(seconds * 1000);
+  }
+
+  // 2. HTTP-Date format: RFC 1123 / RFC 850
+  const parsedTs = Date.parse(raw);
+  if (Number.isFinite(parsedTs)) {
+    const diff = parsedTs - now;
+    return diff > 0 && diff < 86400 * 7 * 1000 ? Math.trunc(diff) : 0;
+  }
+
+  return undefined;
+}
+
+/**
+ * Determine if text/detail indicates quota or balance exhaustion.
+ *
+ * @param {string} detail
+ * @returns {boolean}
+ */
+export function isQuotaDetail(detail) {
+  if (!detail) return false;
+  if (isQuotaExceededError(detail)) return true;
+  const d = detail.toLowerCase();
+  return (
+    d.includes('insufficient_quota') ||
+    d.includes('insufficient balance') ||
+    d.includes('insufficient credits') ||
+    d.includes('out of credits') ||
+    d.includes('out of budget') ||
+    d.includes('quota exceeded') ||
+    d.includes('usage limit exceeded') ||
+    d.includes('resource_exhausted') ||
+    d.includes('credit balance') ||
+    d.includes('monthly limit') ||
+    d.includes('weekly limit') ||
+    d.includes('payment required')
+  );
+}
+
+/**
+ * Canonical classifier translating status, body and headers into typed LlmError (#547).
+ *
+ * @param {number} status HTTP status code
+ * @param {unknown} body Response body (string, object, buffer)
+ * @param {Headers | Record<string, unknown> | null | undefined} headers Response headers
+ * @param {{ now?: number }} [options]
+ * @returns {LlmError}
+ */
+export function classifyResponseError(status, body, headers, options = {}) {
+  const now = options.now ?? Date.now();
+  const parsed = parseErrorBody(body);
+  const type = parsed.type ?? '';
+  const message = parsed.message ?? (status ? `HTTP ${status}` : 'Unknown upstream error');
+  const code = (parsed.code ?? '').toUpperCase();
+  const detail = `${type} ${code} ${message}`.trim();
+  const retryMs = retryAfterMs(headers, now);
+
+  const validStatus = Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
+  const errorOptions = {
+    ...(validStatus !== undefined ? { status: validStatus } : {}),
+    ...(retryMs !== undefined ? { providerRetryAfterMs: retryMs } : {}),
+    ...(parsed.raw ? { cause: parsed.raw } : {}),
+  };
+
+  // 1. Context window exceeded
+  if (code === CONTEXT_WINDOW_EXCEEDED_CODE || isContextWindowExceededError(detail)) {
+    return new LlmError(message, CONTEXT_WINDOW_EXCEEDED_CODE, errorOptions);
+  }
+
+  // 2. Authentication & Credentials (401, 403, invalid_api_key)
+  if (
+    status === 401 ||
+    status === 403 ||
+    code === 'INVALID_API_KEY' ||
+    code === 'UNAUTHENTICATED' ||
+    code === 'PERMISSION_DENIED' ||
+    type === 'authentication_error' ||
+    type === 'permission_denied'
+  ) {
+    const isMalformed = /malformed|invalid|bad|incorrect/i.test(detail);
+    return new LlmError(
+      message,
+      isMalformed ? INVALID_CREDENTIAL_CODE : 'AUTH',
+      errorOptions
+    );
+  }
+
+  // 3. Quota & Balance exhaustion (429 or 402 with quota phrasing)
+  if (
+    status === 402 ||
+    code === 'QUOTA' ||
+    code === 'RESOURCE_EXHAUSTED' ||
+    code === 'INSUFFICIENT_QUOTA' ||
+    isQuotaDetail(detail)
+  ) {
+    const isAccount = /account|billing|subscription|replenish/i.test(detail);
+    return new LlmError(
+      message,
+      isAccount ? ACCOUNT_QUOTA_EXCEEDED_CODE : QUOTA_EXCEEDED_CODE,
+      errorOptions
+    );
+  }
+
+  // 4. Rate Limiting (429 without quota exhaustion, concurrency limits)
+  if (
+    status === 429 ||
+    code === 'RATE_LIMIT' ||
+    code === 'RATE_LIMIT_EXCEEDED' ||
+    type === 'rate_limit_error' ||
+    /rate[\s_-]?limit|too many requests|concurrency[\s_-]+limit|rpm|tpm/i.test(detail)
+  ) {
+    return new LlmError(message, 'RATE_LIMIT', errorOptions);
+  }
+
+  // 5. Unknown Model (explicit model_not_found or invalid_model)
+  if (
+    code === 'MODEL_NOT_FOUND' ||
+    code === 'UNKNOWN_MODEL' ||
+    type === 'invalid_model' ||
+    /model[_\s]+not[_\s]+found|unknown[_\s]+model/i.test(detail)
+  ) {
+    return new LlmError(message, 'UNKNOWN_MODEL', errorOptions);
+  }
+
+  // 6. Timeouts (408, 504, DEADLINE_EXCEEDED)
+  if (
+    status === 408 ||
+    status === 504 ||
+    code === 'TIMEOUT' ||
+    code === 'DEADLINE_EXCEEDED' ||
+    /timeout|timed[\s_-]?out/i.test(detail)
+  ) {
+    return new LlmError(message, 'TIMEOUT', errorOptions);
+  }
+
+  // 7. Server Errors (500, 502, 503)
+  if (
+    (status >= 500 && status <= 503) ||
+    code === 'SERVER' ||
+    code === 'INTERNAL' ||
+    code === 'UNAVAILABLE' ||
+    type === 'server_error' ||
+    type === 'api_error'
+  ) {
+    return new LlmError(message, 'SERVER', errorOptions);
+  }
+
+  // 8. Empty response
+  if (code === EMPTY_RESPONSE_CODE || (!message && status === 200)) {
+    return new LlmError(message || 'Upstream returned empty completion', EMPTY_RESPONSE_CODE, errorOptions);
+  }
+
+  // 9. Default client error (400, 422) or generic provider error
+  if (status >= 400 && status < 500) {
+    return new LlmError(message, code || String(status), errorOptions);
+  }
+
+  return new LlmError(message, code || 'PROVIDER_ERROR', errorOptions);
+}
+

package/lib/index.js

@@ -57,6 +57,9 @@ export const name = '@goodandready/dsh-key-rotation';
 export const inject = ['llm', 'webServer', 'settings', 'credentials'];
 export { keyTail, KEY_TAIL_CHARS, KEY_TAIL_PLACEHOLDER, isLoopbackAddress, isTrustedBridgeRequest, isDesktopShellRequest, DEFAULT_SWITCH_CODES, isSwitchableError, formatExhaustionMessage, getRuntime };
 export { notifySwitch, notifyExhaustion, notifyEarlyWarning };
+export { classifyResponseError } from './errors.js';
+export { SessionRouter, defaultSessionRouter, unstickFailedKey } from './session-router.js';
+export { isContentChunk } from './rotate.js';
 
 const NS = 'dsh-key-rotation';
 

package/lib/pool-selection.js

@@ -1,30 +1,91 @@
-// lib/pool-selection.js — pool selection, sticky sessions, attempt sorting and budget metrics (#512).
+// lib/pool-selection.js — pool selection, sticky sessions, attempt sorting and budget metrics (#512, #548).
 // Extracted from lib/pool.js to enforce < 600 line modularity standard.
 
-export const MAX_SESSION_STICKY_ENTRIES = 500;
+import {
+  SessionRouter,
+  defaultSessionRouter,
+  MAX_SESSIONS,
+  SESSION_TTL_MS,
+} from './session-router.js';
 
-export function setSessionSticky(pool, sessionId, candidate) {
-  if (!sessionId || !candidate || !pool?.state) return;
-  if (!(pool.state.sessionSticky instanceof Map)) {
-    pool.state.sessionSticky = new Map();
+export {
+  SessionRouter,
+  defaultSessionRouter,
+  MAX_SESSIONS,
+  SESSION_TTL_MS,
+};
+
+export const MAX_SESSION_STICKY_ENTRIES = MAX_SESSIONS;
+
+/**
+ * Get or initialize the SessionRouter on pool.state or fallback to default.
+ * @param {object} [pool]
+ * @returns {SessionRouter}
+ */
+export function getOrCreateSessionRouter(pool) {
+  if (!pool?.state) return defaultSessionRouter;
+  if (!pool.state.sessionRouter) {
+    pool.state.sessionRouter = new SessionRouter({
+      maxSessions: MAX_SESSIONS,
+      sessionTtlMs: SESSION_TTL_MS,
+    });
   }
-  if (pool.state.sessionSticky.has(sessionId)) {
-    pool.state.sessionSticky.delete(sessionId);
-  } else if (pool.state.sessionSticky.size >= MAX_SESSION_STICKY_ENTRIES) {
-    const oldest = pool.state.sessionSticky.keys().next().value;
-    if (oldest !== undefined) pool.state.sessionSticky.delete(oldest);
+  return pool.state.sessionRouter;
+}
+
+export function setSessionSticky(pool, sessionId, candidate) {
+  if (!sessionId || !candidate) return;
+  const router = getOrCreateSessionRouter(pool);
+  router.setSession(sessionId, candidate);
+  if (pool?.state) {
+    if (!(pool.state.sessionSticky instanceof Map)) {
+      pool.state.sessionSticky = new Map();
+    }
+    if (pool.state.sessionSticky.has(sessionId)) {
+      pool.state.sessionSticky.delete(sessionId);
+    } else if (pool.state.sessionSticky.size >= MAX_SESSION_STICKY_ENTRIES) {
+      const oldest = pool.state.sessionSticky.keys().next().value;
+      if (oldest !== undefined) pool.state.sessionSticky.delete(oldest);
+    }
+    pool.state.sessionSticky.set(sessionId, candidate);
   }
-  pool.state.sessionSticky.set(sessionId, candidate);
 }
 
 export function getSessionSticky(pool, sessionId) {
-  if (!sessionId || !pool?.state?.sessionSticky) return null;
-  return pool.state.sessionSticky.get(sessionId) ?? null;
+  if (!sessionId) return null;
+  const router = getOrCreateSessionRouter(pool);
+  const fromRouter = router.getSession(sessionId);
+  if (fromRouter) return fromRouter;
+  return pool?.state?.sessionSticky?.get?.(sessionId) ?? null;
 }
 
 export function clearSessionSticky(pool, sessionId) {
-  if (!sessionId || !pool?.state?.sessionSticky) return;
-  pool.state.sessionSticky.delete(sessionId);
+  if (!sessionId) return;
+  const router = getOrCreateSessionRouter(pool);
+  router.unstick(sessionId);
+  if (pool?.state?.sessionSticky) {
+    pool.state.sessionSticky.delete(sessionId);
+  }
+}
+
+/**
+ * Proactively unstick all sessions pinned to a cooling or failed key (#548).
+ * @param {object} pool
+ * @param {string} keyRef
+ * @returns {number}
+ */
+export function unstickFailedKey(pool, keyRef) {
+  if (!keyRef) return 0;
+  const router = getOrCreateSessionRouter(pool);
+  const count = router.unstickKey(keyRef);
+  if (pool?.state?.sessionSticky) {
+    for (const [sId, ref] of pool.state.sessionSticky.entries()) {
+      if (ref === keyRef) {
+        pool.state.sessionSticky.delete(sId);
+      }
+    }
+  }
+  return count;
 }
 
 /** Pick a key pool for a (provider, model) pair. */
@@ -48,10 +109,23 @@ export function sortAttemptList(refs, strategy = 'round-robin', deps = {}) {
   if (!Array.isArray(refs) || refs.length <= 1) return (refs ?? []).slice();
   const list = refs.slice();
   if (strategy === 'sticky') {
-    const last = deps.sessionSticky ||
+    const router = getOrCreateSessionRouter(deps.pool);
+    let chosenKey = null;
+
+    if (deps.sessionId) {
+      const resolved = router.resolveSessionKey(deps.sessionId, list);
+      if (resolved && resolved.keyRef) {
+        chosenKey = resolved.keyRef;
+        if (deps.pool) setSessionSticky(deps.pool, deps.sessionId, chosenKey);
+      }
+    }
+
+    const last = chosenKey ||
+      deps.sessionSticky ||
       (deps.sessionId && (deps.pool?.state?.sessionSticky?.get?.(deps.sessionId) || deps.sessionStickyMap?.get?.(deps.sessionId))) ||
       deps.lastUsed ||
       (deps.pool && deps.pool.state && deps.pool.state.lastUsed);
+
     if (last && list.includes(last)) {
       const idx = list.indexOf(last);
       if (idx > 0) {
@@ -147,3 +221,4 @@ export function budgetVerdict(spend, budget) {
   const ratio = spend / budget;
   return { spend, budget, ratio, warn: ratio >= 0.8, exceeded: ratio >= 1 };
 }
+

package/lib/pool.js

@@ -1,16 +1,20 @@
 // lib/pool.js — pure pool arithmetic and selection logic for dsh-key-rotation.
 import {
   MAX_SESSION_STICKY_ENTRIES, setSessionSticky, getSessionSticky, clearSessionSticky,
+  unstickFailedKey, SessionRouter, defaultSessionRouter, MAX_SESSIONS, SESSION_TTL_MS,
   selectPool, sortAttemptList, expiringSoon, shouldNotifyDaily,
   costForDay, costForWeek, budgetVerdict,
 } from './pool-selection.js';
 
 export {
   MAX_SESSION_STICKY_ENTRIES, setSessionSticky, getSessionSticky, clearSessionSticky,
+  unstickFailedKey, SessionRouter, defaultSessionRouter, MAX_SESSIONS, SESSION_TTL_MS,
   selectPool, sortAttemptList, expiringSoon, shouldNotifyDaily,
   costForDay, costForWeek, budgetVerdict,
 };
 
+import { classifyResponseError, CONTEXT_WINDOW_EXCEEDED_CODE } from './errors.js';
+export { classifyResponseError };
 import { resetModelQuotaIfNeeded } from './model-quota.js';
 import { decryptSecret } from './crypto-storage.js';
 import { bestEffort } from './best-effort.js';
@@ -190,6 +194,7 @@ export function pickNext(pool, now, refsCount = pool.refs.length) {
 
 /** Apply a failed-key cooldown to pool state. Pure: returns next state shape. */
 export function applyCooldown(pool, ref, cooldownMs, now = Date.now()) {
+  unstickFailedKey(pool, ref);
   return {
     ...pool,
     state: {
@@ -218,6 +223,7 @@ export function computeBackoff(baseMs, failCount, maxMs, isSoft = false) {
 
 /** Record a failure for `ref` in `pool.state`. */
 export function recordFailure(pool, ref, now, baseMs, maxMs, isSoft = false, jitter = false) {
+  unstickFailedKey(pool, ref);
   if (!pool.state.failCounts) pool.state.failCounts = new Map();
   let next = pool.state.failCounts.get(ref) ?? 0;
   if (!isSoft) {
@@ -494,6 +500,18 @@ export function isSwitchableError(failureOrPayload, switchCodes = new Set(DEFAUL
     status = Number(rawCode);
   }
 
+  // 0. Structured response error classification (#547)
+  if (status || failure.body || message.startsWith('{') || (code && code !== 'ERROR')) {
+    const typed = classifyResponseError(status, failure.body ?? message, failure.headers ?? failure.response?.headers);
+    if (typed.code === CONTEXT_WINDOW_EXCEEDED_CODE) return false;
+    if ((typed.code === 'QUOTA' || typed.code === 'ACCOUNT_QUOTA') && (switchCodes.has('QUOTA') || switchCodes.has('RATE_LIMIT') || switchCodes.has('429'))) return true;
+    if (typed.code === 'RATE_LIMIT' && (switchCodes.has('RATE_LIMIT') || switchCodes.has('429'))) return true;
+    if ((typed.code === 'AUTH' || typed.code === 'INVALID_CREDENTIAL') && (switchCodes.has('AUTH') || switchCodes.has('401') || switchCodes.has('403'))) return true;
+    if (typed.code === 'SERVER' && (switchCodes.has('SERVER') || (status >= 500 && status <= 504 && switchCodes.has(String(status))))) return true;
+    if (typed.code === 'TIMEOUT' && (switchCodes.has('TIMEOUT') || switchCodes.has('408') || switchCodes.has('504'))) return true;
+    if (switchCodes.has(typed.code)) return true;
+  }
+
   // 1. Direct HTTP status codes (#267: also 408/425 transient, #545: numeric status/code mapped to semantic switch codes)
   if ((status === 429 || status === 408 || status === 425) && (switchCodes.has('RATE_LIMIT') || switchCodes.has('QUOTA') || switchCodes.has('429') || switchCodes.has('TIMEOUT') || switchCodes.has(String(status)))) return true;
   if ((status === 401 || status === 403) && (switchCodes.has('AUTH') || switchCodes.has('401') || switchCodes.has('403') || switchCodes.has(String(status)))) return true;
@@ -576,3 +594,4 @@ export function isKeyBroken(pool, ref, now = Date.now()) {
   if (pool.basePool) return isKeyBroken(pool.basePool, ref, now);
   return false;
 }
+

package/lib/rotate.js

@@ -15,6 +15,7 @@ import {
   getSessionSticky,
   setSessionSticky,
   clearSessionSticky,
+  unstickFailedKey,
 } from './pool.js';
 import { pickCascadeFallback, CASCADE_MAX_DEPTH } from './cascade.js';
 import { createRequestBudget, BUDGET_EXHAUSTED_TIMEOUT, BUDGET_EXHAUSTED_ATTEMPTS } from './request-budget.js';
@@ -210,6 +211,7 @@ export function createRotate(deps) {
       const penalizeRef = (targetRef, errCode, errMsg, rawHeaders) => {
         if (!targetRef) return;
         if (sessionId) clearSessionSticky(pool, sessionId);
+        unstickFailedKey(pool, targetRef);
         if (errCode === LOCAL_QUOTA_CODE) return;
         let headerResetMs = null;
         if (rawHeaders) {
@@ -411,6 +413,7 @@ export function createRotate(deps) {
           let yielded = false;
           let switching = false;
           let inner;
+          const preTokenBuffer = [];
           try {
             // #464 & #461: Record attempt & trace dispatch
             budget.recordAttempt();
@@ -450,10 +453,13 @@ export function createRotate(deps) {
                     if (ok) reqStore.concurrencyRef = fallbackRef;
                   }
                 }
-                // Only actual content deltas lock the stream (no more rotation).
-                // Structural/metadata chunks (block-start/end, usage) do not.
-                if (chunk && (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta' || chunk.type === 'tool-call-delta')) {
-                  yielded = true;
+                // Pre-First-Token Failover (#527): Lock the stream only upon first content delta.
+                if (chunk && isContentChunk(chunk)) {
+                  if (!yielded) {
+                    yielded = true;
+                    for (const prev of preTokenBuffer) yield prev;
+                    preTokenBuffer.length = 0;
+                  }
                   yield chunk;
                   continue;
                 }
@@ -465,15 +471,16 @@ export function createRotate(deps) {
                   const message = failure?.message ?? '';
                   const effectiveSwitchCodes = pool.switchCodes ?? switchCodes;
                   const switchable = !yielded && kind === 'error' && isSwitchableError(failure, effectiveSwitchCodes);
-                  const activeRef = reqStore.pickedRef ?? pool.state.lastUsed;
+                  const activeRef = reqStore.pickedRef ?? pool.state.lastUsed ?? attemptList[attempt];
                   if (switchable) {
+                    preTokenBuffer.length = 0; // Discard metadata from aborted attempt (#527)
                     penalizeRef(activeRef, code ?? 'UNKNOWN', message, rawHdrs ?? failure?.headers ?? pool.state.detectedLimits?.get?.(activeRef));
                     recordFailureCategory(pool, code ?? 'UNKNOWN', message, activeRef, now());
                     pool.state.switches = (pool.state.switches ?? 0) + 1;
                     pool.state.lastReason = String(code ?? 'UNKNOWN');
                     pool.state.lastSwitchAt = now();
                     lastFailure = chunk;
-                    logWarn(`[dsh-key-rotation] ${options.provider}: key ${String(activeRef ?? '?')} failed (${String(code)} ${String(message).slice(0, 100)}) - next key`);
+                    logWarn(`[dsh-key-rotation] ${options.provider}: key ${String(activeRef ?? '?')} failed before first token (${String(code)} ${String(message).slice(0, 100)}) - failover to next key`);
                     // #216: per-switch webhook (opt-in switchNotify), deduped per provider
                     if (switchNotify && activeRef) {
                       notifySwitch(runtime0, pool, {
@@ -492,6 +499,10 @@ export function createRotate(deps) {
                     if (kind === 'error' && isSwitchableError(failure, effectiveSwitchCodes)) {
                       penalizeRef(activeRef, code ?? 'UNKNOWN', message, rawHdrs ?? failure?.headers ?? pool.state.detectedLimits?.get?.(activeRef));
                     }
+                    if (!yielded) {
+                      for (const prev of preTokenBuffer) yield prev;
+                      preTokenBuffer.length = 0;
+                    }
                     yield chunk;
                     return;
                   }
@@ -539,24 +550,33 @@ export function createRotate(deps) {
                     });
                   }
                   recordLatency(pool, reqStore);
-                  activePermit?.success();
+                  if (typeof activePermit?.success === 'function') activePermit.success();
                   if (isTraceOwner) trace.finish('SUCCESS', activeRef);
+                  if (!yielded) {
+                    for (const prev of preTokenBuffer) yield prev;
+                    preTokenBuffer.length = 0;
+                  }
                   yield chunk;
                   return;
                 }
-                yield chunk;
+                if (yielded) {
+                  yield chunk;
+                } else {
+                  preTokenBuffer.push(chunk);
+                }
               }
             } catch (e) {
               const effectiveSwitchCodes = pool.switchCodes ?? switchCodes;
-              const activeRef = _pickedRef ?? reqStore.pickedRef ?? pool.state.lastUsed;
+              const activeRef = _pickedRef ?? reqStore.pickedRef ?? pool.state.lastUsed ?? attemptList[attempt];
               if (!yielded && isSwitchableError(e, effectiveSwitchCodes)) {
+                preTokenBuffer.length = 0; // Discard metadata from failed attempt (#527)
                 penalizeRef(activeRef, e?.code ?? 'TRANSPORT', String(e?.message ?? e), e?.headers ?? e?.response?.headers ?? pool.state.detectedLimits?.get?.(activeRef));
                 recordFailureCategory(pool, e?.code ?? 'TRANSPORT', String(e?.message ?? e), activeRef, now());
                 pool.state.switches = (pool.state.switches ?? 0) + 1;
                 pool.state.lastReason = String(e?.code ?? 'TRANSPORT');
                 pool.state.lastSwitchAt = now();
                 lastFailure = finishError(e?.code ?? 'TRANSPORT', String(e?.message ?? e));
-                logWarn(`[dsh-key-rotation] ${options.provider}: key ${String(activeRef ?? '?')} stream threw ${String(e?.code ?? e?.message ?? e)} - failover to next key`);
+                logWarn(`[dsh-key-rotation] ${options.provider}: key ${String(activeRef ?? '?')} stream threw before first token ${String(e?.code ?? e?.message ?? e)} - failover to next key`);
                 if (switchNotify && activeRef) {
                   notifySwitch(runtime0, pool, {
                     provider: options.provider,
@@ -570,16 +590,24 @@ export function createRotate(deps) {
               if (yielded && isSwitchableError(e, effectiveSwitchCodes)) {
                 penalizeRef(activeRef, e?.code ?? 'TRANSPORT', String(e?.message ?? e), e?.headers ?? e?.response?.headers ?? pool.state.detectedLimits?.get?.(activeRef));
               }
+              if (!yielded) {
+                for (const prev of preTokenBuffer) yield prev;
+                preTokenBuffer.length = 0;
+              }
               yield finishError(e?.code ?? 'TRANSPORT', String(e?.message ?? e));
               return;
             }
 
             if (switching) continue; // try the next key
+            if (!yielded && preTokenBuffer.length > 0) {
+              for (const prev of preTokenBuffer) yield prev;
+              preTokenBuffer.length = 0;
+            }
             if (yielded) {
               const activeRef = reqStore.pickedRef ?? _pickedRef ?? pool.state.lastUsed;
               if (activeRef) recordSuccess(pool, activeRef, now());
               recordLatency(pool, reqStore);
-              activePermit?.success();
+              if (typeof activePermit?.success === 'function') activePermit.success();
               if (isTraceOwner) trace.finish('SUCCESS', activeRef);
             } else if (isTraceOwner) {
               trace.finish('COMPLETED', reqStore.pickedRef ?? _pickedRef ?? pool.state.lastUsed);
@@ -626,3 +654,25 @@ export function createRotate(deps) {
 
   return rotate;
 }
+
+/**
+ * Whether a chunk carries a model-visible content delta (#527).
+ * @param {Record<string, unknown>} chunk
+ * @returns {boolean}
+ */
+export function isContentChunk(chunk) {
+  if (!chunk || typeof chunk !== 'object') return false;
+  if (chunk.type === 'text-delta' || chunk.type === 'reasoning-delta' || chunk.type === 'tool-call-delta') {
+    return true;
+  }
+  if (chunk.delta !== undefined || chunk.text !== undefined || chunk.content !== undefined || chunk.choices !== undefined) {
+    return true;
+  }
+  if (chunk.type === 'start' || chunk.type === 'block-start' || chunk.type === 'block-stop' ||
+      chunk.type === 'metadata' || chunk.type === 'response-metadata' || chunk.type === 'usage' ||
+      chunk.type === 'finish') {
+    return false;
+  }
+  return false;
+}
+

package/lib/session-router.js

@@ -0,0 +1,265 @@
+// lib/session-router.js — Bounded SessionRouter with LRU eviction and proactive unsticking (#548).
+// Prevents unbounded memory growth and unpins sessions from failed/cooldown keys.
+
+export const MAX_SESSIONS = 1000;
+export const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+export class SessionRouter {
+  /**
+   * @param {{
+   *   maxSessions?: number,
+   *   sessionTtlMs?: number,
+   *   now?: () => number,
+   * }} [options]
+   */
+  constructor(options = {}) {
+    this.maxSessions = options.maxSessions ?? MAX_SESSIONS;
+    this.sessionTtlMs = options.sessionTtlMs ?? SESSION_TTL_MS;
+    this.now = options.now ?? (() => Date.now());
+    // sessionId -> { keyRef: string, assignedAt: number, lastUsedAt: number }
+    this.sessions = new Map();
+  }
+
+  /**
+   * Evict sessions older than TTL and prune LRU entries if capacity exceeded.
+   *
+   * @param {number} [currentTime]
+   * @returns {number} count of evicted sessions
+   */
+  prune(currentTime = this.now()) {
+    let evicted = 0;
+    // 1. Evict by TTL
+    for (const [id, entry] of this.sessions.entries()) {
+      if (currentTime - entry.lastUsedAt > this.sessionTtlMs) {
+        this.sessions.delete(id);
+        evicted++;
+      }
+    }
+
+    // 2. Evict least-recently used if size exceeds maxSessions
+    while (this.sessions.size > this.maxSessions) {
+      let oldestId = null;
+      let oldestTime = Infinity;
+      for (const [id, entry] of this.sessions.entries()) {
+        if (entry.lastUsedAt < oldestTime) {
+          oldestTime = entry.lastUsedAt;
+          oldestId = id;
+        }
+      }
+      if (oldestId !== null) {
+        this.sessions.delete(oldestId);
+        evicted++;
+      } else {
+        break;
+      }
+    }
+
+    return evicted;
+  }
+
+  /**
+   * Count how many active sessions are currently assigned to each key.
+   *
+   * @param {number} [currentTime]
+   * @returns {Map<string, number>}
+   */
+  getKeyAssignmentCounts(currentTime = this.now()) {
+    const counts = new Map();
+    for (const entry of this.sessions.values()) {
+      if (currentTime - entry.lastUsedAt <= this.sessionTtlMs) {
+        counts.set(entry.keyRef, (counts.get(entry.keyRef) ?? 0) + 1);
+      }
+    }
+    return counts;
+  }
+
+  /**
+   * Select candidate key with the least active sessions assigned (Least-Used Initial Assignment).
+   *
+   * @param {string[]} availableRefs List of candidate key refs
+   * @param {number} [currentTime]
+   * @returns {string|null}
+   */
+  selectLeastUsedKey(availableRefs, currentTime = this.now()) {
+    if (!Array.isArray(availableRefs) || availableRefs.length === 0) return null;
+    if (availableRefs.length === 1) return availableRefs[0];
+
+    const counts = this.getKeyAssignmentCounts(currentTime);
+    let minKey = availableRefs[0];
+    let minCount = counts.get(minKey) ?? 0;
+
+    for (let i = 1; i < availableRefs.length; i++) {
+      const key = availableRefs[i];
+      const count = counts.get(key) ?? 0;
+      if (count < minCount) {
+        minCount = count;
+        minKey = key;
+      }
+    }
+
+    return minKey;
+  }
+
+  /**
+   * Resolve pinned key for a session or allocate via Least-Used Initial Assignment.
+   *
+   * @param {string} sessionId
+   * @param {string[]} availableRefs Candidate keys currently healthy/available
+   * @param {{ preferKey?: string }} [options]
+   * @returns {{ keyRef: string, isReassigned: boolean, reason: string } | null}
+   */
+  resolveSessionKey(sessionId, availableRefs, options = {}) {
+    if (!sessionId || !Array.isArray(availableRefs) || availableRefs.length === 0) {
+      const fallback = availableRefs?.[0] ?? null;
+      return fallback ? { keyRef: fallback, isReassigned: false, reason: 'ad_hoc' } : null;
+    }
+
+    const t = this.now();
+    let existing = this.sessions.get(sessionId);
+
+    // Check TTL
+    if (existing && (t - existing.lastUsedAt > this.sessionTtlMs)) {
+      this.sessions.delete(sessionId);
+      existing = null;
+    }
+
+    // If session is already pinned to an available key:
+    if (existing && availableRefs.includes(existing.keyRef)) {
+      existing.lastUsedAt = t;
+      return { keyRef: existing.keyRef, isReassigned: false, reason: 'sticky_pinned' };
+    }
+
+    // Prune before adding new entry
+    if (!existing && this.sessions.size >= this.maxSessions) {
+      this.prune(t);
+    }
+
+    // Select candidate: prefer explicit key or least-used
+    let chosen = options.preferKey && availableRefs.includes(options.preferKey)
+      ? options.preferKey
+      : this.selectLeastUsedKey(availableRefs, t);
+
+    if (!chosen) chosen = availableRefs[0];
+
+    const wasReassigned = Boolean(existing);
+    this.sessions.set(sessionId, {
+      keyRef: chosen,
+      assignedAt: existing ? existing.assignedAt : t,
+      lastUsedAt: t,
+    });
+
+    return {
+      keyRef: chosen,
+      isReassigned: wasReassigned,
+      reason: wasReassigned ? 'mid_session_failover' : 'new_session_assigned',
+    };
+  }
+
+  /**
+   * Pin or update session sticky assignment explicitly.
+   *
+   * @param {string} sessionId
+   * @param {string} keyRef
+   */
+  setSession(sessionId, keyRef) {
+    if (!sessionId || !keyRef) return;
+    const t = this.now();
+    const existing = this.sessions.get(sessionId);
+    this.sessions.set(sessionId, {
+      keyRef,
+      assignedAt: existing ? existing.assignedAt : t,
+      lastUsedAt: t,
+    });
+    if (this.sessions.size > this.maxSessions) {
+      this.prune(t);
+    }
+  }
+
+  /**
+   * Get pinned key for a session if still valid.
+   *
+   * @param {string} sessionId
+   * @returns {string|null}
+   */
+  getSession(sessionId) {
+    if (!sessionId) return null;
+    const entry = this.sessions.get(sessionId);
+    if (!entry) return null;
+    const t = this.now();
+    if (t - entry.lastUsedAt > this.sessionTtlMs) {
+      this.sessions.delete(sessionId);
+      return null;
+    }
+    return entry.keyRef;
+  }
+
+  /**
+   * Unstick a specific session (e.g. after a failure or manual unpin).
+   *
+   * @param {string} sessionId
+   * @returns {boolean} true if session was present and removed
+   */
+  unstick(sessionId) {
+    if (!sessionId) return false;
+    return this.sessions.delete(sessionId);
+  }
+
+  /**
+   * Proactively unstick all sessions pinned to a failed / cooling key (#548).
+   *
+   * @param {string} keyRef Failed key ref
+   * @returns {number} count of sessions unpinned
+   */
+  unstickKey(keyRef) {
+    if (!keyRef) return 0;
+    let count = 0;
+    for (const [id, entry] of this.sessions.entries()) {
+      if (entry.keyRef === keyRef) {
+        this.sessions.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Return router diagnostics.
+   */
+  getStatus() {
+    const t = this.now();
+    const counts = this.getKeyAssignmentCounts(t);
+    return {
+      activeSessionsCount: this.sessions.size,
+      maxSessions: this.maxSessions,
+      sessionTtlMs: this.sessionTtlMs,
+      keyAssignments: Object.fromEntries(counts.entries()),
+    };
+  }
+
+  /**
+   * Reset all sessions (useful for tests).
+   */
+  reset() {
+    this.sessions.clear();
+  }
+}
+
+// Global default router instance for convenience
+export const defaultSessionRouter = new SessionRouter();
+
+/**
+ * Helper to unstick all sessions pinned to keyRef across router or default instance (#548).
+ * @param {string|object} keyRefOrRouter
+ * @param {string} [keyRef]
+ * @returns {number}
+ */
+export function unstickFailedKey(keyRefOrRouter, keyRef) {
+  if (typeof keyRefOrRouter === 'string') {
+    return defaultSessionRouter.unstickKey(keyRefOrRouter);
+  }
+  if (keyRefOrRouter instanceof SessionRouter) {
+    return keyRefOrRouter.unstickKey(keyRef);
+  }
+  return defaultSessionRouter.unstickKey(keyRef);
+}
+

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "@goodandready/dsh-key-rotation",
-  "version": "0.8.76",
-  "packageManager": "pnpm@10.33.2",
+  "version": "0.8.77",
   "description": "Per-provider API key rotation for DeepSeek Harness: a key pool per provider, auto-created clone routes, and switching to the next key on quota/rate-limit errors. Includes a Settings section (Key Rotation) to edit the key pools, cooldown and switch codes.",
   "keywords": [
     "deepseek-harness",
@@ -60,13 +59,6 @@
     "@deepseek-ai/dsh-llm": "^0.1.7-rc.2 || >=0.2.0-rc.1 <0.2.1-0 || >=0.2.1-alpha.1 <0.2.2-0",
     "@deepseek-ai/schemastery": "^3.18.4"
   },
-  "scripts": {
-    "test": "node tools/test.mjs",
-    "test:core": "node tools/test.mjs --core",
-    "check": "node tools/check.mjs",
-    "build:client": "node scripts/build-client.mjs",
-    "pretest": "node scripts/build-client.mjs"
-  },
   "devDependencies": {
     "react": "18.3.1",
     "react-test-renderer": "18.3.1",
@@ -75,5 +67,12 @@
     "@deepseek-ai/schemastery": "^3.18.4",
     "semver": "^7.6.3"
   },
-  "dependencies": {}
-}
+  "dependencies": {},
+  "scripts": {
+    "test": "node tools/test.mjs",
+    "test:core": "node tools/test.mjs --core",
+    "check": "node tools/check.mjs",
+    "build:client": "node scripts/build-client.mjs",
+    "pretest": "node scripts/build-client.mjs"
+  }
+}