// Your existing function — untouched
async function getWeather(city: string) {
  return `22°C and sunny in ${city}`
}

// Register it once with AILink
ai.register('getWeather', async ({ city }) => getWeather(city), {
  description: 'Get current weather for a city',
  parameters: {
    type: 'object',
    properties: {
      city: { type: 'string', description: 'City name' }
    },
    required: ['city']
  }
})

// Now anyone can use it with natural language
const result = await ai.run('What is the weather in Tokyo?')
console.log(result.response)
// → "It's currently 22°C and sunny in Tokyo."

import { AILink } from '@ailink/sdk'

const ai = new AILink({
  provider: 'groq',
  providerKey: process.env.GROQ_KEY!
})

ai.register('checkStock', async ({ productId }) => {
  // your existing function
  return inventory.check(productId)
}, {
  description: 'Check how many units of a product are in stock',
  parameters: {
    type: 'object',
    properties: {
      productId: { type: 'string', description: 'Product ID to check' }
    },
    required: ['productId']
  }
})

const result = await ai.run('How many units of product-001 do we have?')
console.log(result.response)
// → "You have 45 units of product-001 in stock."

ai.register('functionName', async (args) => {
  return yourExistingFunction(args)
}, {
  description: 'Plain English — what does this function do?',
  parameters: {
    type: 'object',
    properties: {
      param1: { type: 'string', description: 'What is this parameter?' }
    },
    required: ['param1']
  }
})

// Your existing LangChain chain — not touching this
const chain = prompt.pipe(model).pipe(new StringOutputParser())

// Wrap it with AILink — one line, nothing changes
const wrapped = ai.wrap(chain.invoke.bind(chain), {
  toolName: 'ProductRagChain',
  role: 'admin'
})

// Call it exactly as before — now tracked through AILink
const result = await wrapped({ question: 'What is the return policy?' })

// Your existing functions — registered as normal, not touched
ai.register('checkStock', async ({ productId }) => checkStock(productId), {
  description: 'Check stock levels',
  parameters: { type: 'object', properties: { productId: { type: 'string' } }, required: ['productId'] }
})

// New SDK function — wrapped with ai.wrap(), registered as a tool
const searchDocs = ai.wrap(retriever.getRelevantDocuments.bind(retriever), {
  toolName: 'DocumentSearch'
})

// Both work together — AI picks which to call
const result = await ai.run('Check stock for laptop-001 and find the return policy')

import { streamText } from 'ai'
import { openai } from '@ai-sdk/openai'

// Your existing streaming function
async function streamResponse(prompt: string) {
  return streamText({ model: openai('gpt-4o'), prompt })
}

// Wrap it — AILink tracks the call, streaming behavior is unchanged
const streamWithTracking = ai.wrap(streamResponse, { toolName: 'StreamedResponse' })

// Call it exactly as you did before — stream still works
const stream = await streamWithTracking('Explain quantum entanglement')
for await (const chunk of stream.textStream) {
  process.stdout.write(chunk)
}

import { RetrievalQAChain } from 'langchain/chains'

const chain = RetrievalQAChain.fromLLM(llm, vectorStore.asRetriever())

// Wrap it — LangChain does the retrieval, AILink tracks it
const ragSearch = ai.wrap(chain.call.bind(chain), { toolName: 'PolicyRag', role: 'user' })

// Your product policy search — unchanged, now tracked
const answer = await ragSearch({ query: 'What is the refund window?' })
console.log(answer.text)
// → 'Refunds are accepted within 30 days of purchase.'

// Frontend — exactly as it was
import { useChat } from 'ai/react'

export function Chat() {
  const { messages, input, handleSubmit } = useChat({ api: '/api/chat' })
  return (
    <form onSubmit={handleSubmit}>
      <input value={input} onChange={e => setInput(e.target.value)} />
    </form>
  )
}

// Backend — your Express handler calls AILink
import { AILink } from '@ailink/sdk'

const ai = new AILink({ provider: 'groq', providerKey: process.env.GROQ_KEY! })
ai.register('getOrderStatus', async ({ orderId }) => db.orders.status(orderId), {
  description: 'Get the current status of an order',
  parameters: { type: 'object', properties: { orderId: { type: 'string' } }, required: ['orderId'] }
})

