@juspay/neurolink 9.54.3 → 9.54.5

package/dist/cli/commands/authProviders.d.ts

@@ -1,34 +1,5 @@
 import type { ArgumentsCamelCase } from "yargs";
-import type { AuthProviderType } from "../../lib/types/index.js";
-/**
- * Auth command argument types
- */
-export type AuthProvidersArgs = {
-    format?: "text" | "json" | "table";
-};
-export type AuthValidateArgs = {
-    token: string;
-    provider: AuthProviderType;
-    domain?: string;
-    clientId?: string;
-    secretKey?: string;
-    secret?: string;
-    url?: string;
-    anonKey?: string;
-    apiKey?: string;
-    format?: "text" | "json";
-};
-export type AuthHealthArgs = {
-    provider: AuthProviderType;
-    domain?: string;
-    clientId?: string;
-    secretKey?: string;
-    secret?: string;
-    url?: string;
-    anonKey?: string;
-    apiKey?: string;
-    format?: "text" | "json";
-};
+import type { AuthHealthArgs, AuthProvidersArgs, AuthValidateArgs } from "../../lib/types/index.js";
 /**
  * Handle 'auth providers' command
  */

package/dist/cli/commands/config.d.ts

@@ -82,8 +82,8 @@ declare const ConfigSchema: z.ZodObject<{
         enableCaching: z.ZodDefault<z.ZodBoolean>;
         cacheStrategy: z.ZodDefault<z.ZodEnum<{
             file: "file";
-            memory: "memory";
             redis: "redis";
+            memory: "memory";
         }>>;
         defaultEvaluationDomain: z.ZodOptional<z.ZodString>;
         enableAnalyticsByDefault: z.ZodDefault<z.ZodBoolean>;
@@ -124,7 +124,7 @@ declare const ConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-export type NeuroLinkConfig = z.infer<typeof ConfigSchema>;
+type NeuroLinkConfig = z.infer<typeof ConfigSchema>;
 export declare class ConfigManager {
     private configDir;
     private configFile;

package/dist/cli/commands/evaluate.js

@@ -10,7 +10,7 @@ import ora from "ora";
 import fs from "node:fs";
 import { EvaluationPipeline, getPreset, getPresetNames, PipelinePresets, } from "../../lib/evaluation/pipeline/index.js";
 import { ScorerRegistry } from "../../lib/evaluation/scorers/index.js";
-import { ReportGenerator, } from "../../lib/evaluation/reporting/reportGenerator.js";
+import { ReportGenerator } from "../../lib/evaluation/reporting/reportGenerator.js";
 import { logger } from "../../lib/utils/logger.js";
 /**
  * Format score result for display

package/dist/cli/commands/proxy.js

@@ -201,27 +201,200 @@ async function isProxyHealthy(host, port, timeoutMs) {
         return false;
     }
 }
+// ---------------------------------------------------------------------------
+// Stable entrypoint for launchd
+// ---------------------------------------------------------------------------
+/**
+ * Path to a small trampoline script that the plist invokes.
+ * The trampoline re-resolves `neurolink` via PATH on every launch,
+ * so launchd never gets pinned to a version-specific store path.
+ */
+const TRAMPOLINE_DIR = join(homedir(), ".neurolink", "bin");
+const TRAMPOLINE_PATH = join(TRAMPOLINE_DIR, "neurolink-proxy");
+/**
+ * Verify a candidate bin path actually runs by invoking `--version` on it.
+ * Returns the version string on success, or undefined on any failure.
+ */
+function probeBinVersion(binPath) {
+    try {
+        const { execFileSync } = _require("node:child_process");
+        const out = execFileSync(binPath, ["--version"], {
+            encoding: "utf8",
+            timeout: 5_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return out || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write (or overwrite) the trampoline shell script.
+ *
+ * Defensive design: the trampoline tries multiple candidates in order and
+ * only `exec`s one whose `--version` check succeeds. If every PATH-based
+ * candidate is broken (stale shims, missing packages), it falls back to the
+ * baked-in `node + script` path that was verified to work at install time.
+ */
+function writeTrampoline() {
+    const { writeFileSync, mkdirSync, existsSync, chmodSync } = _require("fs");
+    if (!existsSync(TRAMPOLINE_DIR)) {
+        mkdirSync(TRAMPOLINE_DIR, { recursive: true });
+    }
+    // Baked-in fallback: the specific node + JS script currently running
+    // (guaranteed to work, since we ARE running). Used only if all PATH-based
+    // candidates fail their --version probe.
+    const bakedNode = process.execPath;
+    const bakedScript = process.argv[1] ?? join(__dirname, "..", "index.js");
+    // Shell-escape the baked paths (they shouldn't contain quotes in practice,
+    // but be safe for paths with spaces).
+    const shEscape = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+    const script = `#!/bin/sh
+# Auto-generated by \`neurolink proxy install\` — do not edit.
+# Resolves a working neurolink binary on every launchd invocation so the
+# plist never gets pinned to a broken/stale shim.
+
+# Probe a candidate: must be executable and respond to --version cleanly.
+_try() {
+  [ -n "$1" ] && [ -x "$1" ] || return 1
+  "$1" --version >/dev/null 2>&1 || return 1
+  return 0
+}
+
+# 1. Explicit user override (escape hatch for broken environments).
+if [ -n "\${NEUROLINK_BIN:-}" ]; then
+  if _try "$NEUROLINK_BIN"; then
+    exec "$NEUROLINK_BIN" "$@"
+  fi
+  echo "[neurolink-proxy] WARN: NEUROLINK_BIN=$NEUROLINK_BIN is not runnable, trying defaults" >&2
+fi
+
+# 2. PATH-based and common install locations. First working one wins.
+for cand in \\
+    "$(command -v neurolink 2>/dev/null || true)" \\
+    "\${PNPM_HOME:-}/neurolink" \\
+    "$HOME/.local/share/pnpm/neurolink" \\
+    "$HOME/Library/pnpm/neurolink" \\
+    "/usr/local/bin/neurolink" \\
+    "/opt/homebrew/bin/neurolink"; do
+  if _try "$cand"; then
+    exec "$cand" "$@"
+  fi
+done
+
+# 3. Baked-in fallback: the exact node + script that worked at install time.
+#    Always valid at install time; may become stale after package updates
+#    (but at that point the PATH candidates above should work).
+BAKED_NODE=${shEscape(bakedNode)}
+BAKED_SCRIPT=${shEscape(bakedScript)}
+if [ -x "$BAKED_NODE" ] && [ -f "$BAKED_SCRIPT" ]; then
+  exec "$BAKED_NODE" "$BAKED_SCRIPT" "$@"
+fi
+
+echo "[neurolink-proxy] FATAL: no working neurolink binary found." >&2
+echo "[neurolink-proxy] Tried: PATH, \\$PNPM_HOME, \\$HOME/.local/share/pnpm, \\$HOME/Library/pnpm, /usr/local/bin, /opt/homebrew/bin, baked-in install path." >&2
+echo "[neurolink-proxy] Fix: reinstall with 'pnpm add -g @juspay/neurolink' or set NEUROLINK_BIN=/path/to/working/neurolink." >&2
+exit 127
+`;
+    writeFileSync(TRAMPOLINE_PATH, script, { mode: 0o755 });
+    chmodSync(TRAMPOLINE_PATH, 0o755);
+}
+/**
+ * Resolve the `pnpm` binary defensively.
+ *
+ * Tries multiple candidates in order of preference and validates each by
+ * running `--version`. Returns the first one that actually works, along
+ * with a list of all candidates tried (for diagnostics). This defends
+ * against environments where `which pnpm` returns a broken shim or an
+ * incompatible version.
+ *
+ * Honors `NEUROLINK_PNPM_PATH` as an escape hatch.
+ */
+function resolveFullPnpmPath() {
+    const candidates = [];
+    // 1. User override
+    if (process.env.NEUROLINK_PNPM_PATH) {
+        candidates.push(process.env.NEUROLINK_PNPM_PATH);
+    }
+    // 2. PNPM_HOME (pnpm's own env variable)
+    if (process.env.PNPM_HOME) {
+        candidates.push(join(process.env.PNPM_HOME, "pnpm"));
+    }
+    // 3. `which pnpm` — whatever is on PATH
+    try {
+        const { execFileSync } = _require("node:child_process");
+        const whichOut = execFileSync("which", ["pnpm"], {
+            encoding: "utf8",
+            timeout: 5_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (whichOut) {
+            candidates.push(whichOut);
+        }
+    }
+    catch {
+        // ignore
+    }
+    // 4. Common standalone installer locations
+    candidates.push(join(homedir(), ".local", "share", "pnpm", "pnpm"));
+    candidates.push(join(homedir(), "Library", "pnpm", "pnpm"));
+    // Dedupe while preserving order
+    const seen = new Set();
+    const unique = candidates.filter((p) => {
+        if (!p || seen.has(p)) {
+            return false;
+        }
+        seen.add(p);
+        return true;
+    });
+    // Probe each candidate
+    const tried = unique.map((path) => {
+        const version = probeBinVersion(path);
+        return { path, version, working: version !== undefined };
+    });
+    const working = tried.find((r) => r.working);
+    if (working) {
+        return {
+            bin: working.path,
+            resolved: true,
+            version: working.version,
+            tried,
+        };
+    }
+    return { bin: "pnpm", resolved: false, tried };
+}
 function spawnFailOpenGuard(host, port, parentPid) {
+    // The guard runs the same version as this process, so process.argv[1]
+    // (the currently-running script) is correct here — no stale-path risk.
     const entryScript = process.argv[1];
     if (!entryScript) {
         return undefined;
     }
+    const args = [
+        entryScript,
+        "proxy",
+        "guard",
+        "--host",
+        host,
+        "--port",
+        String(port),
+        "--parent-pid",
+        String(parentPid),
+        "--quiet",
+    ];
+    // Write guard stdout/stderr to a log file instead of discarding them.
+    const { openSync, closeSync, mkdirSync, existsSync } = _require("fs");
+    const guardLogDir = join(homedir(), ".neurolink", "logs");
+    if (!existsSync(guardLogDir)) {
+        mkdirSync(guardLogDir, { recursive: true });
+    }
+    const guardLogPath = join(guardLogDir, "proxy-guard.log");
+    const logFd = openSync(guardLogPath, "a");
     try {
-        const args = [
-            entryScript,
-            "proxy",
-            "guard",
-            "--host",
-            host,
-            "--port",
-            String(port),
-            "--parent-pid",
-            String(parentPid),
-            "--quiet",
-        ];
         const child = spawn(process.execPath, args, {
             detached: true,
-            stdio: "ignore",
+            stdio: ["ignore", logFd, logFd],
         });
         child.unref();
         return child.pid;
@@ -230,6 +403,9 @@ function spawnFailOpenGuard(host, port, parentPid) {
         logger.debug(`[proxy] failed to start fail-open guard: ${error instanceof Error ? error.message : String(error)}`);
         return undefined;
     }
+    finally {
+        closeSync(logFd); // parent closes its copy; child keeps the fd
+    }
 }
 async function runProxyTelemetryManager(command) {
     const { existsSync } = await import("fs");
@@ -568,10 +744,7 @@ async function createProxyStartApp(params) {
                     success: account.successCount,
                     errors: account.errorCount,
                     rateLimits: account.rateLimitCount,
-                    backoffLevel: account.currentBackoffLevel,
-                    cooling: account.coolingUntil
-                        ? account.coolingUntil > Date.now()
-                        : false,
+                    cooling: false, // No persistent cooldown — always active
                 })),
             },
             config: params.proxyConfig
@@ -1294,34 +1467,113 @@ export const proxyGuardCommand = {
                     logger.always(`[guard] WARNING: invalid version format "${result.latestVersion}", skipping`);
                     return;
                 }
-                logger.always(`[guard] traffic quiet, installing @juspay/neurolink@${result.latestVersion}...`);
+                // Resolve pnpm to a deterministic path, validating that it actually
+                // runs (some environments have broken shims on PATH).
+                const pnpmResolution = resolveFullPnpmPath();
+                // Log the full candidate list so operators can see why a particular
+                // pnpm was chosen (or why none worked).
+                logger.always(`[guard] pnpm candidates: ${pnpmResolution.tried
+                    .map((c) => `${c.path}(${c.working ? `v${c.version}` : "BROKEN"})`)
+                    .join(", ")}`);
+                if (!pnpmResolution.resolved) {
+                    // Environmental problem, not version-specific — skip this cycle
+                    // without suppressing the version (so we retry on the next tick
+                    // once the user fixes pnpm).
+                    logger.always(`[guard] WARNING: no working pnpm found; skipping update cycle. Install pnpm or set NEUROLINK_PNPM_PATH.`);
+                    return;
+                }
+                logger.always(`[guard] traffic quiet, installing @juspay/neurolink@${result.latestVersion} via ${pnpmResolution.bin} (pnpm v${pnpmResolution.version})...`);
                 const { execFileSync } = await import("node:child_process");
                 try {
-                    execFileSync("pnpm", ["add", "-g", `@juspay/neurolink@${result.latestVersion}`], {
+                    execFileSync(pnpmResolution.bin, ["add", "-g", `@juspay/neurolink@${result.latestVersion}`], {
                         timeout: 120_000,
                         stdio: "pipe",
                     });
                 }
                 catch (installErr) {
-                    logger.always(`[guard] WARNING: pnpm install failed: ${installErr instanceof Error ? installErr.message : String(installErr)}`);
-                    suppressVersion(result.latestVersion, "install_failed");
+                    // Capture stderr for actionable diagnostics
+                    const stderr = installErr &&
+                        typeof installErr === "object" &&
+                        "stderr" in installErr
+                        ? String(installErr.stderr).slice(0, 500)
+                        : "";
+                    const msg = installErr instanceof Error
+                        ? installErr.message
+                        : String(installErr);
+                    logger.always(`[guard] WARNING: pnpm install failed: ${msg}${stderr ? `\n  stderr: ${stderr}` : ""}`);
+                    suppressVersion(result.latestVersion, `install_failed: ${msg.slice(0, 200)}${stderr ? ` | stderr: ${stderr.slice(0, 200)}` : ""}`);
                     return;
                 }
-                // 4. Restart via launchctl
+                // 4. Rewrite the launchd plist so it picks up the (possibly new)
+                //    stable bin path, then restart via launchctl.
+                try {
+                    const { writeFileSync, existsSync: fsExists, mkdirSync: fsMkdir, } = await import("fs");
+                    if (!fsExists(PLIST_DIR)) {
+                        fsMkdir(PLIST_DIR, { recursive: true });
+                    }
+                    // Rewrite the trampoline and plist so the restarted service
+                    // resolves the newly installed binary via PATH.
+                    writeTrampoline();
+                    // Validate the trampoline actually resolves to the NEW version
+                    // before asking launchd to restart. If the install somehow left
+                    // PATH still pointing at the old version, don't kickstart.
+                    const probed = probeBinVersion(TRAMPOLINE_PATH);
+                    if (!probed) {
+                        logger.always(`[guard] WARNING: trampoline does not resolve to a working neurolink after install; skipping restart.`);
+                        suppressVersion(result.latestVersion, `trampoline_broken_after_install: ${TRAMPOLINE_PATH} --version failed`);
+                        return;
+                    }
+                    if (probed !== result.latestVersion) {
+                        // The trampoline resolves to a DIFFERENT version than what we
+                        // just installed. This means `pnpm add -g` installed into a
+                        // store that PATH doesn't reach (store mismatch), or PATH still
+                        // shadows with an older shim. Restarting would run the wrong
+                        // version — abort.
+                        logger.always(`[guard] ABORT: trampoline resolves to v${probed} but installed v${result.latestVersion}.`);
+                        logger.always(`[guard]   pnpm used: ${pnpmResolution.bin} (v${pnpmResolution.version})`);
+                        logger.always(`[guard]   This usually means pnpm's global store doesn't match the PATH-visible neurolink.`);
+                        logger.always(`[guard]   Fix: run 'pnpm add -g @juspay/neurolink' with the SAME pnpm whose bin dir is on PATH.`);
+                        suppressVersion(result.latestVersion, `version_mismatch: trampoline=${probed} expected=${result.latestVersion} pnpm=${pnpmResolution.bin}(v${pnpmResolution.version})`);
+                        return;
+                    }
+                    const existingArgs = parseExistingPlistArgs();
+                    const updatedPlist = buildPlist(port, host, existingArgs.envFile, existingArgs.configFile);
+                    writeFileSync(PLIST_PATH, updatedPlist, "utf-8");
+                    logger.always(`[guard] trampoline (resolves to v${probed}) + plist rewritten at ${PLIST_PATH}`);
+                }
+                catch (plistErr) {
+                    logger.always(`[guard] WARNING: failed to rewrite plist (restart may use stale path): ${plistErr instanceof Error ? plistErr.message : String(plistErr)}`);
+                    // Continue with restart anyway — the stable bin symlink may still be correct
+                }
                 // Signal the health loop to not exit when it detects
                 // the parent PID is gone — we're intentionally restarting.
                 updateRestartInProgress = true;
-                logger.always(`[guard] restarting proxy via launchctl...`);
+                logger.always(`[guard] restarting proxy via launchctl bootout/bootstrap...`);
                 const uid = process.getuid?.() ?? 501;
                 try {
-                    execFileSync("launchctl", ["kickstart", "-k", `gui/${uid}/${PLIST_LABEL}`], {
+                    // bootout unloads the in-memory job definition. This is required
+                    // because `kickstart -k` reuses the cached plist and ignores any
+                    // on-disk changes (like the trampoline rewrite above).
+                    try {
+                        execFileSync("launchctl", ["bootout", `gui/${uid}/${PLIST_LABEL}`], { timeout: 10_000, stdio: "pipe" });
+                    }
+                    catch {
+                        // Job may not be loaded (first install, or already unloaded)
+                    }
+                    // bootstrap loads the plist fresh from disk, picking up the
+                    // new trampoline-based ProgramArguments.
+                    execFileSync("launchctl", ["bootstrap", `gui/${uid}`, PLIST_PATH], {
                         timeout: 10_000,
                         stdio: "pipe",
                     });
                 }
-                catch {
-                    logger.always(`[guard] WARNING: launchctl kickstart failed`);
-                    suppressVersion(result.latestVersion, "restart_failed");
+                catch (restartErr) {
+                    updateRestartInProgress = false;
+                    const msg = restartErr instanceof Error
+                        ? restartErr.message
+                        : String(restartErr);
+                    logger.always(`[guard] WARNING: launchctl bootstrap failed: ${msg}`);
+                    suppressVersion(result.latestVersion, `restart_failed: ${msg.slice(0, 200)}`);
                     return;
                 }
                 // 5. Wait for healthy restart
@@ -1584,9 +1836,42 @@ function buildLaunchdPath() {
     }
     return [...segments].join(":");
 }
+/**
+ * Parse the existing launchd plist to extract --env-file and --config values.
+ * Used by the auto-updater to rewrite the plist with the same configuration.
+ */
+function parseExistingPlistArgs() {
+    try {
+        const { readFileSync, existsSync: fsExists } = _require("fs");
+        if (!fsExists(PLIST_PATH)) {
+            return {};
+        }
+        const xml = readFileSync(PLIST_PATH, "utf-8");
+        // Extract --env-file value: <string>--env-file</string>\n    <string>VALUE</string>
+        const envMatch = xml.match(/<string>--env-file<\/string>\s*<string>([^<]+)<\/string>/);
+        const configMatch = xml.match(/<string>--config<\/string>\s*<string>([^<]+)<\/string>/);
+        // Unescape XML entities so buildPlist() doesn't double-escape them.
+        const unescapeXml = (value) => value
+            ?.replace(/&apos;/g, "'")
+            .replace(/&quot;/g, '"')
+            .replace(/&gt;/g, ">")
+            .replace(/&lt;/g, "<")
+            .replace(/&amp;/g, "&");
+        return {
+            envFile: unescapeXml(envMatch?.[1]),
+            configFile: unescapeXml(configMatch?.[1]),
+        };
+    }
+    catch {
+        return {};
+    }
+}
 function buildPlist(port, host, envFile, configFile) {
-    const nodeExec = escapeXml(process.execPath);
-    const entryScript = escapeXml(process.argv[1] ?? join(__dirname, "..", "index.js"));
+    // The plist invokes the trampoline script (a tiny shell wrapper at
+    // ~/.neurolink/bin/neurolink-proxy) which re-resolves the real
+    // `neurolink` binary via PATH on every launch.  This way, launchd
+    // is never pinned to a version-specific pnpm store path.
+    const trampolinePath = escapeXml(TRAMPOLINE_PATH);
     const envFileArgs = envFile
         ? `
     <string>--env-file</string>
@@ -1607,8 +1892,7 @@ function buildPlist(port, host, envFile, configFile) {
 
   <key>ProgramArguments</key>
   <array>
-    <string>${nodeExec}</string>
-    <string>${entryScript}</string>
+    <string>${trampolinePath}</string>
     <string>proxy</string>
     <string>start</string>
     <string>--port</string>
@@ -1709,6 +1993,24 @@ export const proxyInstallCommand = {
         if (!existsSync(PLIST_DIR)) {
             mkdirSync(PLIST_DIR, { recursive: true });
         }
+        writeTrampoline();
+        console.info(chalk.green(`✓ Trampoline written to ${TRAMPOLINE_PATH}`));
+        // Sanity-check: run the trampoline itself and confirm it resolves to
+        // a working neurolink binary. This catches environments where every
+        // PATH-based candidate is broken AND the baked-in path is unreachable.
+        const trampolineVersion = probeBinVersion(TRAMPOLINE_PATH);
+        if (!trampolineVersion) {
+            console.info(chalk.red(`✗ Trampoline validation failed: ${TRAMPOLINE_PATH} --version did not run cleanly.`));
+            console.info(chalk.yellow(`  The launchd service would not be able to start neurolink. Fix your install first.`));
+            console.info(chalk.yellow(`  Try: 'pnpm add -g @juspay/neurolink' or set NEUROLINK_BIN=/path/to/working/neurolink.`));
+            process.exit(1);
+        }
+        if (trampolineVersion !== PROXY_VERSION) {
+            console.info(chalk.red(`✗ Trampoline resolves to v${trampolineVersion} but this installer is v${PROXY_VERSION}.`));
+            console.info(chalk.yellow(`  PATH may shadow this installation with an older version. Fix your PATH or set NEUROLINK_BIN.`));
+            process.exit(1);
+        }
+        console.info(chalk.green(`✓ Trampoline validated (resolves to neurolink v${trampolineVersion})`));
         const plist = buildPlist(port, host, envFile, configFile);
         writeFileSync(PLIST_PATH, plist, "utf-8");
         console.info(chalk.green(`✓ Plist written to ${PLIST_PATH}`));

package/dist/cli/loop/conversationSelector.d.ts

@@ -2,8 +2,7 @@
  * Conversation Selector for Loop Mode
  * Handles discovery and selection of stored conversations from Redis
  */
-import type { ConversationSummary } from "../../lib/types/index.js";
-import type { RedisStorageConfig } from "../../lib/types/index.js";
+import type { ConversationSummary, RedisStorageConfig } from "../../lib/types/index.js";
 export declare class ConversationSelector {
     private redisClient;
     private redisConfig;

package/dist/cli/loop/conversationSelector.js

@@ -21,7 +21,7 @@ export class ConversationSelector {
     async initializeRedis() {
         if (!this.redisClient) {
             // Cast is necessary: createRedisClient returns the ioredis client type which
-            // does not structurally match our RedisClient interface due to overloaded
+            // does not structurally match our CliRedisClient interface due to overloaded
             // method signatures. The runtime value is fully compatible.
             this.redisClient = (await createRedisClient(this.redisConfig));
         }

package/dist/cli/loop/optionsSchema.d.ts

@@ -1,5 +1,4 @@
-import type { OptionSchema } from "../../lib/types/index.js";
-import type { TextGenerationOptions } from "../../lib/types/index.js";
+import type { OptionSchema, TextGenerationOptions } from "../../lib/types/index.js";
 /**
  * Master schema for all text generation options.
  * This object provides metadata for validation and help text in the CLI loop.

package/dist/cli/utils/completeSetup.d.ts

@@ -4,7 +4,7 @@
  * Orchestrates the entire setup process: interactive wizard, environment management,
  * provider testing, and summary display.
  */
-import { type SetupResult } from "./interactiveSetup.js";
+import type { SetupResult } from "../../lib/types/index.js";
 /**
  * Run the complete interactive setup process
  */

package/dist/cli/utils/interactiveSetup.d.ts

@@ -5,7 +5,8 @@
  * credential collection, testing, and environment file management.
  */
 import { AIProviderName } from "../../lib/constants/enums.js";
-export type ProviderConfig = {
+import type { SetupResult } from "../../lib/types/index.js";
+type ProviderConfig = {
     id: AIProviderName;
     name: string;
     description: string;
@@ -18,17 +19,6 @@ export type ProviderConfig = {
     }>;
 };
 export declare const PROVIDER_CONFIGS: ProviderConfig[];
-export type SetupResult = {
-    selectedProviders: AIProviderName[];
-    credentials: Record<string, string>;
-    envFileBackup?: string;
-    testResults: Array<{
-        provider: AIProviderName;
-        status: "working" | "failed";
-        error?: string;
-        responseTime?: number;
-    }>;
-};
 /**
  * Run the interactive setup wizard
  */
@@ -46,3 +36,4 @@ export declare function testProviderConnectivity(providers: AIProviderName[], qu
  * Display setup summary
  */
 export declare function displaySetupSummary(result: SetupResult, quiet?: boolean): void;
+export {};

package/dist/cli/utils/videoFileUtils.d.ts

@@ -11,7 +11,7 @@ import type { VideoGenerationResult } from "../../lib/types/index.js";
 /**
  * Result of saving video to file
  */
-export type VideoSaveResult = {
+type VideoSaveResult = {
     /** Whether the save was successful */
     success: boolean;
     /** Full path to the saved file */
@@ -109,3 +109,4 @@ export declare function isVideoGenerationResult(obj: unknown): obj is VideoGener
  * @returns Formatted metadata summary string
  */
 export declare function getVideoMetadataSummary(video: VideoGenerationResult): string;
+export {};

package/dist/client/aiSdkAdapter.d.ts

@@ -7,7 +7,7 @@
  *
  * @module @neurolink/ai-sdk
  */
-import type { LanguageModel, LanguageModelCallOptions, LanguageModelResponse, LanguageModelStreamResponse, NeuroLinkProviderOptions, ModelOptions } from "../types/clientTypes.js";
+import type { ClientLanguageModel, ClientLanguageModelCallOptions, ClientLanguageModelResponse, ClientLanguageModelStreamResponse, NeuroLinkProviderOptions, ClientModelOptions } from "../types/index.js";
 import { NeuroLinkClient } from "./httpClient.js";
 /**
  * NeuroLink Language Model implementation compatible with Vercel AI SDK
@@ -30,23 +30,23 @@ import { NeuroLinkClient } from "./httpClient.js";
  * });
  * ```
  */
-export declare class NeuroLinkLanguageModel implements LanguageModel {
+export declare class NeuroLinkLanguageModel implements ClientLanguageModel {
     readonly modelId: string;
     readonly provider: string;
     private client;
     private options;
-    constructor(client: NeuroLinkClient, modelId: string, provider: string, options?: ModelOptions);
+    constructor(client: NeuroLinkClient, modelId: string, provider: string, options?: ClientModelOptions);
     /**
      * Generate a non-streaming response
      */
-    doGenerate(options: LanguageModelCallOptions): Promise<LanguageModelResponse>;
+    doGenerate(options: ClientLanguageModelCallOptions): Promise<ClientLanguageModelResponse>;
     /**
      * Generate a streaming response
      *
      * Uses an async queue so that each text delta from the provider is yielded
      * to the consumer immediately, rather than buffering the entire response.
      */
-    doStream(options: LanguageModelCallOptions): Promise<LanguageModelStreamResponse>;
+    doStream(options: ClientLanguageModelCallOptions): Promise<ClientLanguageModelStreamResponse>;
     /**
      * Map NeuroLink finish reasons to AI SDK finish reasons
      */
@@ -87,11 +87,11 @@ export declare class NeuroLinkProvider {
      * @param modelId - Model ID (e.g., 'gpt-4o', 'claude-3-opus')
      * @param options - Additional model options
      */
-    model(modelId?: string, options?: ModelOptions): NeuroLinkLanguageModel;
+    model(modelId?: string, options?: ClientModelOptions): NeuroLinkLanguageModel;
     /**
      * Alias for model() - makes the provider callable
      */
-    call(modelId?: string, options?: ModelOptions): NeuroLinkLanguageModel;
+    call(modelId?: string, options?: ClientModelOptions): NeuroLinkLanguageModel;
     /**
      * Infer provider from model ID
      */
@@ -119,7 +119,7 @@ export declare class NeuroLinkProvider {
  * });
  * ```
  */
-export declare function createNeuroLinkProvider(options: NeuroLinkProviderOptions): NeuroLinkProvider & ((modelId?: string, modelOptions?: ModelOptions) => NeuroLinkLanguageModel);
+export declare function createNeuroLinkProvider(options: NeuroLinkProviderOptions): NeuroLinkProvider & ((modelId?: string, modelOptions?: ClientModelOptions) => NeuroLinkLanguageModel);
 /**
  * Create a standalone NeuroLink model for Vercel AI SDK
  *
@@ -193,4 +193,3 @@ export declare function createStreamingResponse(options: NeuroLinkProviderOption
     maxTokens?: number;
     systemPrompt?: string;
 }): Promise<Response>;
-export type { LanguageModel, LanguageModelCallOptions, LanguageModelResponse, LanguageModelStreamResponse, NeuroLinkProviderOptions, ModelOptions, } from "../types/clientTypes.js";