@nyte-ai/ai 0.0.0-stage → 0.0.19

package/dist/chunks/account-limits-cache-a6cgeagz.js

@@ -0,0 +1,77 @@
+import {
+  FifoQueue2
+} from "./account-limits-cache-nn9jebsj.js";
+
+// src/utils/event-stream.ts
+class EventStream2 {
+  queue = new FifoQueue2;
+  waiting = new FifoQueue2;
+  done = false;
+  finalResult = Promise.withResolvers();
+  isComplete;
+  extractResult;
+  constructor(isComplete, extractResult) {
+    this.isComplete = isComplete;
+    this.extractResult = extractResult;
+  }
+  push(event) {
+    if (this.done)
+      return;
+    if (this.isComplete(event)) {
+      this.done = true;
+      this.finalResult.resolve(this.extractResult(event));
+    }
+    const next = { value: event, done: false };
+    const waiter = this.waiting.dequeue();
+    if (waiter) {
+      waiter(next);
+    } else {
+      this.queue.enqueue(next);
+    }
+  }
+  end(result) {
+    this.done = true;
+    if (result !== undefined) {
+      this.finalResult.resolve(result);
+    }
+    for (let waiter = this.waiting.dequeue();waiter; waiter = this.waiting.dequeue()) {
+      waiter({ value: undefined, done: true });
+    }
+  }
+  async* [Symbol.asyncIterator]() {
+    while (true) {
+      const queued = this.queue.dequeue();
+      if (queued) {
+        yield queued.value;
+      } else if (this.done) {
+        return;
+      } else {
+        const result = await new Promise((resolve) => this.waiting.enqueue(resolve));
+        if (result.done)
+          return;
+        yield result.value;
+      }
+    }
+  }
+  result() {
+    return this.finalResult.promise;
+  }
+}
+
+class AssistantMessageEventStream2 extends EventStream2 {
+  constructor() {
+    super((event) => event.type === "done" || event.type === "error", (event) => {
+      if (event.type === "done") {
+        return event.message;
+      } else if (event.type === "error") {
+        return event.error;
+      }
+      throw new Error("Unexpected event type for final result");
+    });
+  }
+}
+function createAssistantMessageEventStream2() {
+  return new AssistantMessageEventStream2;
+}
+
+export { EventStream2, AssistantMessageEventStream2, createAssistantMessageEventStream2 };

package/dist/chunks/account-limits-cache-ag5b8dja.js

@@ -0,0 +1,38 @@
+// src/utils/headers.ts
+function headersToRecord2(headers) {
+  return Object.fromEntries(headers.entries());
+}
+function mergeProviderHeaders2(...headerSources) {
+  const merged = new Map;
+  for (const source of headerSources) {
+    for (const [name, value] of Object.entries(source ?? {})) {
+      const normalizedName = name.toLowerCase();
+      merged.delete(normalizedName);
+      merged.set(normalizedName, [name, value]);
+    }
+  }
+  return Object.fromEntries(merged.values());
+}
+function providerHeadersToRecord2(...headerSources) {
+  const entries = Object.entries(mergeProviderHeaders2(...headerSources)).filter((entry) => entry[1] !== null);
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function hasHeader2(headers, name) {
+  if (!headers)
+    return false;
+  const expected = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
+      return true;
+  }
+  return false;
+}
+function getClientApiKey2(provider, apiKey, headers) {
+  if (apiKey)
+    return apiKey;
+  if (hasHeader2(headers, "authorization") || hasHeader2(headers, "cf-aig-authorization"))
+    return "unused";
+  throw new Error(`No API key for provider: ${provider}`);
+}
+
+export { headersToRecord2, mergeProviderHeaders2, providerHeadersToRecord2, hasHeader2, getClientApiKey2 };

package/dist/chunks/account-limits-cache-b0x2sfya.js