app.post('/api/chat', async (req, res) => {
  const result = await ai.run(req.body.messages.at(-1).content)
  res.json({ role: 'assistant', content: result.response })
})

async function getOrderStatus({ orderId }: { orderId: string }) {
  return db.orders.status(orderId)
}

// Wrap it to add your own callback behavior
const tracked = ai.wrap(async (args: { orderId: string }) => {
  const result = await getOrderStatus(args)
  await myAnalytics.log({ tool: 'getOrderStatus', args, result })  // your callback
  return result
}, { toolName: 'getOrderStatus' })

const wrapped = ai.wrap(anyAsyncFunction)

// Using Groq
const ai = new AILink({ provider: 'groq', providerKey: process.env.GROQ_KEY! })

// Using OpenAI — everything else stays the same
const ai = new AILink({ provider: 'openai', providerKey: process.env.OPENAI_KEY! })

const ai = new AILink({
  provider: 'openai',
  providerKey: process.env.OPENAI_KEY!,
  providerKeys: {
    claude: process.env.CLAUDE_KEY!,
    groq: process.env.GROQ_KEY!
  },
  fallback: ['claude', 'groq'],
  retries: 3,
  retryDelay: 1000,
  platformKey: 'your-key'
})

ai.register('viewData', async () => getData(), {
  description: 'View public data',
  parameters: { type: 'object', properties: {} },
  roles: ['user', 'admin', 'developer']  // everyone
})

ai.register('updateSettings', async (args) => updateSettings(args), {
  description: 'Update system settings',
  parameters: { type: 'object', properties: { setting: { type: 'string' } } },
  roles: ['admin', 'developer']  // admin and above only
})

ai.register('deleteAllData', async () => deleteAll(), {
  description: 'Delete all data',
  parameters: { type: 'object', properties: {} },
  roles: ['developer']  // developer only
})

// Pass the role at runtime
await ai.run('Update the settings', { userRole: 'admin' })    // allowed
await ai.run('Delete all data', { userRole: 'user' })         // blocked

ai.register('checkStock', async (args) => checkInventory(args), {
  description: 'Check stock levels',
  parameters: { type: 'object', properties: { productId: { type: 'string' } } },
  group: 'inventory'
})

ai.register('processRefund', async (args) => refund(args), {
  description: 'Process a customer refund',
  parameters: { type: 'object', properties: { orderId: { type: 'string' } } },
  group: 'payments'
})

// Only inventory tools are available for this request
await ai.run('How many laptops are in stock?', { groups: ['inventory'] })

// Only payment tools
await ai.run('Process a refund for order-123', { groups: ['payments'] })

// Multiple groups
await ai.run('Check stock and process refund', { groups: ['inventory', 'payments'] })

const session = ai.createSession()

await session.run('My name is Jay and I work at Acme Corp')
await session.run('I want to order 5 laptops')
const result = await session.run('What is the total cost and who is placing the order?')
// → AI remembers the name, company, and order from previous turns
console.log(result.response)

// Save
const history = session.getHistory()
const sessionId = session.sessionId
// Store both in your database

// Restore later
const restored = ai.createSession(sessionId, 50, savedHistory)
await restored.run('Continue from where we left off')

ai.createSession(
  sessionId?,       // Custom ID — auto-generated if not provided
  maxTurns?,        // Max turns to keep in memory. Default: 50. Older turns are pruned automatically.
  initialHistory?   // Restore a saved session
)

ai.register('fetchUser', async ({ userId }) => getUser(userId), { ... })
ai.register('fetchOrders', async ({ userId }) => getOrders(userId), { ... })
ai.register('fetchPayments', async ({ userId }) => getPayments(userId), { ... })

// All three run in parallel automatically
const result = await ai.run('Give me the full profile for user-123')

const ai = new AILink({
  provider: 'groq',
  providerKey: process.env.GROQ_KEY!,
  platformUrl: 'https://your-dashboard.com/logs',
  platformKey: 'your-dashboard-key'
})

const ai = new AILink({
  provider: 'groq',
  providerKey: process.env.GROQ_KEY!,
  platformKey: 'your-key',
  maxIterations: 5  // default is 10
})

const names = ai.tools()
// → ['checkStock', 'processRefund', 'getWeather']

