@juspay/neurolink 9.30.0 → 9.31.1

package/dist/client/aiSdkAdapter.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Vercel AI SDK Compatibility Layer
+ *
+ * Provides compatibility with the Vercel AI SDK by implementing the
+ * LanguageModelV1 interface. This allows NeuroLink to be used as a
+ * drop-in replacement for other AI providers in AI SDK applications.
+ *
+ * @module @neurolink/ai-sdk
+ */
+import type { LanguageModel, LanguageModelCallOptions, LanguageModelResponse, LanguageModelStreamResponse, NeuroLinkProviderOptions, ModelOptions } from "../types/clientTypes.js";
+import { NeuroLinkClient } from "./httpClient.js";
+/**
+ * NeuroLink Language Model implementation compatible with Vercel AI SDK
+ *
+ * Implements the LanguageModelV1 interface for drop-in compatibility.
+ *
+ * @example Using with AI SDK
+ * ```typescript
+ * import { generateText } from 'ai';
+ * import { createNeuroLinkModel } from '@neurolink/ai-sdk';
+ *
+ * const model = createNeuroLinkModel({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * const result = await generateText({
+ *   model: model('gpt-4o'),
+ *   prompt: 'Hello, world!',
+ * });
+ * ```
+ */
+export declare class NeuroLinkLanguageModel implements LanguageModel {
+    readonly modelId: string;
+    readonly provider: string;
+    private client;
+    private options;
+    constructor(client: NeuroLinkClient, modelId: string, provider: string, options?: ModelOptions);
+    /**
+     * Generate a non-streaming response
+     */
+    doGenerate(options: LanguageModelCallOptions): Promise<LanguageModelResponse>;
+    /**
+     * 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>;
+    /**
+     * Map NeuroLink finish reasons to AI SDK finish reasons
+     */
+    private mapFinishReason;
+}
+/**
+ * NeuroLink Provider for Vercel AI SDK
+ *
+ * Creates model instances that are compatible with the Vercel AI SDK.
+ *
+ * @example
+ * ```typescript
+ * import { neurolink } from '@neurolink/ai-sdk';
+ *
+ * const provider = neurolink({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * // Create a model
+ * const model = provider('gpt-4o');
+ *
+ * // Use with AI SDK
+ * const result = await generateText({
+ *   model,
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+export declare class NeuroLinkProvider {
+    private client;
+    private defaultProvider;
+    private defaultModel;
+    constructor(options: NeuroLinkProviderOptions);
+    /**
+     * Create a language model instance
+     *
+     * @param modelId - Model ID (e.g., 'gpt-4o', 'claude-3-opus')
+     * @param options - Additional model options
+     */
+    model(modelId?: string, options?: ModelOptions): NeuroLinkLanguageModel;
+    /**
+     * Alias for model() - makes the provider callable
+     */
+    call(modelId?: string, options?: ModelOptions): NeuroLinkLanguageModel;
+    /**
+     * Infer provider from model ID
+     */
+    private inferProvider;
+    /**
+     * Get the underlying client
+     */
+    getClient(): NeuroLinkClient;
+}
+/**
+ * Create a NeuroLink provider for Vercel AI SDK
+ *
+ * @example
+ * ```typescript
+ * import { createNeuroLinkProvider, generateText } from '@neurolink/ai-sdk';
+ *
+ * const neurolink = createNeuroLinkProvider({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: process.env.NEUROLINK_API_KEY,
+ * });
+ *
+ * const result = await generateText({
+ *   model: neurolink('gpt-4o'),
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+export declare function createNeuroLinkProvider(options: NeuroLinkProviderOptions): NeuroLinkProvider & ((modelId?: string, modelOptions?: ModelOptions) => NeuroLinkLanguageModel);
+/**
+ * Create a standalone NeuroLink model for Vercel AI SDK
+ *
+ * @example
+ * ```typescript
+ * import { createNeuroLinkModel, generateText } from '@neurolink/ai-sdk';
+ *
+ * const model = createNeuroLinkModel({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: process.env.NEUROLINK_API_KEY,
+ *   modelId: 'gpt-4o',
+ *   provider: 'openai',
+ * });
+ *
+ * const result = await generateText({
+ *   model,
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+export declare function createNeuroLinkModel(options: NeuroLinkProviderOptions & {
+    modelId: string;
+    provider?: string;
+}): NeuroLinkLanguageModel;
+/**
+ * Default export for easy provider creation
+ *
+ * @example
+ * ```typescript
+ * import { neurolink } from '@neurolink/ai-sdk';
+ *
+ * const provider = neurolink({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: 'your-key',
+ * });
+ *
+ * const model = provider('gpt-4o');
+ * ```
+ */
+export declare const neurolink: typeof createNeuroLinkProvider;
+/**
+ * Create an AI SDK compatible streaming response from NeuroLink stream
+ *
+ * @example
+ * ```typescript
+ * // In a Next.js API route or server action
+ * import { createStreamingResponse } from '@neurolink/ai-sdk';
+ *
+ * export async function POST(req: Request) {
+ *   const { prompt } = await req.json();
+ *
+ *   const stream = await createStreamingResponse({
+ *     baseUrl: process.env.NEUROLINK_URL,
+ *     apiKey: process.env.NEUROLINK_API_KEY,
+ *     input: { text: prompt },
+ *     provider: 'openai',
+ *     model: 'gpt-4o',
+ *   });
+ *
+ *   return stream;
+ * }
+ * ```
+ */
+export declare function createStreamingResponse(options: NeuroLinkProviderOptions & {
+    input: {
+        text: string;
+    };
+    model: string;
+    provider?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+}): Promise<Response>;
+export type { LanguageModel, LanguageModelCallOptions, LanguageModelResponse, LanguageModelStreamResponse, NeuroLinkProviderOptions, ModelOptions, } from "../types/clientTypes.js";

