@nyte-ai/ai 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,134 @@
+import {
+  lazyStream2
+} from "./account-limits-cache-90c9c2eb.js";
+import {
+  ModelsError2
+} from "./account-limits-cache-7z9s8j16.js";
+
+// src/provider.ts
+import { ModelSchema } from "@nyte-ai/schema/model";
+import { Value } from "typebox/value";
+var CATALOG_FRESHNESS_WINDOW_MS = 4 * 60 * 60 * 1000;
+function createProvider2(input) {
+  let catalogModels = [];
+  const api = input.api;
+  const single = "streamSimple" in api ? api : undefined;
+  const byApi = new Map("streamSimple" in api ? [] : Object.entries(api));
+  const apiFor = (model) => single ?? byApi.get(model.api);
+  const usableModels = (catalog) => catalog.filter((model) => Value.Check(ModelSchema, model) && model.provider === input.id && apiFor(model) !== undefined);
+  const dispatch = (model, run) => {
+    const streams = apiFor(model);
+    if (!streams) {
+      return lazyStream2(model, async () => {
+        throw new ModelsError2("stream", `Provider ${input.id} has no API implementation for "${model.api}"`);
+      });
+    }
+    return run(streams);
+  };
+  const provider = {
+    id: input.id,
+    name: input.name ?? input.id,
+    baseUrl: input.baseUrl,
+    headers: input.headers,
+    promptCache: input.promptCache,
+    auth: input.auth,
+    fetchAccountLimits: input.fetchAccountLimits,
+    getModels: () => catalogModels,
+    refreshModels: async (context) => {
+      if (context.stored) {
+        const restored = usableModels(context.stored.models);
+        if (!await context.publish({
+          update: () => {
+            catalogModels = restored;
+          }
+        })) {
+          return;
+        }
+      }
+      if (!context.allowNetwork || context.signal.aborted)
+        return;
+      if (context.force !== true && context.stored?.checkedAt !== undefined && Date.now() - context.stored.checkedAt < CATALOG_FRESHNESS_WINDOW_MS) {
+        return;
+      }
+      const headers = new Headers({ Accept: "application/json" });
+      if (context.stored?.etag !== undefined) {
+        headers.set("If-None-Match", context.stored.etag);
+      }
+      let response;
+      try {
+        response = await context.catalog.fetch(`${context.catalog.url.replace(/\/+$/u, "")}/${input.id}.json`, {
+          headers,
+          signal: context.signal,
+          redirect: "error"
+        });
+      } catch (error) {
+        context.signal.throwIfAborted();
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id}`, {
+          cause: error
+        });
+      }
+      const checkedAt = Date.now();
+      if (response.status === 304) {
+        if (!context.stored) {
+          throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP 304 without cached models)`);
+        }
+        await context.publish({ persist: { ...context.stored, checkedAt } });
+        return;
+      }
+      if (response.status !== 200) {
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP ${String(response.status)})`);
+      }
+      let value;
+      try {
+        value = await response.json();
+      } catch {
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP 200, invalid JSON)`);
+      }
+      if (!Array.isArray(value)) {
+        throw new ModelsError2("model_source", `Model catalog request failed for ${input.id} (HTTP 200, expected an array)`);
+      }
+      const refreshed = usableModels(value);
+      const lastModifiedHeader = response.headers.get("Last-Modified");
+      const parsedLastModified = lastModifiedHeader === null ? undefined : Date.parse(lastModifiedHeader);
+      const lastModified = parsedLastModified === undefined || Number.isNaN(parsedLastModified) ? undefined : parsedLastModified;
+      if (context.signal.aborted)
+        return;
+      await context.publish({
+        persist: {
+          models: value,
+          etag: response.headers.get("ETag") ?? undefined,
+          lastModified,
+          checkedAt
+        },
+        update: () => {
+          catalogModels = refreshed;
+        }
+      });
+    },
+    filterModels: input.filterModels,
+    stream: (model, context, options) => dispatch(model, (streams) => streams.stream(model, context, options)),
+    streamSimple: (model, context, options) => dispatch(model, (streams) => streams.streamSimple(model, context, options))
+  };
+  const streams = single ? [single] : [...byApi.values()].filter((entry) => entry !== undefined);
+  if (streams.some((entry) => entry.fetchDeferred !== undefined)) {
+    provider.fetchDeferred = (model, handle, options) => lazyStream2(model, async () => {
+      const implementation = apiFor(model);
+      if (!implementation?.fetchDeferred) {
+        throw new ModelsError2("provider", `Provider ${input.id} does not support deferred responses for "${model.api}"`);
+      }
+      return implementation.fetchDeferred(model, handle, options);
+    });
+  }
+  if (streams.some((entry) => entry.cancelDeferred !== undefined)) {
+    provider.cancelDeferred = async (model, handle, options) => {
+      const implementation = apiFor(model);
+      if (!implementation?.cancelDeferred) {
+        throw new ModelsError2("provider", `Provider ${input.id} cannot cancel deferred responses for "${model.api}"`);
+      }
+      await implementation.cancelDeferred(model, handle, options);
+    };
+  }
+  return provider;
+}
+
+export { createProvider2 };

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

