@juspay/neurolink 9.30.0 → 9.31.0

package/dist/lib/providers/sagemaker/language-model.js

@@ -1,7 +1,7 @@
 /**
  * SageMaker Language Model Implementation
  *
- * This module implements the LanguageModelV1 interface for Amazon SageMaker
+ * This module implements the LanguageModel interface for Amazon SageMaker
  * integration with the Vercel AI SDK.
  */
 import { randomUUID } from "crypto";
@@ -74,7 +74,7 @@ const DEFAULT_INITIAL_CONCURRENCY = 5;
 const DEFAULT_MAX_CONCURRENCY = 10;
 const DEFAULT_MIN_CONCURRENCY = 1;
 /**
- * SageMaker Language Model implementing LanguageModelV1 interface
+ * SageMaker Language Model implementing LanguageModel interface
  *
  * Token Limit Behavior:
  * - When maxTokens is undefined, SageMaker uses the model's default token limits
@@ -82,11 +82,22 @@ const DEFAULT_MIN_CONCURRENCY = 1;
  * - This aligns with the unlimited-by-default token policy across all providers
  */
 export class SageMakerLanguageModel {
-    specificationVersion = "v1";
+    /**
+     * Specification version for the AI SDK LanguageModel interface.
+     * Uses "v2" for structural compatibility with AI SDK v6's `LanguageModelV2`.
+     * The AI SDK checks this field to determine which interface version to use.
+     */
+    specificationVersion = "v2";
     provider = "sagemaker";
     modelId;
     supportsStreaming = true;
     defaultObjectGenerationMode = "json";
+    /**
+     * Supported URL patterns by media type.
+     * SageMaker endpoints do not natively download URLs, so this is empty.
+     * Required by the LanguageModelV2 interface.
+     */
+    supportedUrls = {};
     client;
     config;
     modelConfig;
@@ -150,8 +161,8 @@ export class SageMakerLanguageModel {
             const result = {
                 text: generatedText,
                 usage: {
-                    promptTokens: usage.promptTokens,
-                    completionTokens: usage.completionTokens,
+                    inputTokens: usage.promptTokens,
+                    outputTokens: usage.completionTokens,
                     totalTokens: usage.total,
                 },
                 finishReason,
@@ -678,10 +689,11 @@ export class SageMakerLanguageModel {
                 results[index] = {
                     text: result.text || "",
                     usage: {
-                        promptTokens: result.usage.promptTokens,
-                        completionTokens: result.usage.completionTokens,
+                        promptTokens: result.usage.inputTokens ?? 0,
+                        completionTokens: result.usage.outputTokens ?? 0,
                         total: result.usage.totalTokens ??
-                            result.usage.promptTokens + result.usage.completionTokens,
+                            (result.usage.inputTokens ?? 0) +
+                                (result.usage.outputTokens ?? 0),
                     },
                     finishReason: result.finishReason,
                     index,

package/dist/lib/proxy/accountQuota.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Per-Account Quota Tracking
+ *
+ * Captures Anthropic rate-limit / utilisation headers from proxy responses
+ * and persists them to ~/.neurolink/account-quotas.json so the CLI can
+ * display remaining session & weekly capacity per account.
+ *
+ * Hot-path design: parseQuotaHeaders is pure CPU (no I/O). saveAccountQuota
+ * updates an in-memory cache and debounces disk writes so the request/response
+ * path is never blocked by file I/O.
+ */
+import type { AccountQuota } from "../types/index.js";
+/**
+ * Parse Anthropic rate-limit / quota headers into an `AccountQuota`.
+ * Returns `null` when key headers are absent.
+ * Pure computation — no I/O, no blocking.
+ */
+export declare function parseQuotaHeaders(headers: Headers | Record<string, string>): AccountQuota | null;
+/**
+ * Load all persisted account quotas.
+ * First call reads from disk; subsequent calls return the in-memory cache.
+ */
+export declare function loadAccountQuotas(): Promise<Record<string, AccountQuota>>;
+/**
+ * Load quota for a single account.
+ */
+export declare function loadAccountQuota(accountKey: string): Promise<AccountQuota | null>;
+/**
+ * Update quota for a single account.
+ * Updates in-memory cache immediately (non-blocking),
+ * then debounces the disk write to every 5 seconds.
+ */
+export declare function saveAccountQuota(accountKey: string, quota: AccountQuota): Promise<void>;

package/dist/lib/proxy/accountQuota.js

@@ -0,0 +1,163 @@
+/**
+ * Per-Account Quota Tracking
+ *
+ * Captures Anthropic rate-limit / utilisation headers from proxy responses
+ * and persists them to ~/.neurolink/account-quotas.json so the CLI can
+ * display remaining session & weekly capacity per account.
+ *
+ * Hot-path design: parseQuotaHeaders is pure CPU (no I/O). saveAccountQuota
+ * updates an in-memory cache and debounces disk writes so the request/response
+ * path is never blocked by file I/O.
+ */
+import { join } from "path";
+import { homedir } from "os";
+import { promises as fs } from "fs";
+// ---------------------------------------------------------------------------
+// Header parsing (pure CPU — no I/O, safe for hot path)
+// ---------------------------------------------------------------------------
+function getHeader(headers, name) {
+    if (typeof headers.get === "function") {
+        return headers.get(name) ?? undefined;
+    }
+    const rec = headers;
+    if (rec[name] !== undefined) {
+        return rec[name];
+    }
+    const lower = name.toLowerCase();
+    for (const key of Object.keys(rec)) {
+        if (key.toLowerCase() === lower) {
+            return rec[key];
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse Anthropic rate-limit / quota headers into an `AccountQuota`.
+ * Returns `null` when key headers are absent.
+ * Pure computation — no I/O, no blocking.
+ */
+export function parseQuotaHeaders(headers) {
+    // Anthropic prefixes all quota headers with "anthropic-ratelimit-"
+    const P = "anthropic-ratelimit-";
+    const sessionUtilRaw = getHeader(headers, `${P}unified-5h-utilization`);
+    const weeklyUtilRaw = getHeader(headers, `${P}unified-7d-utilization`);
+    if (sessionUtilRaw === undefined || weeklyUtilRaw === undefined) {
+        return null;
+    }
+    const sessionUsed = parseFloat(sessionUtilRaw);
+    const weeklyUsed = parseFloat(weeklyUtilRaw);
+    if (Number.isNaN(sessionUsed) || Number.isNaN(weeklyUsed)) {
+        return null;
+    }
+    const sessionResetRaw = getHeader(headers, `${P}unified-5h-reset`);
+    const weeklyResetRaw = getHeader(headers, `${P}unified-7d-reset`);
+    const fallbackRaw = getHeader(headers, `${P}unified-fallback-percentage`);
+    return {
+        sessionUsed,
+        sessionStatus: getHeader(headers, `${P}unified-5h-status`) ?? "unknown",
+        sessionResetAt: sessionResetRaw ? parseInt(sessionResetRaw, 10) || 0 : 0,
+        weeklyUsed,
+        weeklyStatus: getHeader(headers, `${P}unified-7d-status`) ?? "unknown",
+        weeklyResetAt: weeklyResetRaw ? parseInt(weeklyResetRaw, 10) || 0 : 0,
+        fallbackPercentage: fallbackRaw ? parseFloat(fallbackRaw) || 0 : 0,
+        overageStatus: getHeader(headers, `${P}unified-overage-status`) ?? "unknown",
+        lastUpdated: Date.now(),
+    };
+}
+// ---------------------------------------------------------------------------
+// In-memory cache + debounced async persistence
+// ---------------------------------------------------------------------------
+const QUOTA_FILE = "account-quotas.json";
+const FLUSH_INTERVAL_MS = 5_000; // write to disk at most every 5 seconds
+let memoryCache = {};
+let cacheLoaded = false;
+let dirty = false;
+let flushTimer = null;
+function getQuotaFilePath() {
+    return join(homedir(), ".neurolink", QUOTA_FILE);
+}
+async function ensureDir() {
+    const dir = join(homedir(), ".neurolink");
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 }).catch(() => {
+        // Non-fatal: directory may already exist
+    });
+}
+/** Flush the in-memory cache to disk (async, non-blocking). */
+async function flushToDisk() {
+    if (!dirty) {
+        return;
+    }
+    try {
+        // Snapshot before async I/O so we only clear dirty if nothing changed
+        const snapshot = JSON.stringify(memoryCache, null, 2);
+        await ensureDir();
+        const filePath = getQuotaFilePath();
+        const tmpPath = `${filePath}.tmp`;
+        await fs.writeFile(tmpPath, snapshot, {
+            mode: 0o600,
+        });
+        await fs.rename(tmpPath, filePath);
+        // Only clear dirty if the cache hasn't changed during the write
+        if (JSON.stringify(memoryCache, null, 2) === snapshot) {
+            dirty = false;
+        }
+    }
+    catch {
+        // Non-fatal — quota is best-effort telemetry
+    }
+}
+function scheduleFlush() {
+    if (flushTimer) {
+        return;
+    } // already scheduled
+    flushTimer = setTimeout(() => {
+        flushTimer = null;
+        flushToDisk().catch(() => {
+            // Non-fatal: quota persistence is best-effort
+        });
+    }, FLUSH_INTERVAL_MS);
+    // Don't prevent process exit
+    if (flushTimer && typeof flushTimer === "object" && "unref" in flushTimer) {
+        flushTimer.unref();
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Load all persisted account quotas.
+ * First call reads from disk; subsequent calls return the in-memory cache.
+ */
+export async function loadAccountQuotas() {
+    if (cacheLoaded) {
+        return { ...memoryCache };
+    }
+    try {
+        const raw = await fs.readFile(getQuotaFilePath(), "utf-8");
+        memoryCache = JSON.parse(raw);
+    }
+    catch {
+        memoryCache = {};
+    }
+    cacheLoaded = true;
+    return { ...memoryCache };
+}
+/**
+ * Load quota for a single account.
+ */
+export async function loadAccountQuota(accountKey) {
+    const all = await loadAccountQuotas();
+    return all[accountKey] ?? null;
+}
+/**
+ * Update quota for a single account.
+ * Updates in-memory cache immediately (non-blocking),
+ * then debounces the disk write to every 5 seconds.
+ */
+export async function saveAccountQuota(accountKey, quota) {
+    memoryCache[accountKey] = quota;
+    cacheLoaded = true;
+    dirty = true;
+    scheduleFlush();
+}
+//# sourceMappingURL=accountQuota.js.map

package/dist/lib/proxy/claudeFormat.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Claude Messages API format conversion layer.
+ *
+ * Provides a request parser (Claude -> NeuroLink), a response serializer
+ * (NeuroLink -> Claude), a streaming SSE state machine, and an error
+ * envelope helper.  Together they allow NeuroLink to act as a
+ * drop-in Claude API proxy.
+ *
+ * Reference: https://docs.anthropic.com/en/api/messages
+ */
+import type { ClaudeErrorResponse, ClaudeRequest, ClaudeResponse, ContentBlockType, InternalResult, ParsedClaudeRequest, StreamLifecycleState } from "../types/index.js";
+/** Generate a unique message id in the Claude format. */
+export declare function generateMessageId(): string;
+/** Generate a Claude-format tool use ID (`toolu_` + 24 random chars). */
+export declare function generateToolUseId(): string;
+/**
+ * Reset the internal id counter (useful in tests).
+ * @internal
+ */
+export declare function _resetIdCounter(): void;
+/**
+ * Parse an incoming Claude Messages API request into an intermediate
+ * representation consumable by NeuroLink's generate/stream pipeline.
+ *
+ * Handles:
+ * - System prompt extraction (string or content-block array)
+ * - Message flattening (text + image blocks)
+ * - Tool definition conversion
+ * - tool_choice mapping
+ * - top_p pass-through
+ * - thinking configuration
+ */
+export declare function parseClaudeRequest(body: ClaudeRequest): ParsedClaudeRequest;
+/**
+ * Serialize a NeuroLink GenerateResult into a Claude Messages API response.
+ */
+export declare function serializeClaudeResponse(result: InternalResult, requestModel: string): ClaudeResponse;
+/**
+ * Build a Claude-compatible error envelope.
+ */
+export declare function buildClaudeError(status: number, message: string, errorType?: string): ClaudeErrorResponse;
+/**
+ * Format a single SSE frame (one `event:` + `data:` pair).
+ */
+export declare function formatSSE(eventType: string, data: unknown): string;
+/**
+ * Stateful SSE serializer that emits a well-formed Claude SSE stream.
+ *
+ * Tracks both lifecycle state (`idle` -> `streaming` -> `done`) and the
+ * current content block type (`text`, `thinking`, `tool_use`). Each
+ * content block gets a unique, monotonically increasing `blockIndex`.
+ *
+ * Usage:
+ * ```ts
+ * const sse = new ClaudeStreamSerializer(requestModel, inputTokens);
+ *
+ * // Thinking deltas
+ * for await (const thought of thinkingStream) {
+ *   yield* sse.pushThinkingDelta(thought);
+ * }
+ *
+ * // Text deltas
+ * for await (const chunk of textStream) {
+ *   yield* sse.pushDelta(chunk);
+ * }
+ *
+ * // Tool use
+ * yield* sse.pushToolUse(toolId, toolName, toolInput);
+ *
+ * // Finalize
+ * yield* sse.finish(outputTokens, finishReason);
+ * ```
+ */
+export declare class ClaudeStreamSerializer {
+    private state;
+    private currentBlockType;
+    private blockIndex;
+    private hasOpenedBlock;
+    private outputTokens;
+    private messageStarted;
+    private readonly messageId;
+    private readonly model;
+    private readonly inputTokens;
+    constructor(model: string, inputTokens?: number);
+    /** Current lifecycle state (exposed for testing). */
+    getState(): StreamLifecycleState;
+    /** Current content block type (exposed for testing). */
+    getCurrentBlockType(): ContentBlockType;
+    /** Current block index (exposed for testing). */
+    getBlockIndex(): number;
+    /**
+     * Emit a ping event frame.  The actual periodic timer is wired in
+     * the route handler; this method just formats the SSE frame.
+     */
+    static pingEvent(): string;
+    /**
+     * Emit `message_start` and initial ping if not already done.
+     */
+    private ensureMessageStarted;
+    /**
+     * Close the current content block if one is open.
+     */
+    private closeCurrentBlock;
+    /**
+     * Open a new content block of the given type.
+     * Increments blockIndex for each new block.
+     */
+    private openBlock;
+    /**
+     * Emit the opening frames: message_start, ping, content_block_start (text).
+     * Automatically called on the first pushDelta if not called manually.
+     */
+    start(): Generator<string>;
+    /**
+     * Push a text delta.  Returns zero or more SSE frames.
+     * If currently in a thinking block, the thinking block is closed first.
+     */
+    pushDelta(text: string): Generator<string>;
+    /**
+     * Push a thinking delta.  Returns zero or more SSE frames.
+     * If currently in a text or tool_use block, that block is closed first
+     * and a new thinking block is opened.
+     */
+    pushThinkingDelta(text: string): Generator<string>;
+    /**
+     * Push a complete tool use block.
+     *
+     * 1. Closes any open content block
+     * 2. Emits `content_block_start` with `{type: "tool_use", id, name}`
+     * 3. JSON-stringifies the input, chunks it into ~100 char segments
+     * 4. Emits `content_block_delta` with `{type: "input_json_delta", partial_json}` per chunk
+     * 5. Emits `content_block_stop`
+     */
+    pushToolUse(id: string, name: string, input: unknown): Generator<string>;
+    /**
+     * Finalize the stream: content_block_stop, message_delta, message_stop.
+     */
+    finish(outputTokens?: number, finishReason?: string): Generator<string>;
+    /**
+     * Emit an error event.  Transitions to terminal ERROR state.
+     */
+    emitError(status: number, message: string): Generator<string>;
+}