@@ -0,0 +1,45 @@
+// src/auth/types.ts
+import { typed } from "@nyte-ai/schema/model";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var OAuthTokenResponseSchema2 = typed()(Type.Object({
+  access_token: Type.String({ minLength: 1 }),
+  refresh_token: Type.String({ minLength: 1 }),
+  expires_in: Type.Number()
+}));
+var CredentialSchema = Type.Union([
+  Type.Object({
+    type: Type.Literal("api_key"),
+    key: Type.Optional(Type.String()),
+    env: Type.Optional(Type.Record(Type.String(), Type.String()))
+  }),
+  Type.Object({
+    type: Type.Literal("oauth"),
+    refresh: Type.String(),
+    access: Type.String(),
+    expires: Type.Number()
+  })
+]);
+var CredentialAccountsSchema = Type.Object({
+  active: Type.Union([Type.String(), Type.Null()]),
+  accounts: Type.Array(Type.Object({
+    id: Type.String({ minLength: 1 }),
+    label: Type.String({ minLength: 1 }),
+    credential: CredentialSchema
+  }))
+});
+function readCredentialAccounts2(value) {
+  if (Value.Check(CredentialSchema, value))
+    return {
+      active: "default",
+      accounts: [{ id: "default", label: "Default", credential: value }]
+    };
+  if (!Value.Check(CredentialAccountsSchema, value))
+    return;
+  const ids = new Set(value.accounts.map((account) => account.id));
+  if (ids.size !== value.accounts.length || value.active !== null && !ids.has(value.active))
+    return;
+  return value;
+}
+
+export { OAuthTokenResponseSchema2, readCredentialAccounts2 };

package/dist/chunks/account-limits-cache-b23sbrke.js

@@ -0,0 +1,26 @@
+// src/utils/provider-env.ts
+var procEnvCache = null;
+function getBunSandboxEnvValue(name) {
+  if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) {
+    return;
+  }
+  if (procEnvCache === null) {
+    procEnvCache = new Map;
+    try {
+      const data = process.getBuiltinModule("node:fs").readFileSync("/proc/self/environ", "utf-8");
+      for (const entry of data.split("\x00")) {
+        const variable = /^([^=]+)=(.*)$/su.exec(entry);
+        if (variable)
+          procEnvCache.set(variable[1], variable[2]);
+      }
+    } catch {
+      return;
+    }
+  }
+  return procEnvCache.get(name);
+}
+function getProviderEnvValue2(name, env) {
+  return env?.[name] || (typeof process !== "undefined" ? process.env[name] : undefined) || getBunSandboxEnvValue(name) || undefined;
+}
+
+export { getProviderEnvValue2 };

package/dist/chunks/account-limits-cache-b4edaybk.js

@@ -0,0 +1,8 @@
+// src/utils/text.ts
+import {
+  contentText as contentText2,
+  getSystemMessageText as getSystemMessageText2,
+  renderSystemMessageUpdate as renderSystemMessageUpdate2
+} from "@nyte-ai/schema/model";
+
+export { contentText2, getSystemMessageText2, renderSystemMessageUpdate2 };

package/dist/chunks/account-limits-cache-bsknrh6t.js

