@krutai/ai-provider 0.1.0 → 0.2.2

package/dist/index.d.mts

@@ -1,54 +1,49 @@
-import * as _openrouter_sdk_lib_event_streams_js from '@openrouter/sdk/lib/event-streams.js';
-import * as _openrouter_sdk_models from '@openrouter/sdk/models';
-import { OpenRouter } from '@openrouter/sdk';
-
 /**
  * Types for @krutai/ai-provider
  */
 /**
- * Default model used when no model is specified
+ * Default model identifier sent to the LangChain server when no model is specified.
+ * Your server can use this value to route to its own default model.
  */
-declare const DEFAULT_MODEL: "qwen/qwen3-235b-a22b-thinking-2507";
+declare const DEFAULT_MODEL: "default";
 /**
  * Configuration options for KrutAIProvider
  */
 interface KrutAIProviderConfig {
     /**
-     * KrutAI API key for service validation.
+     * KrutAI API key.
+     * Validated against the LangChain server before use.
      * @required
      */
     apiKey: string;
     /**
-     * OpenRouter API key.
-     * Falls back to process.env.OPENROUTER_API_KEY if not provided.
+     * Base URL of your deployed LangChain backend server.
+     * @default "http://localhost:8000"
+     * @example "https://ai.krut.ai"
      */
-    openRouterApiKey?: string;
+    serverUrl?: string;
     /**
-     * The AI model to use.
-     * @default "qwen/qwen3-235b-a22b-thinking-2507"
-     * @see https://openrouter.ai/models
+     * The AI model to use (passed to the server).
+     * The server decides what to do with this value.
+     * @default "default"
      */
     model?: string;
     /**
-     * Whether to validate the OpenRouter API key on initialization.
+     * Whether to validate the API key against the server on initialization.
+     * Set to false to skip the validation round-trip (e.g. in tests).
      * @default true
      */
     validateOnInit?: boolean;
-    /**
-     * Custom POST endpoint for OpenRouter API key validation.
-     * Will be wired in once you deploy the route.
-     */
-    validationEndpoint?: string;
 }
 /**
- * A single chat message (OpenRouter format)
+ * A single chat message
  */
 interface ChatMessage {
     role: 'user' | 'assistant' | 'system';
     content: string;
 }
 /**
- * Options for a single generate / stream call
+ * Options for a single generate / stream / chat call
  */
 interface GenerateOptions {
     /**
@@ -70,115 +65,133 @@ interface GenerateOptions {
 }
 
 /**
- * OpenRouter API Key Validator
+ * API Key Validator for @krutai/ai-provider
  *
- * Validates the OpenRouter API key format and (optionally) its validity
- * via a configurable POST endpoint.
+ * Validates the KrutAI API key by calling the deployed LangChain server's
+ * validation endpoint. The server is expected to respond with { valid: true }
+ * for a valid key and { valid: false } (or a non-2xx status) for an invalid one.
  *
- * The user will later provide a live POST route; until then the
- * service-level check is a placeholder that accepts any well-formed key.
+ * Validation endpoint called:
+ *   POST {serverUrl}/validate
+ *   Headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey }
+ *   Body:    { "apiKey": "<key>" }
+ *   Expected Response: { "valid": true }
  */
-declare class OpenRouterKeyValidationError extends Error {
+declare class KrutAIKeyValidationError extends Error {
     constructor(message: string);
 }
 /**
- * Validates the format of an OpenRouter API key.
- * @throws {OpenRouterKeyValidationError}
+ * Basic sanity check — ensures the key is a non-empty string.
+ * @throws {KrutAIKeyValidationError}
  */
-declare function validateOpenRouterKeyFormat(apiKey: string): void;
+declare function validateApiKeyFormat(apiKey: string): void;
 /**
- * Validates the OpenRouter API key with the KrutAI validation service.
+ * Validates the API key against the deployed LangChain server.
  *
- * The user will provide a live POST route later. Until then this is a
- * placeholder that accepts any key that passes format validation.
+ * Sends a POST request to `{serverUrl}/validate` and expects:
+ *   - HTTP 2xx status
+ *   - JSON body: `{ "valid": true }`
  *
- * @param apiKey - OpenRouter API key to validate
- * @param validationEndpoint - Optional POST URL to validate against
+ * @param apiKey   - The API key to validate
+ * @param serverUrl - Base URL of the LangChain backend (e.g. "https://ai.yourapp.com")
+ * @throws {KrutAIKeyValidationError}
  */
-declare function validateOpenRouterKeyWithService(apiKey: string, validationEndpoint?: string): Promise<boolean>;
+declare function validateApiKey(apiKey: string, serverUrl: string): Promise<boolean>;
 
 /**
- * KrutAIProvider — AI provider for KrutAI
+ * KrutAIProvider — fetch-based AI provider for KrutAI
  *
- * Wraps `@openrouter/sdk` and adds:
- *  - OpenRouter API key format validation
- *  - Configurable default model (defaults to qwen/qwen3-235b-a22b-thinking-2507)
- *  - Optional pluggable validation endpoint
+ * Calls your deployed LangChain backend server for all AI operations.
+ * The API key is validated against the server before use.
  *
  * @example
  * ```typescript
  * import { KrutAIProvider } from '@krutai/ai-provider';
  *
+ * // Using local dev server (http://localhost:8000 by default)
  * const ai = new KrutAIProvider({
  *   apiKey: process.env.KRUTAI_API_KEY!,
- *   openRouterApiKey: process.env.OPENROUTER_API_KEY!, // or set in env
  * });
  *
- * await ai.initialize();
+ * // Or point to a production server
+ * const aiProd = new KrutAIProvider({
+ *   apiKey: process.env.KRUTAI_API_KEY!,
+ *   serverUrl: 'https://ai.krut.ai',
+ * });
+ *
+ * await ai.initialize(); // validates key against server
  *
  * const text = await ai.generate('Tell me a joke');
  * console.log(text);
  * ```
  */
 declare class KrutAIProvider {
-    private readonly resolvedOpenRouterKey;
+    private readonly apiKey;
+    private readonly serverUrl;
     private readonly resolvedModel;
     private readonly config;
-    private openRouterClient;
     private initialized;
     constructor(config: KrutAIProviderConfig);
     /**
      * Initialize the provider.
-     * Validates the OpenRouter API key (optionally against a service endpoint)
-     * and sets up the underlying OpenRouter client.
+     * Validates the API key against the LangChain server, then marks provider as ready.
      *
-     * @throws {OpenRouterKeyValidationError}
+     * @throws {KrutAIKeyValidationError} if the key is rejected or the server is unreachable
      */
     initialize(): Promise<void>;
-    /** @private */
-    private setupClient;
     /**
-     * Get the raw OpenRouter SDK client instance.
-     * @throws {Error} If not initialized
-     */
-    getClient(): OpenRouter;
-    /**
-     * Get the currently configured default model.
+     * Returns the currently configured default model.
      */
     getModel(): string;
     /**
-     * Check whether the provider has been initialized.
+     * Returns whether the provider has been initialized.
      */
     isInitialized(): boolean;
+    private assertInitialized;
+    /** Common request headers sent to the server on every AI call. */
+    private authHeaders;
     /**
      * Generate a response for a prompt (non-streaming).
      *
+     * Calls: POST {serverUrl}/generate
+     * Body:  { prompt, model, system?, maxTokens?, temperature? }
+     * Expected response: { text: string } or { content: string } or { message: string }
+     *
      * @param prompt - The user prompt string
      * @param options - Optional overrides (model, system, maxTokens, temperature)
      * @returns The assistant's response text
      */
     generate(prompt: string, options?: GenerateOptions): Promise<string>;
     /**
-     * Generate a streaming response for a prompt.
+     * Generate a streaming response for a prompt via Server-Sent Events (SSE).
+     *
+     * Calls: POST {serverUrl}/stream
+     * Body:  { prompt, model, system?, maxTokens?, temperature? }
+     * Expected response: `text/event-stream` with `data: <chunk>` lines.
      *
      * @param prompt - The user prompt string
      * @param options - Optional overrides (model, system, maxTokens, temperature)
-     * @returns An async iterable of server-sent event chunks
+     * @returns An async generator yielding string chunks from the server
      *
      * @example
      * ```typescript
-     * const stream = await ai.stream('Tell me a story');
+     * const stream = ai.stream('Tell me a story');
      * for await (const chunk of stream) {
-     *   process.stdout.write(chunk.choices?.[0]?.delta?.content ?? '');
+     *   process.stdout.write(chunk);
      * }
      * ```
      */
-    stream(prompt: string, options?: GenerateOptions): Promise<_openrouter_sdk_lib_event_streams_js.EventStream<_openrouter_sdk_models.ChatStreamingResponseChunkData>>;
+    stream(prompt: string, options?: GenerateOptions): AsyncGenerator<string>;
     /**
      * Multi-turn conversation: pass a full message history.
      *
+     * Calls: POST {serverUrl}/chat
+     * Body:  { messages, model, maxTokens?, temperature? }
+     * Expected response: { text: string } or { content: string } or { message: string }
+     *
      * @param messages - Full conversation history
      * @param options - Optional overrides (model, maxTokens, temperature)
+     * @returns The assistant's response text
      */
     chat(messages: ChatMessage[], options?: GenerateOptions): Promise<string>;
 }
@@ -186,16 +199,19 @@ declare class KrutAIProvider {
 /**
  * @krutai/ai-provider — AI Provider package for KrutAI
  *
- * A thin wrapper around `@openrouter/sdk`, mirroring the patterns from `@krutai/auth`.
- *
- * Default model: `qwen/qwen3-235b-a22b-thinking-2507`
+ * A fetch-based wrapper that calls your deployed LangChain backend server.
+ * The user's API key is validated against the server before any AI call is made.
  *
  * @example Basic usage
  * ```typescript
  * import { krutAI } from '@krutai/ai-provider';
  *
- * const ai = krutAI(); // uses OPENROUTER_API_KEY env var
- * await ai.initialize();
+ * const ai = krutAI({
+ *   apiKey: process.env.KRUTAI_API_KEY!,
+ *   serverUrl: 'https://ai.yourapp.com',
+ * });
+ *
+ * await ai.initialize(); // validates key with server
  *
  * const text = await ai.generate('Write a poem about TypeScript');
  * console.log(text);
@@ -203,19 +219,26 @@ declare class KrutAIProvider {
  *
  * @example With custom model
  * ```typescript
- * const ai = krutAI({ model: 'openai/gpt-4o' });
+ * const ai = krutAI({
+ *   apiKey: process.env.KRUTAI_API_KEY!,
+ *   serverUrl: 'https://ai.yourapp.com',
+ *   model: 'gpt-4o',
+ * });
  * await ai.initialize();
  * const text = await ai.generate('Hello!');
  * ```
  *
  * @example Streaming
  * ```typescript
- * const ai = krutAI();
+ * const ai = krutAI({
+ *   apiKey: process.env.KRUTAI_API_KEY!,
+ *   serverUrl: 'https://ai.yourapp.com',
+ * });
  * await ai.initialize();
  *
- * const stream = await ai.stream('Tell me a story');
+ * const stream = ai.stream('Tell me a story');
  * for await (const chunk of stream) {
- *   process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
+ *   process.stdout.write(chunk);
  * }
  * ```
  *
@@ -225,24 +248,27 @@ declare class KrutAIProvider {
 /**
  * krutAI — convenience factory (mirrors `krutAuth` in @krutai/auth).
  *
- * Creates a `KrutAIProvider` instance. OpenRouter API key is read from
- * `config.openRouterApiKey` or falls back to `process.env.OPENROUTER_API_KEY`.
+ * Creates a `KrutAIProvider` instance configured to call your LangChain server.
  *
- * @param config - Provider configuration (all fields optional except apiKey)
- * @returns A `KrutAIProvider` instance (call `.initialize()` before use)
+ * @param config - Provider configuration (`apiKey` and `serverUrl` are required)
+ * @returns A `KrutAIProvider` instance — call `.initialize()` before use
  *
  * @example
  * ```typescript
  * import { krutAI } from '@krutai/ai-provider';
  *
- * const ai = krutAI(); // env OPENROUTER_API_KEY + default model
+ * const ai = krutAI({
+ *   apiKey: process.env.KRUTAI_API_KEY!,
+ *   serverUrl: 'https://ai.yourapp.com',
+ * });
+ *
  * await ai.initialize();
  * const text = await ai.generate('Hello!');
  * ```
  */
-declare function krutAI(config?: Partial<KrutAIProviderConfig> & {
-    apiKey?: string;
+declare function krutAI(config: KrutAIProviderConfig & {
+    model?: string;
 }): KrutAIProvider;
-declare const VERSION = "0.1.0";
+declare const VERSION = "0.2.0";
 
-export { type ChatMessage, DEFAULT_MODEL, type GenerateOptions, KrutAIProvider, type KrutAIProviderConfig, OpenRouterKeyValidationError, VERSION, krutAI, validateOpenRouterKeyFormat, validateOpenRouterKeyWithService };
+export { type ChatMessage, DEFAULT_MODEL, type GenerateOptions, KrutAIKeyValidationError, KrutAIProvider, type KrutAIProviderConfig, VERSION, krutAI, validateApiKey, validateApiKeyFormat };