@@ -0,0 +1,251 @@
+import {
+  defaultNyteHome2
+} from "./account-limits-cache-rz8p1g5y.js";
+import {
+  readCredentialAccounts2
+} from "./account-limits-cache-b0x2sfya.js";
+
+// src/auth/store.ts
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+  writeSync
+} from "node:fs";
+import { hostname } from "node:os";
+import { dirname, join } from "node:path";
+import process from "node:process";
+import { Type } from "typebox";
+import { Value } from "typebox/value";
+function defaultAuthPath2() {
+  return join(defaultNyteHome2(), "auth.json");
+}
+var LOCK_TIMEOUT_MS = 30000;
+var LOCK_RETRY_MS = 25;
+var LOCK_ABANDONED_MS = 2 * LOCK_TIMEOUT_MS;
+var RECOVERY_STALE_MS = 1000;
+var CredentialFileSchema = Type.Record(Type.String(), Type.Unknown());
+var SystemErrorSchema = Type.Object({ code: Type.String() });
+function errorCode(cause) {
+  return Value.Check(SystemErrorSchema, cause) ? cause.code : undefined;
+}
+function lockOwner() {
+  return `${process.pid} ${hostname()} ${randomUUID()}`;
+}
+function readOwner(lockPath) {
+  try {
+    return readFileSync(lockPath, "utf8");
+  } catch {
+    return;
+  }
+}
+function localOwnerPid(owner) {
+  if (owner === undefined)
+    return;
+  const [pid, host] = owner.split(" ");
+  if (host !== hostname())
+    return;
+  const parsed = Number(pid);
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return errorCode(error) === "EPERM";
+  }
+}
+function ageMs(path) {
+  try {
+    return Date.now() - statSync(path).mtimeMs;
+  } catch {
+    return;
+  }
+}
+function lockAbandoned(lockPath) {
+  const pid = localOwnerPid(readOwner(lockPath));
+  if (pid !== undefined && !processAlive(pid))
+    return true;
+  const age = ageMs(lockPath);
+  return age !== undefined && age > LOCK_ABANDONED_MS;
+}
+function createLock(lockPath, owner) {
+  let handle;
+  try {
+    handle = openSync(lockPath, "wx", 384);
+  } catch (error) {
+    if (errorCode(error) === "EEXIST")
+      return false;
+    throw error;
+  }
+  try {
+    writeSync(handle, owner);
+  } finally {
+    closeSync(handle);
+  }
+  return true;
+}
+function reclaimAbandonedLock(lockPath, owner) {
+  const recoveryPath = `${lockPath}.recovery`;
+  if (!createLock(recoveryPath, owner)) {
+    const age = ageMs(recoveryPath);
+    if (age !== undefined && age > RECOVERY_STALE_MS)
+      rmSync(recoveryPath, { force: true });
+    return;
+  }
+  try {
+    if (lockAbandoned(lockPath))
+      rmSync(lockPath, { force: true });
+  } finally {
+    rmSync(recoveryPath, { force: true });
+  }
+}
+async function acquireLock(lockPath, signal) {
+  const owner = lockOwner();
+  const lock = {
+    held: () => readOwner(lockPath) === owner,
+    release: () => {
+      if (readOwner(lockPath) !== owner)
+        return;
+      try {
+        rmSync(lockPath, { force: true });
+      } catch {
+        return;
+      }
+    }
+  };
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  for (;; ) {
+    signal?.throwIfAborted();
+    if (createLock(lockPath, owner))
+      return lock;
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting for the credential lock at ${lockPath}`);
+    }
+    if (lockAbandoned(lockPath))
+      reclaimAbandonedLock(lockPath, owner);
+    await new Promise((resolve) => {
+      setTimeout(resolve, LOCK_RETRY_MS);
+    });
+  }
+}
+async function publish(staging, path) {
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  for (;; ) {
+    try {
+      renameSync(staging, path);
+      return;
+    } catch (error) {
+      const busy = process.platform === "win32" && error instanceof Error && "code" in error && (error.code === "EPERM" || error.code === "EACCES" || error.code === "EBUSY");
+      if (!busy || Date.now() >= deadline)
+        throw error;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, LOCK_RETRY_MS);
+    });
+  }
+}
+
+class FileCredentialStore2 {
+  path;
+  lockPath;
+  constructor(path = defaultAuthPath2()) {
+    this.path = path;
+    this.lockPath = `${path}.lock`;
+  }
+  load() {
+    if (!existsSync(this.path))
+      return {};
+    const text = readFileSync(this.path, "utf8");
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch (error) {
+      throw new Error(`${this.path} is not valid JSON. Fix or remove it, then sign in again.`, {
+        cause: error
+      });
+    }
+    if (!Value.Check(CredentialFileSchema, parsed)) {
+      throw new Error(`${this.path} does not hold credentials keyed by provider`);
+    }
+    return parsed;
+  }
+  async save(lock, entries) {
+    if (!lock.held()) {
+      throw new Error(`Another process took over ${this.lockPath}; nothing was written`);
+    }
+    const staging = `${this.path}.${process.pid}.tmp`;
+    try {
+      writeFileSync(staging, `${JSON.stringify(entries, null, 2)}
+`, { mode: 384 });
+      await publish(staging, this.path);
+    } catch (error) {
+      rmSync(staging, { force: true });
+      throw error;
+    }
+  }
+  async withLock(run, options) {
+    options?.signal?.throwIfAborted();
+    mkdirSync(dirname(this.path), { recursive: true, mode: 448 });
+    const lock = await acquireLock(this.lockPath, options?.signal);
+    try {
+      return await run(lock);
+    } finally {
+      lock.release();
+    }
+  }
+  async read(providerId, options) {
+    options?.signal?.throwIfAborted();
+    return readCredentialAccounts2(this.load()[providerId]);
+  }
+  async list(options) {
+    options?.signal?.throwIfAborted();
+    const stored = [];
+    for (const [providerId, value] of Object.entries(this.load())) {
+      const accounts = readCredentialAccounts2(value);
+      if (accounts)
+        stored.push(...accounts.accounts.map((account) => ({
+          providerId,
+          id: account.id,
+          label: account.label,
+          type: account.credential.type,
+          active: account.id === accounts.active
+        })));
+    }
+    return stored;
+  }
+  modify(providerId, fn, options) {
+    return this.withLock(async (lock) => {
+      const entries = this.load();
+      const current = readCredentialAccounts2(entries[providerId]);
+      const next = await fn(current);
+      if (next !== undefined) {
+        if (next.accounts.length === 0)
+          delete entries[providerId];
+        else
+          entries[providerId] = next;
+        await this.save(lock, entries);
+      }
+      return next ?? current;
+    }, options);
+  }
+  delete(providerId, options) {
+    return this.withLock(async (lock) => {
+      const entries = this.load();
+      if (providerId in entries) {
+        delete entries[providerId];
+        await this.save(lock, entries);
+      }
+    }, options);
+  }
+}
+
+export { defaultAuthPath2, FileCredentialStore2 };

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

@@ -0,0 +1,25 @@
+// src/api/github-copilot-headers.ts
+var GITHUB_COPILOT_API_VERSION2 = "2026-06-01";
+var GITHUB_COPILOT_DEFAULT_ORIGIN2 = "https://api.individual.githubcopilot.com";
+var GITHUB_COPILOT_HEADERS2 = {
+  "User-Agent": "GitHubCopilotChat/0.35.0",
+  "Editor-Version": "vscode/1.107.0",
+  "Editor-Plugin-Version": "copilot-chat/0.35.0",
+  "Copilot-Integration-Id": "vscode-chat"
+};
+function buildCopilotDynamicHeaders2(input) {
+  const last = input.messages.at(-1);
+  const headers = {
+    "X-GitHub-Api-Version": GITHUB_COPILOT_API_VERSION2,
+    "X-Initiator": last && last.role !== "user" ? "agent" : "user",
+    "Openai-Intent": "conversation-edits",
+    "X-Interaction-Type": "conversation-agent"
+  };
+  if (input.sessionId)
+    headers["X-Interaction-Id"] = input.sessionId;
+  if (input.messages.some((message) => (message.role === "user" || message.role === "toolResult") && Array.isArray(message.content) && message.content.some((part) => part.type === "image")))
+    headers["Copilot-Vision-Request"] = "true";
+  return headers;
+}
+
+export { GITHUB_COPILOT_API_VERSION2, GITHUB_COPILOT_DEFAULT_ORIGIN2, GITHUB_COPILOT_HEADERS2, buildCopilotDynamicHeaders2 };

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

@@ -0,0 +1,79 @@
+// src/utils/error-body.ts
+var MAX_PROVIDER_ERROR_BODY_CHARS2 = 4000;
+function normalizeProviderError2(cause) {
+  if (!(cause instanceof Error)) {
+    return { message: safeJsonStringify(cause), messageCarriesBody: false };
+  }
+  const status = extractStatus(cause);
+  const body = extractBody(cause);
+  const messageCarriesBody = body === undefined || cause.message.includes(body);
+  return {
+    status,
+    body,
+    message: cause.message,
+    messageCarriesBody
+  };
+}
+function extractStatus(error) {
+  if (typeof error.statusCode === "number")
+    return error.statusCode;
+  if (typeof error.status === "number")
+    return error.status;
+  if (typeof error.$metadata?.httpStatusCode === "number")
+    return error.$metadata.httpStatusCode;
+  if (typeof error.$response?.statusCode === "number")
+    return error.$response.statusCode;
+  return;
+}
+function extractBody(error) {
+  const bodyText = pickBodyText(error);
+  if (bodyText === undefined)
+    return;
+  const trimmed = bodyText.trim();
+  if (trimmed.length === 0)
+    return;
+  return truncateErrorText(trimmed, MAX_PROVIDER_ERROR_BODY_CHARS2);
+}
+function pickBodyText(error) {
+  if (typeof error.body === "string")
+    return error.body;
+  if (plainObjectWithFields(error.error))
+    return safeJsonStringify(error.error);
+  const responseBody = error.$response?.body;
+  if (typeof responseBody === "string")
+    return responseBody;
+  if (typeof responseBody === "object" && responseBody !== null && "pipe" in responseBody && typeof responseBody.pipe === "function")
+    return;
+  if (plainObjectWithFields(responseBody))
+    return safeJsonStringify(responseBody);
+  return;
+}
+function plainObjectWithFields(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    return false;
+  return Object.keys(value).length > 0;
+}
+function formatProviderError2(norm, prefix) {
+  if (norm.messageCarriesBody || norm.status === undefined || norm.body === undefined) {
+    return prefix !== undefined && norm.status !== undefined ? `${prefix} (${norm.status}): ${norm.message}` : norm.message;
+  }
+  return prefix !== undefined ? `${prefix} (${norm.status}): ${norm.body}` : `${norm.status}: ${norm.body}`;
+}
+function truncateErrorText(text, maxChars) {
+  if (text.length <= maxChars)
+    return text;
+  return `${text.slice(0, maxChars)}... [truncated ${text.length - maxChars} chars]`;
+}
+function safeJsonStringify(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? String(value) : serialized;
+  } catch {
+    return String(value);
+  }
+}
+
+export { MAX_PROVIDER_ERROR_BODY_CHARS2, normalizeProviderError2, formatProviderError2 };

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

@@ -0,0 +1,62 @@
+// src/model-capabilities.ts
+import { MODEL_THINKING_LEVELS } from "@nyte-ai/schema/model";
+function hasApi2(model, api) {
+  return model.api === api;
+}
+function calculateCost2(model, usage) {
+  const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+  let rates = model.cost;
+  let matchedThreshold = -1;
+  for (const tier of model.cost.tiers ?? []) {
+    if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+      rates = tier;
+      matchedThreshold = tier.inputTokensAbove;
+    }
+  }
+  const longWrite = usage.cacheWrite1h ?? 0;
+  const shortWrite = usage.cacheWrite - longWrite;
+  usage.cost.input = rates.input / 1e6 * usage.input;
+  usage.cost.output = rates.output / 1e6 * usage.output;
+  usage.cost.cacheRead = rates.cacheRead / 1e6 * usage.cacheRead;
+  usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1e6;
+  usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+  return usage.cost;
+}
+function getSupportedThinkingLevels2(model) {
+  if (!model.reasoning)
+    return ["off"];
+  return MODEL_THINKING_LEVELS.filter((level) => {
+    const mapped = model.thinkingLevelMap?.[level];
+    if (mapped === null)
+      return false;
+    if (level === "xhigh" || level === "max")
+      return mapped !== undefined;
+    return true;
+  });
+}
+function clampThinkingLevel2(model, level) {
+  const availableLevels = getSupportedThinkingLevels2(model);
+  if (availableLevels.includes(level))
+    return level;
+  const requestedIndex = MODEL_THINKING_LEVELS.findIndex((candidate) => candidate === level);
+  if (requestedIndex === -1)
+    return availableLevels[0] ?? "off";
+  for (let i = requestedIndex;i < MODEL_THINKING_LEVELS.length; i++) {
+    const candidate = MODEL_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate))
+      return candidate;
+  }
+  for (let i = requestedIndex - 1;i >= 0; i--) {
+    const candidate = MODEL_THINKING_LEVELS[i];
+    if (availableLevels.includes(candidate))
+      return candidate;
+  }
+  return availableLevels[0] ?? "off";
+}
+function modelsAreEqual2(a, b) {
+  if (!a || !b)
+    return false;
+  return a.id === b.id && a.provider === b.provider;
+}
+
+export { hasApi2, calculateCost2, getSupportedThinkingLevels2, clampThinkingLevel2, modelsAreEqual2 };