@@ -0,0 +1,74 @@
+import {
+  sleep2
+} from "./account-limits-cache-j2bt392s.js";
+import {
+  classifyAssistantFailure2,
+  retryCanHelp2
+} from "./account-limits-cache-xds88kxd.js";
+
+// src/utils/retry.ts
+var DEFAULT_MAX_AGENT_RETRY_DELAY_MS2 = 60000;
+function retryDelayMs2(policy, attempt) {
+  const delay = policy.baseDelayMs * 2 ** Math.max(0, attempt - 1);
+  const safeDelay = Number.isSafeInteger(delay) ? delay : Number.MAX_SAFE_INTEGER;
+  return Math.min(safeDelay, policy.maxAgentDelayMs ?? DEFAULT_MAX_AGENT_RETRY_DELAY_MS2);
+}
+function assistantRetryDelayMs2(policy, attempt, retryAfterMs) {
+  const asked = retryAfterMs ?? 0;
+  if (asked > (policy.maxAgentDelayMs ?? DEFAULT_MAX_AGENT_RETRY_DELAY_MS2))
+    return null;
+  return Math.max(asked, retryDelayMs2(policy, attempt));
+}
+
+class RetrySleepAbortError extends Error {
+  constructor() {
+    super("Aborted");
+  }
+}
+function abortableSleep2(ms, signal) {
+  return sleep2(ms, signal, () => new RetrySleepAbortError);
+}
+async function retryAssistantCall2(produce, policy, signal, callbacks) {
+  const maxAttempts = policy?.enabled ? policy.maxRetries : 0;
+  let attempt = 0;
+  let lastRetry;
+  for (;; ) {
+    const response = await produce();
+    if (response.stopReason === "aborted") {
+      if (lastRetry)
+        await callbacks?.onRetryFinished?.(false, lastRetry.attempt);
+      return response;
+    }
+    if (response.stopReason !== "error") {
+      if (lastRetry)
+        await callbacks?.onRetryFinished?.(true, lastRetry.attempt);
+      return response;
+    }
+    const failure = classifyAssistantFailure2(response);
+    const delayMs = policy === undefined || attempt >= maxAttempts || !retryCanHelp2(failure.class) ? null : assistantRetryDelayMs2(policy, attempt + 1, failure.retryAfterMs);
+    if (delayMs === null) {
+      if (lastRetry)
+        await callbacks?.onRetryFinished?.(false, lastRetry.attempt, response.errorMessage);
+      return response;
+    }
+    attempt++;
+    lastRetry = { attempt, errorMessage: response.errorMessage || "Unknown error" };
+    await callbacks?.onRetryScheduled?.(attempt, maxAttempts, delayMs, lastRetry.errorMessage);
+    try {
+      await abortableSleep2(delayMs, signal);
+    } catch (error) {
+      await callbacks?.onRetryFinished?.(false, attempt, lastRetry.errorMessage);
+      if (error instanceof RetrySleepAbortError) {
+        const { errorMessage: _errorMessage, ...rest } = response;
+        return { ...rest, stopReason: "aborted" };
+      }
+      throw error;
+    }
+    await callbacks?.onRetryAttemptStart?.();
+  }
+}
+function failedTransiently2(message) {
+  return message.stopReason === "error" && retryCanHelp2(classifyAssistantFailure2(message).class);
+}
+
+export { DEFAULT_MAX_AGENT_RETRY_DELAY_MS2, retryDelayMs2, assistantRetryDelayMs2, abortableSleep2, retryAssistantCall2, failedTransiently2 };

package/dist/chunks/account-limits-cache-csbxvam7.js

@@ -0,0 +1,12 @@
+// src/api/openai-prompt-cache.ts
+var OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH = 64;
+function clampOpenAIPromptCacheKey2(key) {
+  if (key === undefined)
+    return;
+  const chars = Array.from(key);
+  if (chars.length <= OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH)
+    return key;
+  return chars.slice(0, OPENAI_PROMPT_CACHE_KEY_MAX_LENGTH).join("");
+}
+
+export { clampOpenAIPromptCacheKey2 };

package/dist/chunks/account-limits-cache-cw7q7vfy.js

