import OpenRouter from 'openrouter-kit'; // Using the default export

// Initialize the client with your API key
const client = new OpenRouter({
  apiKey: 'sk-or-v1-...' // Your OpenRouter API key
  // debug: true, // Enable detailed logging
});

async function main() {
  try {
    // Simple request to the model
    const response = await client.chat({ prompt: 'Hello, world!' });
    console.log('Model response:', response);

    // Example specifying a model
    const haikuResponse = await client.chat({
        model: 'google/gemini-2.0-flash-001',
        prompt: 'Tell me a short joke about programmers.'
    });
    console.log('Joke from Haiku:', haikuResponse);

  } catch (error: any) {
    console.error(`An error occurred [${error.code || 'UNKNOWN'}]: ${error.message}`);
    if (error.details) {
        console.error('Details:', error.details);
    }
  }
  // Note: In short-lived scripts, calling client.destroy() is not strictly necessary, 
  // but it's crucial in long-running applications to release resources (see below).
}

main();

import OpenRouter from 'openrouter-kit';

const client = new OpenRouter({ apiKey: 'YOUR_KEY', historyStorage: 'memory' });
const userId = 'user-abc';

async function chatWithHistory(prompt: string) {
  console.log(`> User (${userId}): ${prompt}`);
  // Pass 'user' to enable history management
  const response = await client.chat({ prompt, user: userId });
  console.log(`< Assistant: ${response}`);
  return response;
}

async function runConversation() {
  await chatWithHistory('Hello! My name is Alex.');
  await chatWithHistory('What is the weather like in Moscow today?');
  await chatWithHistory('What is my name?'); // The model should remember the name from history
  
  // In applications where the client is used long-term, calling destroy is important
  await client.destroy();
}

runConversation();

import { Tool, ToolContext } from 'openrouter-kit'; // Import types

// Example weather fetching function
async function getCurrentWeather(location: string, unit: 'celsius' | 'fahrenheit' = 'celsius'): Promise<object> {
    console.log(`[Tool] Fetching weather for ${location} (${unit})`);
    // ... weather API call logic here ...
    // Return an object to be serialized to JSON
    return { location, temperature: "25", unit, forecast: "sunny" };
}

// Tool definition for the API
const weatherTool: Tool = {
  type: 'function',
  function: {
    name: 'getCurrentWeather', // Name the LLM will use
    description: 'Get the current weather in a specified location',
    parameters: { // JSON Schema for arguments
      type: 'object',
      properties: {
        location: {
          type: 'string',
          description: 'The city or location, e.g., Moscow or San Francisco',
        },
        unit: {
          type: 'string',
          enum: ['celsius', 'fahrenheit'],
          description: 'Unit for temperature',
        },
      },
      required: ['location'], // Required arguments
    },
  },
  // Function that will be called by the library
  execute: async (args: { location: string; unit?: 'celsius' | 'fahrenheit' }, context?: ToolContext) => {
      // args - parsed and validated arguments
      // context - contains userInfo and securityManager (if available)
      console.log(`Executing getCurrentWeather for user: ${context?.userInfo?.userId || 'unknown'}`);
      return getCurrentWeather(args.location, args.unit);
  },
  // (Optional) Security settings for this tool
  security: {
      // requiredRole: 'premium_user',
      // rateLimit: { limit: 5, period: 'minute' }
  }
};

async function askAboutWeather() {
  const client = new OpenRouter({ apiKey: 'YOUR_KEY' });
  try {
    const response = await client.chat({
      prompt: 'What\'s the weather like in London?',
      tools: [weatherTool] // Pass our tool
    });
    console.log('Final response:', response);
  } catch (error: any) {
    console.error('Error:', error.message);
  } finally {
    // Important for long-running applications
    await client.destroy();
  }
}

askAboutWeather();

import OpenRouter from 'openrouter-kit';
import type { SecurityConfig } from 'openrouter-kit/security'; // Import type

const jwtSecret = process.env.JWT_SECRET || 'default-secret-replace-in-production'; // IMPORTANT: Replace with a strong secret!