package/dist/client/aiSdkAdapter.js

@@ -0,0 +1,487 @@
+/**
+ * Vercel AI SDK Compatibility Layer
+ *
+ * Provides compatibility with the Vercel AI SDK by implementing the
+ * LanguageModelV1 interface. This allows NeuroLink to be used as a
+ * drop-in replacement for other AI providers in AI SDK applications.
+ *
+ * @module @neurolink/ai-sdk
+ */
+import { logger } from "../utils/logger.js";
+import { createClient, NeuroLinkClient } from "./httpClient.js";
+// =============================================================================
+// LanguageModel Implementation
+// =============================================================================
+/**
+ * NeuroLink Language Model implementation compatible with Vercel AI SDK
+ *
+ * Implements the LanguageModelV1 interface for drop-in compatibility.
+ *
+ * @example Using with AI SDK
+ * ```typescript
+ * import { generateText } from 'ai';
+ * import { createNeuroLinkModel } from '@neurolink/ai-sdk';
+ *
+ * const model = createNeuroLinkModel({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * const result = await generateText({
+ *   model: model('gpt-4o'),
+ *   prompt: 'Hello, world!',
+ * });
+ * ```
+ */
+export class NeuroLinkLanguageModel {
+    modelId;
+    provider;
+    client;
+    options;
+    constructor(client, modelId, provider, options = {}) {
+        this.client = client;
+        this.modelId = modelId;
+        this.provider = provider;
+        this.options = options;
+    }
+    /**
+     * Generate a non-streaming response
+     */
+    async doGenerate(options) {
+        const { prompt, system, messages, temperature, maxTokens, abortSignal } = options;
+        // Build the input text from prompt or messages
+        let inputText = prompt ?? "";
+        if (messages && messages.length > 0) {
+            inputText = messages
+                .filter((m) => m.role !== "system")
+                .map((m) => m.content)
+                .join("\n");
+        }
+        // Extract system message if present
+        const systemPrompt = system ?? messages?.find((m) => m.role === "system")?.content;
+        try {
+            const response = await this.client.generate({
+                input: { text: inputText },
+                provider: this.provider,
+                model: this.modelId,
+                temperature: temperature ?? this.options.temperature,
+                maxTokens: maxTokens ?? this.options.maxTokens,
+                systemPrompt,
+            }, {
+                signal: abortSignal,
+            });
+            return {
+                text: response.data.content,
+                finishReason: this.mapFinishReason(response.data.finishReason),
+                usage: {
+                    promptTokens: response.data.usage?.promptTokens ?? 0,
+                    completionTokens: response.data.usage?.completionTokens ?? 0,
+                },
+                rawResponse: response,
+            };
+        }
+        catch (error) {
+            return {
+                text: "",
+                finishReason: "error",
+                usage: { promptTokens: 0, completionTokens: 0 },
+                rawResponse: error,
+            };
+        }
+    }
+    /**
+     * 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.
+     */
+    async doStream(options) {
+        const { prompt, system, messages, temperature, maxTokens, abortSignal } = options;
+        // Build the input text from prompt or messages
+        let inputText = prompt ?? "";
+        if (messages && messages.length > 0) {
+            inputText = messages
+                .filter((m) => m.role !== "system")
+                .map((m) => m.content)
+                .join("\n");
+        }
+        // Extract system message if present
+        const systemPrompt = system ?? messages?.find((m) => m.role === "system")?.content;
+        const buffer = [];
+        let finished = false;
+        let notifyConsumer = null;
+        /** Resolves the consumer's pending pull, if any. */
+        function wake() {
+            if (notifyConsumer) {
+                const fn = notifyConsumer;
+                notifyConsumer = null;
+                fn();
+            }
+        }
+        /** Push a chunk into the queue and wake the consumer. */
+        function push(chunk) {
+            buffer.push(chunk);
+            wake();
+        }
+        /** Signal that no more chunks will arrive. */
+        function close() {
+            finished = true;
+            wake();
+        }
+        // Kick off the underlying stream in the background.
+        // Errors are forwarded to the consumer via the queue.
+        const self = this;
+        const streamPromise = self.client
+            .stream({
+            input: { text: inputText },
+            provider: self.provider,
+            model: self.modelId,
+            temperature: temperature ?? self.options.temperature,
+            maxTokens: maxTokens ?? self.options.maxTokens,
+            systemPrompt,
+        }, {
+            onText: (text) => {
+                push({ type: "text-delta", textDelta: text });
+            },
+            onDone: (result) => {
+                push({
+                    type: "finish",
+                    finishReason: self.mapFinishReason(result.finishReason),
+                    usage: result.usage
+                        ? {
+                            promptTokens: result.usage.promptTokens,
+                            completionTokens: result.usage.completionTokens,
+                        }
+                        : undefined,
+                });
+                close();
+            },
+        }, {
+            signal: abortSignal,
+        })
+            .catch(() => {
+            // If the stream rejects before onDone fires, emit a finish/error.
+            if (!finished) {
+                push({ type: "finish", finishReason: "error" });
+                close();
+            }
+        });
+        // Suppress unhandled-rejection warnings; the consumer drains the queue.
+        // Errors are pushed into the queue as finish events with error details.
+        streamPromise.catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            push({
+                type: "finish",
+                finishReason: "error",
+                usage: { promptTokens: 0, completionTokens: 0 },
+            });
+            close();
+            logger.debug("[aiSdkAdapter] Stream promise rejected", {
+                error: message,
+            });
+        });
+        // ---- Async iterable that pulls from the queue ----
+        async function* createStream() {
+            while (true) {
+                // Drain anything already buffered.
+                while (buffer.length > 0) {
+                    const chunk = buffer.shift();
+                    yield chunk;
+                    if (chunk.type === "finish") {
+                        return;
+                    }
+                }
+                // Nothing buffered — if the producer is done, exit.
+                if (finished) {
+                    return;
+                }
+                // Wait for the producer to push more data.
+                await new Promise((resolve) => {
+                    notifyConsumer = resolve;
+                });
+            }
+        }
+        return {
+            stream: createStream(),
+        };
+    }
+    /**
+     * Map NeuroLink finish reasons to AI SDK finish reasons
+     */
+    mapFinishReason(reason) {
+        if (!reason) {
+            return "stop";
+        }
+        const mapping = {
+            stop: "stop",
+            length: "length",
+            "tool-calls": "tool-calls",
+            tool_calls: "tool-calls",
+            "content-filter": "content-filter",
+            content_filter: "content-filter",
+            error: "error",
+        };
+        return mapping[reason] ?? "other";
+    }
+}
+// =============================================================================
+// Provider Factory
+// =============================================================================
+/**
+ * NeuroLink Provider for Vercel AI SDK
+ *
+ * Creates model instances that are compatible with the Vercel AI SDK.
+ *
+ * @example
+ * ```typescript
+ * import { neurolink } from '@neurolink/ai-sdk';
+ *
+ * const provider = neurolink({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: 'your-api-key',
+ * });
+ *
+ * // Create a model
+ * const model = provider('gpt-4o');
+ *
+ * // Use with AI SDK
+ * const result = await generateText({
+ *   model,
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+export class NeuroLinkProvider {
+    client;
+    defaultProvider;
+    defaultModel;
+    constructor(options) {
+        this.client = createClient({
+            baseUrl: options.baseUrl,
+            apiKey: options.apiKey,
+            token: options.token,
+            headers: options.headers,
+        });
+        this.defaultProvider = options.defaultProvider ?? "openai";
+        this.defaultModel = options.defaultModel ?? "gpt-4o";
+    }
+    /**
+     * Create a language model instance
+     *
+     * @param modelId - Model ID (e.g., 'gpt-4o', 'claude-3-opus')
+     * @param options - Additional model options
+     */
+    model(modelId, options) {
+        const model = modelId ?? this.defaultModel;
+        const provider = options?.provider ?? this.inferProvider(model);
+        return new NeuroLinkLanguageModel(this.client, model, provider, options);
+    }
+    /**
+     * Alias for model() - makes the provider callable
+     */
+    call(modelId, options) {
+        return this.model(modelId, options);
+    }
+    /**
+     * Infer provider from model ID
+     */
+    inferProvider(modelId) {
+        const providerPatterns = {
+            openai: [/^gpt-/, /^o1-/, /^o3-/, /^davinci/, /^curie/],
+            anthropic: [/^claude-/],
+            "google-ai": [/^gemini-/, /^palm-/],
+            vertex: [/^gemini-/, /^palm-/, /^codechat-/],
+            mistral: [/^mistral-/, /^codestral-/],
+            bedrock: [/^anthropic\./, /^amazon\./],
+            azure: [/^azure-/],
+        };
+        for (const [provider, patterns] of Object.entries(providerPatterns)) {
+            for (const pattern of patterns) {
+                if (pattern.test(modelId)) {
+                    return provider;
+                }
+            }
+        }
+        return this.defaultProvider;
+    }
+    /**
+     * Get the underlying client
+     */
+    getClient() {
+        return this.client;
+    }
+}
+// =============================================================================
+// Factory Functions
+// =============================================================================
+/**
+ * Create a NeuroLink provider for Vercel AI SDK
+ *
+ * @example
+ * ```typescript
+ * import { createNeuroLinkProvider, generateText } from '@neurolink/ai-sdk';
+ *
+ * const neurolink = createNeuroLinkProvider({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: process.env.NEUROLINK_API_KEY,
+ * });
+ *
+ * const result = await generateText({
+ *   model: neurolink('gpt-4o'),
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+export function createNeuroLinkProvider(options) {
+    const provider = new NeuroLinkProvider(options);
+    // Make the provider callable
+    const callable = (modelId, modelOptions) => provider.model(modelId, modelOptions);
+    // Copy all methods from provider to callable
+    Object.setPrototypeOf(callable, provider);
+    Object.assign(callable, {
+        model: provider.model.bind(provider),
+        call: provider.call.bind(provider),
+        getClient: provider.getClient.bind(provider),
+    });
+    return callable;
+}
+/**
+ * Create a standalone NeuroLink model for Vercel AI SDK
+ *
+ * @example
+ * ```typescript
+ * import { createNeuroLinkModel, generateText } from '@neurolink/ai-sdk';
+ *
+ * const model = createNeuroLinkModel({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: process.env.NEUROLINK_API_KEY,
+ *   modelId: 'gpt-4o',
+ *   provider: 'openai',
+ * });
+ *
+ * const result = await generateText({
+ *   model,
+ *   prompt: 'Hello!',
+ * });
+ * ```
+ */
+export function createNeuroLinkModel(options) {
+    const provider = createNeuroLinkProvider(options);
+    return provider(options.modelId, { provider: options.provider });
+}
+// =============================================================================
+// Convenience Exports
+// =============================================================================
+/**
+ * Default export for easy provider creation
+ *
+ * @example
+ * ```typescript
+ * import { neurolink } from '@neurolink/ai-sdk';
+ *
+ * const provider = neurolink({
+ *   baseUrl: 'https://api.neurolink.example.com',
+ *   apiKey: 'your-key',
+ * });
+ *
+ * const model = provider('gpt-4o');
+ * ```
+ */
+export const neurolink = createNeuroLinkProvider;
+// =============================================================================
+// Streaming Utilities
+// =============================================================================
+/**
+ * Create an AI SDK compatible streaming response from NeuroLink stream
+ *
+ * @example
+ * ```typescript
+ * // In a Next.js API route or server action
+ * import { createStreamingResponse } from '@neurolink/ai-sdk';
+ *
+ * export async function POST(req: Request) {
+ *   const { prompt } = await req.json();
+ *
+ *   const stream = await createStreamingResponse({
+ *     baseUrl: process.env.NEUROLINK_URL,
+ *     apiKey: process.env.NEUROLINK_API_KEY,
+ *     input: { text: prompt },
+ *     provider: 'openai',
+ *     model: 'gpt-4o',
+ *   });
+ *
+ *   return stream;
+ * }
+ * ```
+ */
+export async function createStreamingResponse(options) {
+    const client = createClient({
+        baseUrl: options.baseUrl,
+        apiKey: options.apiKey,
+        token: options.token,
+        headers: options.headers,
+    });
+    // Create a ReadableStream for the response
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                await client.stream({
+                    input: options.input,
+                    provider: options.provider ?? "openai",
+                    model: options.model,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    systemPrompt: options.systemPrompt,
+                }, {
+                    onText: (text) => {
+                        // AI SDK format: stream text deltas
+                        const data = JSON.stringify({
+                            type: "text-delta",
+                            textDelta: text,
+                        });
+                        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                    },
+                    onToolCall: (toolCall) => {
+                        const data = JSON.stringify({ type: "tool-call", toolCall });
+                        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                    },
+                    onToolResult: (toolResult) => {
+                        const data = JSON.stringify({ type: "tool-result", toolResult });
+                        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                    },
+                    onDone: (result) => {
+                        const data = JSON.stringify({
+                            type: "finish",
+                            finishReason: result.finishReason ?? "stop",
+                            usage: result.usage,
+                        });
+                        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+                        controller.close();
+                    },
+                    onError: (error) => {
+                        const data = JSON.stringify({ type: "error", error });
+                        controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                        controller.close();
+                    },
+                });
+            }
+            catch (error) {
+                const data = JSON.stringify({
+                    type: "error",
+                    error: { message: error.message },
+                });
+                controller.enqueue(encoder.encode(`data: ${data}\n\n`));
+                controller.close();
+            }
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+        },
+    });
+}