@@ -0,0 +1,293 @@
+import {
+  GITHUB_COPILOT_API_VERSION2,
+  GITHUB_COPILOT_DEFAULT_ORIGIN2,
+  GITHUB_COPILOT_HEADERS2
+} from "./account-limits-cache-za42x8a3.js";
+import {
+  parseGitHubCopilotCatalog2
+} from "./account-limits-cache-gs8a3fhw.js";
+import {
+  raceWithAbortSignal2
+} from "./account-limits-cache-j2bt392s.js";
+import {
+  pollOAuthDeviceCodeFlow2
+} from "./account-limits-cache-4hptgd2h.js";
+
+// src/auth/oauth/github-copilot.ts
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+var DEFAULT_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+var DEVICE_CODE_LIFETIME_SECONDS = 15 * 60;
+var EXPIRED_MESSAGE = "The device code expired before GitHub approved it. Sign in again.";
+var CREDENTIAL_ERROR = "Invalid stored GitHub Copilot credential. Sign in to GitHub Copilot again.";
+var KNOWN_GRANT_ERRORS = new Set([
+  "unsupported_grant_type",
+  "incorrect_client_credentials",
+  "incorrect_device_code",
+  "device_flow_disabled"
+]);
+var DeviceCodeResponse = Type.Object({
+  device_code: Type.String({ minLength: 1 }),
+  user_code: Type.String({ minLength: 1 }),
+  verification_uri: Type.String({ minLength: 1 }),
+  interval: Type.Optional(Type.Unknown()),
+  expires_in: Type.Optional(Type.Unknown())
+});
+var GitHubToken = Type.Object({ access_token: Type.String({ minLength: 1 }) });
+var GrantError = Type.Object({ error: Type.String(), interval: Type.Optional(Type.Unknown()) });
+var PositiveSeconds = Type.Number({ exclusiveMinimum: 0 });
+var CopilotToken = Type.Object({
+  token: Type.String({ minLength: 1 }),
+  expires_at: Type.Number()
+});
+var CopilotCredential = Type.Object({
+  type: Type.Literal("oauth"),
+  refresh: Type.String({ minLength: 1 }),
+  access: Type.String({ minLength: 1 }),
+  expires: Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER }),
+  availableModelIds: Type.Array(Type.String({ minLength: 1 }))
+});
+function matchesCopilotCredential2(value) {
+  return Value.Check(CopilotCredential, value);
+}
+function copilotOrigin(token) {
+  const proxy = /(?:^|;)proxy-ep=([^;]+)/u.exec(token)?.[1];
+  if (proxy === undefined)
+    return GITHUB_COPILOT_DEFAULT_ORIGIN2;
+  const url = URL.parse(`https://${proxy.replace(/^proxy\./u, "api.")}`);
+  if (!url || url.protocol !== "https:" || !url.hostname.endsWith(".githubcopilot.com") || url.port !== "" || url.username !== "" || url.password !== "" || url.pathname !== "/" || url.search !== "" || url.hash !== "") {
+    throw new Error("GitHub Copilot token contains an untrusted API endpoint");
+  }
+  return url.origin;
+}
+async function requestCopilot(input) {
+  const bounded = AbortSignal.any([input.signal, AbortSignal.timeout(15000)]);
+  let response;
+  try {
+    response = await raceWithAbortSignal2((input.fetch ?? globalThis.fetch)(input.url, {
+      ...input.init,
+      signal: bounded,
+      redirect: "error"
+    }), bounded);
+  } catch (error) {
+    if (input.signal.aborted)
+      throw new Error("Login cancelled", { cause: error });
+    if (bounded.aborted)
+      throw new Error(`${input.describe} timed out`, { cause: error });
+    throw new Error(`${input.describe} failed: network error`, { cause: error });
+  }
+  if (!response.ok)
+    throw new Error(`${input.describe} failed (HTTP ${String(response.status)})`);
+  try {
+    return await raceWithAbortSignal2(response.json(), bounded);
+  } catch (error) {
+    if (input.signal.aborted)
+      throw new Error("Login cancelled", { cause: error });
+    if (bounded.aborted)
+      throw new Error(`${input.describe} timed out`, { cause: error });
+    throw new Error(`${input.describe} returned an unreadable response`, { cause: error });
+  }
+}
+var DEVICE_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/x-www-form-urlencoded",
+  "User-Agent": GITHUB_COPILOT_HEADERS2["User-Agent"]
+};
+async function startDeviceAuthorization(input) {
+  const json = await requestCopilot({
+    fetch: input.fetch,
+    url: "https://github.com/login/device/code",
+    init: {
+      method: "POST",
+      headers: DEVICE_HEADERS,
+      body: new URLSearchParams({ client_id: input.clientId, scope: "read:user" })
+    },
+    signal: input.signal,
+    describe: "GitHub device code request"
+  });
+  if (!Value.Check(DeviceCodeResponse, json))
+    throw new Error("GitHub device code response is missing required fields");
+  const url = URL.parse(json.verification_uri);
+  if (!url || url.protocol !== "https:" || url.hostname !== "github.com" && url.hostname !== "www.github.com" || url.port !== "" || url.username !== "" || url.password !== "" || !url.pathname.startsWith("/login/")) {
+    throw new Error("GitHub device code response named a verification page outside github.com");
+  }
+  return {
+    ...json,
+    verification_uri: url.href,
+    interval: Value.Check(PositiveSeconds, json.interval) ? json.interval : undefined,
+    expires_in: Math.min(DEVICE_CODE_LIFETIME_SECONDS, Value.Check(PositiveSeconds, json.expires_in) ? json.expires_in : DEVICE_CODE_LIFETIME_SECONDS)
+  };
+}
+var LIFETIME_GRACE_MS = 1000;
+async function pollForGitHubToken(input) {
+  const lifetime = AbortSignal.timeout(Math.ceil(input.device.expires_in * 1000) + LIFETIME_GRACE_MS);
+  const pollSignal = AbortSignal.any([input.signal, lifetime]);
+  try {
+    return await pollOAuthDeviceCodeFlow2({
+      intervalSeconds: input.device.interval,
+      expiresInSeconds: input.device.expires_in,
+      waitBeforeFirstPoll: true,
+      signal: pollSignal,
+      poll: async () => {
+        const json = await requestCopilot({
+          fetch: input.fetch,
+          url: "https://github.com/login/oauth/access_token",
+          init: {
+            method: "POST",
+            headers: DEVICE_HEADERS,
+            body: new URLSearchParams({
+              client_id: input.clientId,
+              device_code: input.device.device_code,
+              grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+            })
+          },
+          signal: pollSignal,
+          describe: "GitHub device authorization"
+        });
+        if (Value.Check(GitHubToken, json))
+          return { status: "complete", value: json };
+        if (!Value.Check(GrantError, json))
+          return { status: "failed", message: "GitHub device authorization response is malformed" };
+        switch (json.error) {
+          case "authorization_pending":
+            return { status: "pending" };
+          case "slow_down":
+            return {
+              status: "slow_down",
+              intervalSeconds: Value.Check(PositiveSeconds, json.interval) ? json.interval : undefined
+            };
+          case "expired_token":
+            return { status: "failed", message: EXPIRED_MESSAGE };
+          case "access_denied":
+            return { status: "failed", message: "GitHub sign-in was denied." };
+          default:
+            return {
+              status: "failed",
+              message: KNOWN_GRANT_ERRORS.has(json.error) ? `GitHub device authorization failed: ${json.error}` : "GitHub device authorization failed with an unrecognized error"
+            };
+        }
+      }
+    });
+  } catch (error) {
+    if (input.signal.aborted)
+      throw new Error("Login cancelled", { cause: error });
+    if (lifetime.aborted)
+      throw new Error(EXPIRED_MESSAGE, { cause: error });
+    throw error;
+  }
+}
+async function loadCopilotCredential(input) {
+  const token = await requestCopilot({
+    fetch: input.fetch,
+    url: "https://api.github.com/copilot_internal/v2/token",
+    init: {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${input.github.access_token}`,
+        ...GITHUB_COPILOT_HEADERS2
+      }
+    },
+    signal: input.signal,
+    describe: "GitHub Copilot token exchange"
+  });
+  if (!Value.Check(CopilotToken, token) || !Number.isSafeInteger(token.expires_at * 1000) || token.expires_at * 1000 <= Date.now()) {
+    throw new Error("GitHub Copilot token exchange returned an invalid token or expiry. Sign in to GitHub Copilot again.");
+  }
+  const origin = copilotOrigin(token.token);
+  const catalog = parseGitHubCopilotCatalog2(await requestCopilot({
+    fetch: input.fetch,
+    url: `${origin}/models`,
+    init: {
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token.token}`,
+        ...GITHUB_COPILOT_HEADERS2,
+        "X-GitHub-Api-Version": GITHUB_COPILOT_API_VERSION2
+      }
+    },
+    signal: input.signal,
+    describe: "GitHub Copilot catalog request"
+  }), origin, input.knownModelIds);
+  input.signal.throwIfAborted();
+  return {
+    credential: {
+      type: "oauth",
+      refresh: input.github.access_token,
+      access: token.token,
+      expires: token.expires_at * 1000,
+      availableModelIds: catalog.availableModelIds
+    },
+    needsApproval: catalog.needsApproval
+  };
+}
+function githubCopilotOAuth2(options = {}, knownModelIds = () => new Set) {
+  return {
+    name: "GitHub Copilot",
+    isSubscription: true,
+    loginLabel: "Sign in with GitHub",
+    login: async (interaction) => {
+      interaction.signal.throwIfAborted();
+      const environment = typeof process === "undefined" ? undefined : process.env.NYTE_GITHUB_COPILOT_CLIENT_ID;
+      const clientId = options.clientId || environment || DEFAULT_CLIENT_ID;
+      const device = await startDeviceAuthorization({
+        fetch: options.fetch,
+        clientId,
+        signal: interaction.signal
+      });
+      if (interaction.signal.aborted)
+        throw new Error("Login cancelled");
+      const deviceCode = {
+        type: "device_code",
+        userCode: device.user_code,
+        verificationUri: device.verification_uri,
+        intervalSeconds: device.interval,
+        expiresInSeconds: device.expires_in
+      };
+      if (clientId === DEFAULT_CLIENT_ID) {
+        deviceCode.instructions = "This sign-in uses GitHub's Copilot app, not a Nyte OAuth app.";
+      }
+      interaction.notify(deviceCode);
+      const github = await pollForGitHubToken({
+        fetch: options.fetch,
+        clientId,
+        device,
+        signal: interaction.signal
+      });
+      interaction.notify({ type: "progress", message: "Connecting to GitHub Copilot" });
+      const result = await loadCopilotCredential({
+        fetch: options.fetch,
+        github,
+        knownModelIds: knownModelIds(),
+        signal: interaction.signal
+      });
+      if (result.needsApproval)
+        interaction.notify({
+          type: "info",
+          message: "Some Copilot models need account approval. Enable them in your Copilot settings, then sign in again."
+        });
+      return result.credential;
+    },
+    refresh: async (previous, signal) => {
+      if (!matchesCopilotCredential2(previous))
+        throw new Error(CREDENTIAL_ERROR);
+      const result = await loadCopilotCredential({
+        fetch: options.fetch,
+        github: { access_token: previous.refresh },
+        knownModelIds: knownModelIds(),
+        signal
+      });
+      return result.credential;
+    },
+    async toAuth(credential) {
+      if (!matchesCopilotCredential2(credential))
+        throw new Error(CREDENTIAL_ERROR);
+      return {
+        apiKey: credential.access,
+        baseUrl: copilotOrigin(credential.access),
+        headers: GITHUB_COPILOT_HEADERS2
+      };
+    }
+  };
+}
+
+export { matchesCopilotCredential2, githubCopilotOAuth2 };