const defs = ai.toolDefinitions()
console.log(defs[0])
// → {
// →   name: 'checkStock',
// →   description: 'Check how many units of a product are in stock',
// →   schema: {
// →     type: 'object',
// →     properties: { productId: { type: 'string', description: 'Product ID to check' } },
// →     required: ['productId']
// →   },
// →   roles: ['user', 'admin', 'developer'],
// →   group: 'inventory'
// → }

ai.unregister('getWeather')
// The tool is immediately removed from the registry.
// Any subsequent ai.run() call will no longer have access to it.

const ai = new AILink({
  // Required
  provider: 'openai' | 'claude' | 'groq' | 'gemini',
  providerKey: string,       // Your provider API key

  // Optional
  platformKey?: string,      // Auth key for your logging platform. Optional.
  model?: string,            // Override the default model for your provider
  providerKeys?: {           // API keys for fallback providers
    openai?: string,
    claude?: string,
    groq?: string,
    gemini?: string
  },
  fallback?: ProviderName[],    // Fallback providers in order of preference
  retries?: number,             // Retry attempts per provider. Default: 3
  retryDelay?: number,          // Delay between retries in ms. Default: 1000
  maxIterations?: number,       // Max tool-call loop iterations. Default: 10
  debug?: boolean,              // Log engine calls to console. Default: false
  environment?: 'development' | 'staging' | 'production',
  platformUrl?: string          // Send usage logs to your own server or dashboard
})

{
  response: string        // The AI's final natural language response
  toolsCalled: string[]   // Names of tools that were called
  allowedTools: string[]  // Names of tools that were available for this request
  executionTime: number   // Total time in milliseconds
  provider: ProviderName  // Which provider was used (may differ from primary if fallback triggered)
  userRole: RoleName      // Role used for this request
  groups: string[] | null // Groups used for filtering, or null if none specified
  promptTokens: number | null   // Input tokens used — null if provider did not return usage data
  completionTokens: number | null // Output tokens used — null if provider did not return usage data
}

const result = await ai.run('How many units of laptop-001 are in stock?', { userRole: 'admin' })
console.log(result)
// → {
// →   response: 'There are 42 units of laptop-001 currently in stock.',
// →   toolsCalled: ['checkStock'],
// →   allowedTools: ['checkStock', 'processRefund', 'getWeather'],
// →   executionTime: 834,
// →   provider: 'groq',
// →   userRole: 'admin',
// →   groups: null,
// →   promptTokens: 312,
// →   completionTokens: 28
// → }

import {
  AILinkConfigError,
  AllProvidersFailedError,
  EmptyGroupError,
  ToolAlreadyExistsError,
  ToolNotFoundError,
  ValidationError,
  ToolExecutionError,
  UnsupportedProviderError
} from '@ailink/sdk'

try {
  const result = await ai.run('User request')
  console.log(result.response)
} catch (error) {
  if (error instanceof AILinkConfigError) {
    // Missing or invalid configuration
  } else if (error instanceof AllProvidersFailedError) {
    // Primary provider and all fallbacks failed
  } else if (error instanceof EmptyGroupError) {
    // No tools found for the specified groups
  } else if (error instanceof ValidationError) {
    // AI passed invalid arguments to a tool
  }
}

import { AILink } from '@ailink/sdk'

const ai = new AILink({ provider: 'groq', providerKey: process.env.GROQ_KEY! })

// Register your existing functions
ai.register('getOrder', async ({ orderId }) => db.orders.find(orderId), {
  description: 'Get order details by order ID',
  parameters: {
    type: 'object',
    properties: { orderId: { type: 'string' } },
    required: ['orderId']
  }
})

app.post('/chat', async (req, res) => {
  const result = await ai.run(req.body.message, { userRole: req.user.role })
  res.json({ response: result.response })
})

const sessions = new Map()

app.post('/chat/:sessionId', async (req, res) => {
  let session = sessions.get(req.params.sessionId)
  if (!session) {
    session = ai.createSession(req.params.sessionId)
    sessions.set(req.params.sessionId, session)
  }
  const result = await session.run(req.body.message)
  res.json({ response: result.response })
})

const ai = new AILink({
  provider: 'groq',
  providerKey: process.env.GROQ_KEY!,
  debug: true  // logs all engine calls to console
})