@nyte-ai/ai 0.0.0-stage → 0.0.18

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-c7v93krb.js

@@ -0,0 +1,235 @@
+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);
+    });
+  }
+}
+
+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;
+  }
+  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 });
+      renameSync(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;
+        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];
+        this.save(lock, entries);
+      }
+    }, options);
+  }
+}
+
+export { defaultAuthPath2, FileCredentialStore2 };

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 };