package/dist/chunks/account-limits-cache-d1ypzqzp.js

@@ -0,0 +1,27 @@
+// src/auth/oauth/authorization-input.ts
+function parseAuthorizationInput2(input) {
+  const value = input.trim();
+  if (!value)
+    return {};
+  try {
+    const url = new URL(value);
+    return {
+      code: url.searchParams.get("code") ?? undefined,
+      state: url.searchParams.get("state") ?? undefined
+    };
+  } catch {}
+  if (value.includes("#")) {
+    const [code, state] = value.split("#", 2);
+    return { code, state };
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: params.get("code") ?? undefined,
+      state: params.get("state") ?? undefined
+    };
+  }
+  return { code: value };
+}
+
+export { parseAuthorizationInput2 };

package/dist/chunks/account-limits-cache-d2a51dka.js

@@ -0,0 +1,17 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+
+// src/prompt-cache.ts
+function resolveCacheRetention2(retention, env) {
+  if (retention !== undefined)
+    return retention;
+  return getProviderEnvValue2("NYTE_CACHE_RETENTION", env) === "short" ? "short" : "long";
+}
+function promptCacheMinimumTtlMs2(policy, retention) {
+  if (policy === undefined || retention === "none")
+    return;
+  return policy.minimumRetentionMs[retention];
+}
+
+export { resolveCacheRetention2, promptCacheMinimumTtlMs2 };