const securityConfig: SecurityConfig = {
  debug: true, // Enable security logging
  defaultPolicy: 'deny-all', // Deny tool access by default
  requireAuthentication: false, // Require authentication for ANY request with tools?
  allowUnauthenticatedAccess: false, // Allow tool access WITHOUT a token (if requireAuthentication=false)?

  // Authentication settings
  userAuthentication: {
    type: 'jwt',
    jwtSecret: jwtSecret, // Secret for signing and verifying JWTs
  },

  // Tool access settings (override defaultPolicy)
  toolAccess: {
    // Global rules for all tools
    '*': {
      // allow: false // Can deny all by default here too (if defaultPolicy='allow-all')
      // rateLimit: { limit: 100, period: 'hour' } // Global limit
    },
    // Rules for a specific tool
    'getCurrentWeather': {
      allow: true, // Allow calling getCurrentWeather
      roles: ['user', 'admin'], // Only for users with 'user' or 'admin' roles
      rateLimit: { limit: 10, period: 'minute' } // Limit for this specific tool
    },
    'adminTool': {
      allow: true,
      roles: ['admin'], // Only for admins
    },
    'publicTool': {
      allow: true, // Allowed for everyone (even anonymous if allowUnauthenticatedAccess=true)
    }
  },

  // Role definitions (optional, limits and access can be set directly in toolAccess)
  roles: {
      roles: {
          'admin': {
              allowedTools: ['*'], // All tools allowed
              // rateLimits: { '*': { limit: 1000, period: 'hour' }} // Limit for all tools for admin
          },
          'user': {
              allowedTools: ['getCurrentWeather', 'publicTool'], // Explicitly allowed tools
              // rateLimits: { 'getCurrentWeather': { limit: 5, period: 'minute' }}
          }
      }
  },

  // Dangerous argument check configuration
  dangerousArguments: {
    blockedValues: ['DROP TABLE', '--'], // Forbidden substrings
    // toolSpecificPatterns: { // Regex for specific tools
    //   'executeShellCommand': [/rm -rf/, /mkfs/]
    // }
  }
};

const client = new OpenRouter({
  apiKey: 'YOUR_KEY',
  security: securityConfig // Pass the security configuration
});

// --- Usage ---

// 1. Create an access token for a user (e.g., after login)
try {
    const userInfo = { userId: 'user-123', role: 'user', scopes: ['read'] };
    const accessToken = client.createAccessToken(userInfo, '24h'); // Create JWT
    console.log('Access Token:', accessToken);

    // 2. Call chat with the token
    async function callToolWithAuth(token: string) {
        const response = await client.chat({
            prompt: 'What\'s the weather in Berlin?',
            tools: [weatherTool], // Weather tool
            accessToken: token // Pass the token
        });
        console.log('Response with tool:', response);
    }
    // await callToolWithAuth(accessToken);

} catch(e: any) {
    console.error("Error working with token or chat:", e.message);
}

// Subscribe to security events
client.on('access:denied', (event) => {
    console.warn(`[EVENT] Access Denied: User '${event.userId || 'anon'}' to Tool '${event.toolName}'. Reason: ${event.reason}`);
});
client.on('ratelimit:exceeded', (event) => {
     console.warn(`[EVENT] Rate Limit Exceeded: User '${event.userId}' for Tool '${event.toolName}' (Limit: ${event.limit})`);
});

// Don't forget client.destroy() when shutting down the application
// await client.destroy();

async function getStructuredData() {
  const client = new OpenRouter({ apiKey: 'YOUR_KEY' });
  try {
    // Request JSON object
    const jsonResponse = await client.chat({
      prompt: 'Represent information about user John Doe (30 years old, email john.doe@example.com) as JSON.',
      responseFormat: { type: 'json_object' },
      // strictJsonParsing: true, // Throw error if parsing/validation fails
    });
    console.log('JSON Object:', jsonResponse); // Should be a JS object

    // Request JSON according to schema
    const userSchema = {
      type: "object",
      properties: {
        name: { type: "string" },
        age: { type: "integer" },
        email: { type: "string", format: "email" }
      },
      required: ["name", "age"]
    };

    const schemaResponse = await client.chat({
        prompt: 'Create JSON for user Jane Smith, 25 years old, jane@test.com',
        responseFormat: {
            type: 'json_schema',
            json_schema: {
                name: 'User',
                schema: userSchema
            }
        }
    });
     console.log('JSON Schema Response:', schemaResponse); // Should be a JS object matching the schema

  } catch (error: any) {
    console.error('Error:', error.message);
  } finally {
    // Again, important for long-running applications
    await client.destroy();
  }
}

getStructuredData();

import { RateLimitError, ValidationError, ErrorCode } from 'openrouter-kit';

// ...
try {
  // ... call client.chat() ...
} catch (error: any) {
  if (error instanceof RateLimitError) {
    console.warn(`Rate limit reached. Retry after ${Math.ceil((error.details?.timeLeft || 0) / 1000)} sec.`);
  } else if (error instanceof ValidationError) {
    console.error(`Validation error: ${error.message}`, error.details);
  } else if (error.code === ErrorCode.AUTHENTICATION_ERROR) {
     console.error(`Authentication error: check your API key.`);
  } else {
    console.error(`Unhandled error [${error.code || 'UNKNOWN'}]: ${error.message}`);
  }
}

client.on('error', (error) => {
  console.error(`[Client Event Error] Code: ${error.code}, Message: ${error.message}`);
});

// URL string format
const client1 = new OpenRouter({
  apiKey: 'YOUR_KEY',
  proxy: 'http://user:password@your-proxy-server:8080'
});

// Object format
const client2 = new OpenRouter({
  apiKey: 'YOUR_KEY',
  proxy: {
    host: 'your-proxy-server.com',
    port: 8080,
    // user: 'proxy_user', // optional
    // pass: 'proxy_pass'  // optional
  }
});