@juspay/neurolink 11.11.5 → 11.11.7

package/dist/cli/proxy-clients/openCode.js

@@ -0,0 +1,162 @@
+/**
+ * OpenCode client configurator.
+ *
+ * Moved verbatim out of `proxy.ts` so that adding a CLI means adding a file
+ * here rather than editing a 5,000-line command module in seven places.
+ */
+import { homedir } from "os";
+import { join } from "path";
+import { logger } from "../../lib/utils/logger.js";
+function getOpenCodeConfigDir() {
+    // OpenCode resolves this with the unmodified `xdg-basedir` package —
+    // `XDG_CONFIG_HOME || ~/.config` — on every platform, macOS included. There
+    // is deliberately no darwin branch here: `~/Library/Application Support/
+    // opencode` is not a path OpenCode reads. (The similar-looking literal in
+    // OpenCode's binary is `systemManagedConfigDir()`, an MDM policy directory
+    // at the filesystem root with no $HOME prefix.)
+    return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+}
+function getOpenCodeConfigPath() {
+    return join(getOpenCodeConfigDir(), "opencode.json");
+}
+/**
+ * Key under which we persist the snapshot of the user's pre-existing
+ * `provider.neurolink` config inside `opencode.json` itself. Persisting (rather
+ * than relying on in-process state) means restoration still works even if the
+ * proxy crashes or shutdown handlers run in a different process.
+ *
+ * Mirrors the Claude pattern (`__proxy_original_env` inside Claude's settings).
+ */
+const OPENCODE_ORIGINAL_KEY = "__proxy_original_neurolink";
+export async function setOpenCodeProxySettings(baseUrl, proxyKey) {
+    const fs = await import("fs");
+    const configDir = getOpenCodeConfigDir();
+    try {
+        fs.accessSync(configDir);
+    }
+    catch {
+        // OpenCode not installed — config directory does not exist. Report the
+        // skip so the caller does not print a success message for work that did
+        // not happen.
+        return false;
+    }
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(getOpenCodeConfigPath(), "utf8"));
+    }
+    catch {
+        // file missing/invalid — create fresh config object
+        config = { provider: {} };
+    }
+    const provider = (config.provider ?? {});
+    // Persist a snapshot of the user's pre-existing provider.neurolink — but
+    // only the first time we touch the file. Subsequent set() calls must NOT
+    // overwrite the snapshot (otherwise after the proxy writes its own block,
+    // the next set() would store the proxy's block as the "original" and
+    // permanently lose the user's real config on the next clear()).
+    if (!(OPENCODE_ORIGINAL_KEY in config)) {
+        config[OPENCODE_ORIGINAL_KEY] =
+            "neurolink" in provider
+                ? JSON.parse(JSON.stringify(provider.neurolink))
+                : null;
+    }
+    provider.neurolink = {
+        id: "neurolink",
+        name: "NeuroLink Proxy",
+        npm: "@ai-sdk/openai-compatible",
+        env: [],
+        models: {},
+        options: {
+            baseURL: baseUrl,
+            apiKey: proxyKey || "neurolink-proxy",
+        },
+    };
+    config.provider = provider;
+    fs.writeFileSync(getOpenCodeConfigPath(), JSON.stringify(config, null, 2));
+    return true;
+}
+export async function clearOpenCodeProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    let config;
+    try {
+        config = JSON.parse(fs.readFileSync(getOpenCodeConfigPath(), "utf8"));
+    }
+    catch {
+        return false;
+    }
+    const provider = config.provider;
+    if (!provider || !("neurolink" in provider)) {
+        return false;
+    }
+    // Check if our proxy URL matches before removing
+    const existing = provider.neurolink;
+    if (expectedBaseUrl && existing) {
+        const options = existing.options;
+        if (options && typeof options.baseURL === "string") {
+            if (options.baseURL !== expectedBaseUrl) {
+                // User configured a different URL; do not clobber
+                return false;
+            }
+        }
+    }
+    const hadNeurolink = "neurolink" in provider;
+    // Restore from the snapshot persisted at first set(), regardless of process
+    // identity. Only delete provider.neurolink when the snapshot says the user
+    // explicitly had no entry before — never on an "undefined" snapshot, since
+    // that would mean the snapshot was lost and we cannot prove the entry is ours.
+    if (OPENCODE_ORIGINAL_KEY in config) {
+        const snapshot = config[OPENCODE_ORIGINAL_KEY];
+        if (snapshot === null) {
+            // User had no provider.neurolink before the proxy started — safe to remove.
+            delete provider.neurolink;
+        }
+        else {
+            provider.neurolink = snapshot;
+        }
+        delete config[OPENCODE_ORIGINAL_KEY];
+    }
+    else {
+        // No snapshot present — refuse to delete to avoid destroying a config
+        // the proxy may not own (e.g. a user wrote their own `neurolink` block
+        // before the snapshot key was introduced, or this is being cleared from
+        // a process that never ran set()).
+        logger.debug("[proxy] OpenCode clear: no original-provider snapshot found, leaving provider.neurolink intact");
+        return false;
+    }
+    config.provider = provider;
+    fs.writeFileSync(getOpenCodeConfigPath(), JSON.stringify(config, null, 2));
+    return hadNeurolink;
+}
+/**
+ * Test-only export (CLAUDE.md rule 15 determinism exception). The OpenCode
+ * client writers resolve paths from the environment and are only reachable
+ * from `proxy start` / `proxy setup`, neither of which can be driven against a
+ * throwaway HOME without starting a real server. Consumed by
+ * test/continuous-test-suite-proxy.ts.
+ */
+export const __openCodeTestHooks = {
+    getOpenCodeConfigDir,
+    getOpenCodeConfigPath,
+    setOpenCodeProxySettings,
+    clearOpenCodeProxySettings,
+};
+export const openCodeConfigurator = {
+    id: "opencode",
+    displayName: "OpenCode",
+    detect: async () => {
+        const fs = await import("fs");
+        try {
+            fs.accessSync(getOpenCodeConfigDir());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    // OpenCode speaks OpenAI Chat Completions, so it points at the /v1 door
+    // rather than the proxy root. The suffix belongs to the client, not the
+    // caller — every call site used to have to remember it.
+    apply: (proxyBaseUrl) => setOpenCodeProxySettings(`${proxyBaseUrl}/v1`),
+    restore: (proxyBaseUrl) => clearOpenCodeProxySettings(`${proxyBaseUrl}/v1`),
+};
+//# sourceMappingURL=openCode.js.map

package/dist/cli/proxy-clients/qwenCode.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Qwen Code client configurator.
+ *
+ * Qwen Code is OpenAI-compatible: its `cli.js` reads `OPENAI_BASE_URL` and
+ * `OPENAI_API_KEY`, and its settings file carries the same pair under
+ * `security.auth`. It therefore needs no new proxy route — it points at the
+ * existing `/v1/chat/completions` door.
+ *
+ * Settings shape verified against a real `~/.qwen/settings.json` (`$version` 2)
+ * from `@qwen-code/qwen-code@0.17.0`:
+ *
+ *   {
+ *     "security": { "auth": {
+ *       "selectedType": "openai", "apiKey": "...", "baseUrl": "https://..."
+ *     } },
+ *     "model": { "name": "..." },
+ *     "$version": 2
+ *   }
+ */
+import type { CliProxyClientConfigurator } from "../../lib/types/index.js";
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+declare function getQwenConfigDir(): string;
+declare function getQwenSettingsPath(): string;
+export declare function setQwenProxySettings(baseUrl: string, proxyKey?: string): Promise<boolean>;
+export declare function clearQwenProxySettings(expectedBaseUrl?: string): Promise<boolean>;
+export declare const qwenCodeConfigurator: CliProxyClientConfigurator;
+export declare const __qwenCodeTestHooks: {
+    getQwenConfigDir: typeof getQwenConfigDir;
+    getQwenSettingsPath: typeof getQwenSettingsPath;
+    setQwenProxySettings: typeof setQwenProxySettings;
+    clearQwenProxySettings: typeof clearQwenProxySettings;
+};
+export {};

package/dist/cli/proxy-clients/qwenCode.js

@@ -0,0 +1,139 @@
+/**
+ * Qwen Code client configurator.
+ *
+ * Qwen Code is OpenAI-compatible: its `cli.js` reads `OPENAI_BASE_URL` and
+ * `OPENAI_API_KEY`, and its settings file carries the same pair under
+ * `security.auth`. It therefore needs no new proxy route — it points at the
+ * existing `/v1/chat/completions` door.
+ *
+ * Settings shape verified against a real `~/.qwen/settings.json` (`$version` 2)
+ * from `@qwen-code/qwen-code@0.17.0`:
+ *
+ *   {
+ *     "security": { "auth": {
+ *       "selectedType": "openai", "apiKey": "...", "baseUrl": "https://..."
+ *     } },
+ *     "model": { "name": "..." },
+ *     "$version": 2
+ *   }
+ */
+import { homedir } from "os";
+import { join } from "path";
+import { logger } from "../../lib/utils/logger.js";
+/**
+ * Resolved per call rather than at module load so `detect()` and `apply()`
+ * agree when HOME changes — under test, and on the `--dev` isolation path.
+ */
+function getQwenConfigDir() {
+    return join(homedir(), ".qwen");
+}
+function getQwenSettingsPath() {
+    return join(getQwenConfigDir(), "settings.json");
+}
+/**
+ * Key under which the user's pre-existing `security.auth` block is stashed,
+ * inside the settings file itself. Persisting it there (rather than in memory)
+ * means a restore still works after a crash, or from a different process —
+ * the same approach the Claude and OpenCode writers take.
+ */
+const QWEN_ORIGINAL_KEY = "__proxy_original_qwen_auth";
+function readQwenSettings(fs) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(getQwenSettingsPath(), "utf8"));
+        return parsed !== null && typeof parsed === "object"
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function setQwenProxySettings(baseUrl, proxyKey) {
+    const fs = await import("fs");
+    try {
+        fs.accessSync(getQwenConfigDir());
+    }
+    catch {
+        // Qwen Code not installed — report the skip so no caller prints a success
+        // message for work that did not happen.
+        return false;
+    }
+    const settings = readQwenSettings(fs) ?? {};
+    const security = (settings.security ?? {});
+    const auth = (security.auth ?? {});
+    // Snapshot only on first touch. A second apply() must not overwrite the
+    // snapshot with our own block, which would lose the user's real config on
+    // the next restore.
+    if (!(QWEN_ORIGINAL_KEY in settings)) {
+        settings[QWEN_ORIGINAL_KEY] =
+            "auth" in security ? JSON.parse(JSON.stringify(auth)) : null;
+    }
+    auth.selectedType = "openai";
+    auth.baseUrl = baseUrl;
+    auth.apiKey = proxyKey || "neurolink-proxy";
+    security.auth = auth;
+    settings.security = security;
+    fs.writeFileSync(getQwenSettingsPath(), JSON.stringify(settings, null, 2));
+    return true;
+}
+export async function clearQwenProxySettings(expectedBaseUrl) {
+    const fs = await import("fs");
+    const settings = readQwenSettings(fs);
+    if (!settings) {
+        return false;
+    }
+    const security = settings.security;
+    const auth = security?.auth;
+    if (!security || !auth) {
+        return false;
+    }
+    // The user may have pointed Qwen somewhere else since the proxy started.
+    // Never clobber a base URL we did not write.
+    if (expectedBaseUrl &&
+        typeof auth.baseUrl === "string" &&
+        auth.baseUrl !== expectedBaseUrl) {
+        return false;
+    }
+    if (!(QWEN_ORIGINAL_KEY in settings)) {
+        // No snapshot means we cannot prove this block is ours. Leaving a stale
+        // proxy URL behind is recoverable; destroying a real credential is not.
+        logger.debug("[proxy] Qwen clear: no original-auth snapshot found, leaving security.auth intact");
+        return false;
+    }
+    const snapshot = settings[QWEN_ORIGINAL_KEY];
+    if (snapshot === null) {
+        delete security.auth;
+    }
+    else {
+        security.auth = snapshot;
+    }
+    delete settings[QWEN_ORIGINAL_KEY];
+    settings.security = security;
+    fs.writeFileSync(getQwenSettingsPath(), JSON.stringify(settings, null, 2));
+    return true;
+}
+export const qwenCodeConfigurator = {
+    id: "qwen-code",
+    displayName: "Qwen Code",
+    detect: async () => {
+        const fs = await import("fs");
+        try {
+            fs.accessSync(getQwenConfigDir());
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    // Qwen speaks OpenAI Chat Completions, so it points at the /v1 door rather
+    // than the proxy root.
+    apply: (proxyBaseUrl) => setQwenProxySettings(`${proxyBaseUrl}/v1`),
+    restore: (proxyBaseUrl) => clearQwenProxySettings(`${proxyBaseUrl}/v1`),
+};
+export const __qwenCodeTestHooks = {
+    getQwenConfigDir,
+    getQwenSettingsPath,
+    setQwenProxySettings,
+    clearQwenProxySettings,
+};
+//# sourceMappingURL=qwenCode.js.map

package/dist/cli/proxy-clients/registry.d.ts

@@ -0,0 +1,19 @@
+import type { CliProxyClientApplyResult, CliProxyClientConfigurator, CliProxyClientRestoreResult } from "../../lib/types/index.js";
+/**
+ * Every CLI the proxy auto-configures, in apply order.
+ *
+ * Order is behaviour: it is the order messages appear during `proxy start`.
+ * Restore runs in the same order.
+ */
+export declare const PROXY_CLIENT_CONFIGURATORS: readonly CliProxyClientConfigurator[];
+/**
+ * Point every detected client at the proxy.
+ *
+ * One client failing must never stop the others, so each is wrapped
+ * independently and its error is returned rather than thrown. Callers decide
+ * how loudly to report — the daemon-start path logs failures at debug level
+ * while the setup wizard prints a visible warning.
+ */
+export declare function applyAllClients(proxyBaseUrl: string): Promise<CliProxyClientApplyResult[]>;
+/** Restore every client's previous configuration. See applyAllClients. */
+export declare function restoreAllClients(proxyBaseUrl: string): Promise<CliProxyClientRestoreResult[]>;

package/dist/cli/proxy-clients/registry.js

@@ -0,0 +1,69 @@
+import { claudeCodeConfigurator } from "./claudeCode.js";
+import { openCodeConfigurator } from "./openCode.js";
+import { codexConfigurator } from "./codex.js";
+import { qwenCodeConfigurator } from "./qwenCode.js";
+import { copilotConfigurator } from "./copilot.js";
+/**
+ * Every CLI the proxy auto-configures, in apply order.
+ *
+ * Order is behaviour: it is the order messages appear during `proxy start`.
+ * Restore runs in the same order.
+ */
+export const PROXY_CLIENT_CONFIGURATORS = [
+    claudeCodeConfigurator,
+    openCodeConfigurator,
+    codexConfigurator,
+    qwenCodeConfigurator,
+    copilotConfigurator,
+];
+/**
+ * Point every detected client at the proxy.
+ *
+ * One client failing must never stop the others, so each is wrapped
+ * independently and its error is returned rather than thrown. Callers decide
+ * how loudly to report — the daemon-start path logs failures at debug level
+ * while the setup wizard prints a visible warning.
+ */
+export async function applyAllClients(proxyBaseUrl) {
+    const results = [];
+    for (const client of PROXY_CLIENT_CONFIGURATORS) {
+        try {
+            const applied = (await client.detect())
+                ? await client.apply(proxyBaseUrl)
+                : false;
+            results.push({ id: client.id, displayName: client.displayName, applied });
+        }
+        catch (error) {
+            results.push({
+                id: client.id,
+                displayName: client.displayName,
+                applied: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    return results;
+}
+/** Restore every client's previous configuration. See applyAllClients. */
+export async function restoreAllClients(proxyBaseUrl) {
+    const results = [];
+    for (const client of PROXY_CLIENT_CONFIGURATORS) {
+        try {
+            results.push({
+                id: client.id,
+                displayName: client.displayName,
+                restored: await client.restore(proxyBaseUrl),
+            });
+        }
+        catch (error) {
+            results.push({
+                id: client.id,
+                displayName: client.displayName,
+                restored: false,
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+    return results;
+}
+//# sourceMappingURL=registry.js.map

package/dist/lib/types/index.d.ts

@@ -46,6 +46,7 @@ export * from "./ppt.js";
 export * from "./processor.js";
 export * from "./providers.js";
 export * from "./proxy.js";
+export * from "./proxyClient.js";
 export * from "./rag.js";
 export * from "./scorer.js";
 export * from "./sdk.js";

package/dist/lib/types/index.js

@@ -47,6 +47,7 @@ export * from "./ppt.js";
 export * from "./processor.js";
 export * from "./providers.js";
 export * from "./proxy.js";
+export * from "./proxyClient.js";
 export * from "./rag.js";
 export * from "./scorer.js";
 export * from "./sdk.js";

package/dist/lib/types/loopEngine.d.ts

@@ -95,9 +95,6 @@ export type AgenticLoopToolFailureBreaker = {
 export type AgenticLoopAdapter<TConversation = unknown, TRaw = unknown> = {
     readonly providerLabel: string;
     readonly maxSteps: number;
-    /** Pre-existing per-family flat timeout, used as createTurnClock's deadline default. */
-    readonly defaultTurnTimeoutMs?: number;
-    readonly stallTimeoutMs?: number;
     /** Set only for adapter instances whose client has the TOOL_NOT_FOUND strike breaker today: both Gemini adapters (AI Studio, Vertex+Gemini) AND the Vertex+Claude call to createAnthropicLoopAdapter — NOT the native-Anthropic call to that same factory, and not Bedrock. See Verified Fact 4. */
     readonly toolFailureBreaker?: AgenticLoopToolFailureBreaker;
     /**

package/dist/lib/types/proxyClient.d.ts

@@ -0,0 +1,54 @@
+/**
+ * One AI coding CLI the proxy can point at itself.
+ *
+ * Adding a CLI means adding one implementation of this type and one line in
+ * `src/cli/proxy-clients/registry.ts`. Nothing else in the proxy should need
+ * to know the client exists.
+ */
+export type CliProxyClientConfigurator = {
+    /** Stable kebab-case identifier, e.g. "claude-code". */
+    id: string;
+    /** Human-readable name used in CLI output, e.g. "Claude Code". */
+    displayName: string;
+    /**
+     * Whether this CLI appears to be installed. Configurators must not create
+     * config files for a CLI the user never installed.
+     */
+    detect: () => Promise<boolean>;
+    /**
+     * Point the CLI at the proxy. `proxyBaseUrl` is the bare proxy origin
+     * (e.g. "http://127.0.0.1:55669"); the configurator appends whatever path
+     * suffix its CLI needs. Returns false when nothing was written, so callers
+     * never print a success message for work that did not happen.
+     */
+    apply: (proxyBaseUrl: string) => Promise<boolean>;
+    /**
+     * Restore the user's previous configuration. `proxyBaseUrl` is the same bare
+     * origin; a configurator that finds a different URL configured must leave it
+     * alone and return false.
+     */
+    restore: (proxyBaseUrl: string) => Promise<boolean>;
+};
+/** Outcome of applying one configurator, for per-client CLI reporting. */
+export type CliProxyClientApplyResult = {
+    id: string;
+    displayName: string;
+    /** True only when the configurator actually wrote configuration. */
+    applied: boolean;
+    /** Present when the configurator threw; the caller decides how loud to be. */
+    error?: Error;
+};
+/** Outcome of restoring one configurator. */
+export type CliProxyClientRestoreResult = {
+    id: string;
+    displayName: string;
+    /** True only when a previous configuration was actually restored. */
+    restored: boolean;
+    error?: Error;
+};
+/**
+ * Raw contents of a Qwen Code `settings.json`. Deliberately open-ended: the
+ * configurator rewrites only `security.auth` and must round-trip every other
+ * key the user has set, including ones this repo does not know about.
+ */
+export type CliQwenSettings = Record<string, unknown>;

package/dist/lib/types/proxyClient.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=proxyClient.js.map

package/dist/types/index.d.ts

@@ -46,6 +46,7 @@ export * from "./ppt.js";
 export * from "./processor.js";
 export * from "./providers.js";
 export * from "./proxy.js";
+export * from "./proxyClient.js";
 export * from "./rag.js";
 export * from "./scorer.js";
 export * from "./sdk.js";

package/dist/types/index.js

@@ -47,6 +47,7 @@ export * from "./ppt.js";
 export * from "./processor.js";
 export * from "./providers.js";
 export * from "./proxy.js";
+export * from "./proxyClient.js";
 export * from "./rag.js";
 export * from "./scorer.js";
 export * from "./sdk.js";

package/dist/types/loopEngine.d.ts

@@ -95,9 +95,6 @@ export type AgenticLoopToolFailureBreaker = {
 export type AgenticLoopAdapter<TConversation = unknown, TRaw = unknown> = {
     readonly providerLabel: string;
     readonly maxSteps: number;
-    /** Pre-existing per-family flat timeout, used as createTurnClock's deadline default. */
-    readonly defaultTurnTimeoutMs?: number;
-    readonly stallTimeoutMs?: number;
     /** Set only for adapter instances whose client has the TOOL_NOT_FOUND strike breaker today: both Gemini adapters (AI Studio, Vertex+Gemini) AND the Vertex+Claude call to createAnthropicLoopAdapter — NOT the native-Anthropic call to that same factory, and not Bedrock. See Verified Fact 4. */
     readonly toolFailureBreaker?: AgenticLoopToolFailureBreaker;
     /**

package/dist/types/proxyClient.d.ts

@@ -0,0 +1,54 @@
+/**
+ * One AI coding CLI the proxy can point at itself.
+ *
+ * Adding a CLI means adding one implementation of this type and one line in
+ * `src/cli/proxy-clients/registry.ts`. Nothing else in the proxy should need
+ * to know the client exists.
+ */
+export type CliProxyClientConfigurator = {
+    /** Stable kebab-case identifier, e.g. "claude-code". */
+    id: string;
+    /** Human-readable name used in CLI output, e.g. "Claude Code". */
+    displayName: string;
+    /**
+     * Whether this CLI appears to be installed. Configurators must not create
+     * config files for a CLI the user never installed.
+     */
+    detect: () => Promise<boolean>;
+    /**
+     * Point the CLI at the proxy. `proxyBaseUrl` is the bare proxy origin
+     * (e.g. "http://127.0.0.1:55669"); the configurator appends whatever path
+     * suffix its CLI needs. Returns false when nothing was written, so callers
+     * never print a success message for work that did not happen.
+     */
+    apply: (proxyBaseUrl: string) => Promise<boolean>;
+    /**
+     * Restore the user's previous configuration. `proxyBaseUrl` is the same bare
+     * origin; a configurator that finds a different URL configured must leave it
+     * alone and return false.
+     */
+    restore: (proxyBaseUrl: string) => Promise<boolean>;
+};
+/** Outcome of applying one configurator, for per-client CLI reporting. */
+export type CliProxyClientApplyResult = {
+    id: string;
+    displayName: string;
+    /** True only when the configurator actually wrote configuration. */
+    applied: boolean;
+    /** Present when the configurator threw; the caller decides how loud to be. */
+    error?: Error;
+};
+/** Outcome of restoring one configurator. */
+export type CliProxyClientRestoreResult = {
+    id: string;
+    displayName: string;
+    /** True only when a previous configuration was actually restored. */
+    restored: boolean;
+    error?: Error;
+};
+/**
+ * Raw contents of a Qwen Code `settings.json`. Deliberately open-ended: the
+ * configurator rewrites only `security.auth` and must round-trip every other
+ * key the user has set, including ones this repo does not know about.
+ */
+export type CliQwenSettings = Record<string, unknown>;

package/dist/types/proxyClient.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.11.5",
+  "version": "11.11.7",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {