seb/llmorbiter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
seb
2026-09-21 11:26:37 +02:00
commit d47acf5481
11 changed files with 1398 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

500
examples/pdf-pages.js Normal file
View File

@@ -0,0 +1,500 @@
'use strict';
/**
* Example: PDF → per-page LLM processing.
*
* Demonstrates reading a PDF with `pdftotext -layout`, splitting the output
* into pages on the form-feed character (\f), and feeding each page through
* LLMOrbiter in a foreach loop with a simple prompt.
*
* Usage:
* OPENROUTER_API_KEY=sk-or-... node examples/pdf-pages.js
* node examples/pdf-pages.js --key sk-or-... --model <model>
*/
import { execFileSync } from 'child_process';
import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import dotenv from 'dotenv';
import { LLMOrbiter, OpenRouterProvider, defineTool, DirectReturnError } from '../src/index.js';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
dotenv.config({ path: path.resolve(__dirname, '.env') });
// ─── Prompt logfile ─────────────────────────────────────────────────────────────
// Appends the full prompt of every LLM call so we can debug prompt composition.
const logFile = path.resolve(__dirname, 'prompts.log');
function logPrompt(prompt) {
fs.appendFileSync(logFile, `\n${'='.repeat(80)}\n${new Date().toISOString()}\n${'='.repeat(80)}\n${prompt}\n`);
}
function logEntry(label, data) {
fs.appendFileSync(logFile, `\n--- ${label} @ ${new Date().toISOString()} ---\n${typeof data === 'string' ? data : JSON.stringify(data, null, 2)}\n`);
}
// ─── CLI args ───────────────────────────────────────────────────────────────────
const args = process.argv.slice(2);
function getArg(flag) {
const idx = args.indexOf(flag);
return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
}
const apiKey = getArg('--key') || process.env.OPENROUTER_API_KEY;
//const model = getArg('--model') || '~deepseek/deepseek-flash-latest';
//const model = getArg('--model') || 'moonshotai/kimi-k3';
//const model = getArg('--model') || '~openai/gpt-terra-latest:floor';
//const model = getArg('--model') || '~openai/gpt-sol-latest:floor';
//const model = getArg('--model') || '~anthropic/claude-sonnet-latest';
//const model = getArg('--model') || 'google/gemini-3.8-flash';
const model = getArg('--model') || '~openai/gpt-luna-latest:floor';
const pdfPath = getArg('--pdf') || path.resolve(__dirname, 'invoice.pdf');
if (!apiKey) {
console.error('Error: Missing API key. Set OPENROUTER_API_KEY in examples/.env or pass --key <api-key>');
process.exit(1);
}
// ─── Accumulated manifest state ─────────────────────────────────────────────────
// Split into two parts that mirror the two tools, so the prompt sections match
// the tool names and don't confuse the LLM.
const manifestBasedata = {
date: null,
kLieferant: null,
lieferantName: null,
manifestNr: null,
manifestType: null,
};
const manifestNotes = [];
const manifestItems = {
items: [],
pagesFrom: null,
pagesTo: null,
};
// Current page being processed (set in the loop before each run).
let currentPage = 0;
// ─── Tools ──────────────────────────────────────────────────────────────────────
// A single tool with three strictly optional components. Only include the
// components that have new data for this batch; omit the rest.
const outputManifestTool = defineTool({
name: 'output_manifest',
description: 'Stores extracted invoice/delivery-note data: header metadata (basedata), notes, and product line items. Each component is strictly optional — only include the ones that carry new data.',
strict: false,
parameters: {
type: 'object',
additionalProperties: false,
required: [],
properties: {
basedata: {
anyOf: [
{
type: 'object',
additionalProperties: false,
properties: {
date: {
type: ['string', 'null'],
description: 'Document date (ISO 8601)',
},
kLieferant: {
type: ['number', 'null'],
description: 'Lieferant ID',
},
lieferantName: {
type: 'string',
description: 'Lieferant name',
},
manifestNr: {
type: ['string', 'null'],
description: 'Lieferscheinnummer or Rechnungsnummer',
},
manifestType: {
anyOf: [
{ type: 'string', enum: ['rechnung', 'lieferschein'] },
{ type: 'null' },
],
description: 'Document type',
},
},
},
{ type: 'null' },
],
description: 'Header/metadata. Only include fields that are currently missing or changed.',
},
notes: {
anyOf: [
{ type: 'array', items: { type: 'string' } },
{ type: 'null' },
],
description: 'New noteworthy details (in German), for a human to double-check the result. Only include notes not already present.',
},
items: {
anyOf: [
{
type: 'object',
additionalProperties: false,
properties: {
numberOfItemsToAdd: {
type: 'number',
description: 'Number of NEW line items being added in this call (not the running total). Helps you keep track of how many items you are adding.',
},
items: {
type: 'array',
description: 'Invoice/delivery product line items',
items: {
type: 'object',
additionalProperties: false,
required: ['position', 'count', 'vpe', 'unit', 'articleName', 'liefArtNr', 'mwst', 'eknetto'],
properties: {
position: { type: 'number', description: 'Position' },
count: { type: 'number', description: 'Quantity (Menge)' },
vpe: {
type: 'number',
description: 'Packaging unit size (VPE). Default: 1. (count * vpe = total individual sellable items). A bulk pack like VE100 means vpe = 100.',
},
unit: { type: 'string', description: 'Unit of the individual sellable item (e.g. Stk., Beutel, Flasche, Box, Set). NEVER "VE" or "VPE".' },
articleName: { type: 'string', description: 'Article name' },
liefArtNr: { type: 'string', description: 'Supplier article number (Art. Nr.)' },
mwst: {
anyOf: [
{ type: 'string', enum: ['7', '19'] },
{ type: 'null' },
],
description: 'VAT rate (no % sign); null if missing',
},
eknetto: {
type: ['number', 'null'],
description: 'Net price per item or per vpe in euro cents; null if missing; DO NOT USE THE TOTAL, USE THE PER PIECE PRICE',
},
},
},
},
},
},
{ type: 'null' },
],
description: 'New product line items. Only include items not already present.',
},
},
},
invoke: async (args) => {
// 1. basedata — merge only the fields the LLM actually filled in.
if (args.basedata && typeof args.basedata === 'object') {
for (const key of ['date', 'kLieferant', 'lieferantName', 'manifestNr', 'manifestType']) {
if (args.basedata[key] != null) manifestBasedata[key] = args.basedata[key];
}
}
// 2. notes — accept an array of strings; dedupe so re-sent notes don't accumulate.
if (Array.isArray(args.notes)) {
for (const n of args.notes) {
if (n && !manifestNotes.includes(n)) manifestNotes.push(n);
}
}
// 3. items — add only NEW items (dedupe by position).
if (args.items && typeof args.items === 'object' && Array.isArray(args.items.items)) {
const existing = new Set(manifestItems.items.map((it) => it.position));
for (const it of args.items.items) {
if (!existing.has(it.position)) {
manifestItems.items.push({ ...it, page: currentPage });
existing.add(it.position);
}
}
// numberOfItemsToAdd is intentionally ignored — it only helps the LLM
// keep track of how many items it is adding in this call.
// Track the page range the current items come from.
const pages = manifestItems.items.map((it) => it.page).filter((p) => p != null);
if (pages.length) {
manifestItems.pagesFrom = Math.min(...pages);
manifestItems.pagesTo = Math.max(...pages);
}
}
// Stop the LLM loop and return the accumulated data to the caller.
throw new DirectReturnError({
basedata: manifestBasedata,
notes: manifestNotes,
items: manifestItems,
});
},
});
// ─── Base extraction prompt ─────────────────────────────────────────────────────
const BASE_PROMPT = `Extract metadata and product line items from the provided invoice or delivery note.
Call the output_manifest tool with the extracted data. Do not answer with plain text once extraction is complete.
Rules:
- manifestType: "rechnung" or "lieferschein". For "lieferschein", prices and taxes must be null.
- Exclude non-product lines (shipping, handling, etc.).
- Line items: Extract count, vpe (default: 1), liefArtNr, mwst (7 or 19), and eknetto per piece(euro cents).
- Match supplier against the provided list for kLieferant and lieferantName. For unknown suppliers, extract lieferantName and set kLieferant to null.
- Write notes strictly in German.
- The output_manifest tool has three strictly optional components: basedata, notes, items. Only include a component when it carries genuinely new data for this batch; omit the rest.
- Include basedata ONLY when at least one of its fields is currently null/empty and you can fill it in, or when a value actually changes. If all basedata fields are already set and unchanged, omit basedata.
- Include items ONLY when this batch contains new product line items not already present. If there are no new items, omit items.
- Include notes ONLY when there is a genuinely new noteworthy detail not already in the notes list. These notes are for a human to double-check the extraction result, so record anything ambiguous, unusual, or worth verifying (e.g. packaging interpretations, excluded lines, unavailable articles).
VPE (Verpackungseinheit) Logic:
VPE represents the number of individually sellable units inside a bulk item. If not explicitly split for individual sale, default to 1.
- "20 Boxen á 10 Stück" -> VPE = 20.
- "10 Gläser á 100 Filter" -> VPE = 10 (we sell the 10 glasses individually).
- "100 Stück" -> VPE = 1 (sold as one bulk pack).
- We don't sell the individual filters or Pieces, but typical VPEs like Beutel, Glässer, Boxen, Hefte
- That menas that in "Y Hefte á X Blatt" the VPE is NOT X but: Y
- a so called "Display" also means VPE. So "20er Display" means VPE = 20
- eknetto is the price of one full vpe
Unit (ME) rules:
- The unit (ME) must ALWAYS refer to the individual sellable item (e.g. Stk., Beutel, Flasche, Box, Set). It must NEVER be "VE" or "VPE".
- A packaging size like "VE100" means the bulk pack contains 100 individual items: set vpe = 100 and unit = the individual item (e.g. Stk.).
- Example: "Einhängesiebe Stahl, VE100" -> vpe = 100, unit = "Stk.", count = 1 (one bulk pack of 100 sieves).`;
// ─── Read PDF and split into pages ──────────────────────────────────────────────
function readPdfPages(file) {
// pdftotext -layout preserves column layout; pages are separated by \f (form feed)
const raw = execFileSync('pdftotext', ['-layout', file, '-'], { encoding: 'utf8' });
// Split on form feed, drop any leading/trailing empty chunks
return raw
.split('\f')
.map((p) => p.trim())
.filter((p) => p.length > 0);
}
// ─── Write output table ─────────────────────────────────────────────────────────
// Meta base data at the top, then a table of the items.
function writeOutputTable() {
const lines = [];
lines.push('=== Manifest Base Data ===');
lines.push(`Date: ${manifestBasedata.date ?? ''}`);
lines.push(`Lieferant ID: ${manifestBasedata.kLieferant ?? ''}`);
lines.push(`Lieferant Name: ${manifestBasedata.lieferantName ?? ''}`);
lines.push(`Manifest Nr: ${manifestBasedata.manifestNr ?? ''}`);
lines.push(`Manifest Type: ${manifestBasedata.manifestType ?? ''}`);
lines.push(`Number of Items: ${manifestItems.items.length}`);
if (manifestNotes.length) {
lines.push('Notes:');
for (const n of manifestNotes) lines.push(` - ${n}`);
}
lines.push('');
lines.push('=== Items ===');
const headers = ['Pos', 'Art. Nr.', 'Article Name', 'Count', 'VPE', 'Unit', 'MwSt', 'EK Netto (ct)'];
const rows = manifestItems.items.map((it) => [
it.position,
it.liefArtNr,
it.articleName,
it.count,
it.vpe,
it.unit,
it.mwst,
it.eknetto,
]);
// Column widths
const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i] ?? '').length)));
const fmtRow = (cells) => cells.map((c, i) => String(c ?? '').padEnd(widths[i])).join(' ');
lines.push(fmtRow(headers));
lines.push(widths.map((w) => '-'.repeat(w)).join(' '));
for (const r of rows) lines.push(fmtRow(r));
const outFile = path.resolve(__dirname, 'outputTable.txt');
fs.writeFileSync(outFile, lines.join('\n') + '\n');
console.log(`\n📄 Wrote ${outFile}`);
}
// ─── Write verification JSON ────────────────────────────────────────────────────
// Manifest Nr, Manifest Type, and items (without article name / date) for
// verification. If the file already exists, report whether it is identical.
function writeVerificationJson() {
const payload = {
manifestNr: manifestBasedata.manifestNr,
manifestType: manifestBasedata.manifestType,
items: manifestItems.items.map((it) => ({
position: it.position,
liefArtNr: it.liefArtNr,
count: it.count,
vpe: it.vpe,
mwst: it.mwst,
eknetto: it.eknetto,
})),
};
const outFile = path.resolve(__dirname, 'outputVerification.json');
const json = JSON.stringify(payload, null, 2) + '\n';
if (fs.existsSync(outFile)) {
const existing = fs.readFileSync(outFile, 'utf8');
if (existing === json) {
console.log(`\n✅ ${outFile} already exists and is identical.`);
} else {
console.log(`\n⚠️ ${outFile} already exists but DIFFERS from the new result.`);
printJsonDiff(existing, json);
}
} else {
fs.writeFileSync(outFile, json);
console.log(`\n📄 Wrote ${outFile}`);
}
}
// ─── Print a structured diff between two verification JSONs ─────────────────────
// Parses both and compares item-by-item (keyed by position), showing the item's
// article number and exactly which fields differ.
function printJsonDiff(oldStr, newStr) {
let oldObj, newObj;
try {
oldObj = JSON.parse(oldStr);
newObj = JSON.parse(newStr);
} catch {
// Fall back to a plain line diff if JSON parsing fails.
const oldLines = oldStr.split('\n');
const newLines = newStr.split('\n');
const max = Math.max(oldLines.length, newLines.length);
console.log(`\n${'─'.repeat(60)}`);
for (let i = 0; i < max; i++) {
const a = oldLines[i];
const b = newLines[i];
if (a === b) continue;
if (a === undefined) console.log(` ${' '.repeat(3)}${b}`);
else if (b === undefined) console.log(`- ${a}`);
else { console.log(`- ${a}`); console.log(`+ ${b}`); }
}
console.log(`${'─'.repeat(60)}`);
return;
}
console.log(`\n${'─'.repeat(60)}`);
// Top-level scalar fields
for (const key of ['manifestNr', 'manifestType']) {
if (oldObj[key] !== newObj[key]) {
console.log(`${key}: ${JSON.stringify(oldObj[key])} -> ${JSON.stringify(newObj[key])}`);
}
}
// Items, keyed by position
const oldItems = new Map((oldObj.items || []).map((it) => [it.position, it]));
const newItems = new Map((newObj.items || []).map((it) => [it.position, it]));
const allPositions = new Set([...oldItems.keys(), ...newItems.keys()]);
for (const pos of [...allPositions].sort((a, b) => a - b)) {
const o = oldItems.get(pos);
const n = newItems.get(pos);
if (!o) {
console.log(`+ item ${pos} (${n.liefArtNr}) ADDED`);
continue;
}
if (!n) {
console.log(`- item ${pos} (${o.liefArtNr}) REMOVED`);
continue;
}
const diffs = [];
for (const key of ['liefArtNr', 'count', 'vpe', 'mwst', 'eknetto']) {
if (o[key] !== n[key]) diffs.push(`${key}: ${JSON.stringify(o[key])} -> ${JSON.stringify(n[key])}`);
}
if (diffs.length) {
console.log(`item ${pos} (${n.liefArtNr}):`);
for (const d of diffs) console.log(` ${d}`);
}
}
console.log(`${'─'.repeat(60)}`);
}
// ─── Main ───────────────────────────────────────────────────────────────────────
async function main() {
console.log(`Reading PDF: ${pdfPath}`);
const pages = readPdfPages(pdfPath);
console.log(`Found ${pages.length} page(s).\n`);
const provider = new OpenRouterProvider({ apiKey });
let llmCallStart = null;
const orbiter = new LLMOrbiter(provider, {
onLLMCall: (call) => {
llmCallStart = Date.now();
console.log(`🤖 LLM call: model="${call.model}" promptSize=${call.promptSize} messages=${call.messages}`);
},
onStatus: (status) => console.log(`⚡ ${status}`),
onToolCall: (call) => {
console.log(`🔧 Tool called: ${call.name}(${JSON.stringify(call.args)})`);
logEntry(`TOOL CALL ${call.name}`, call.args);
},
onToolResult: (res) => logEntry(`TOOL RESULT ${res.name}`, res.result),
onToolError: (err) => logEntry(`TOOL ERROR ${err.name}`, err.error),
onUsage: (usage) => {
const elapsed = llmCallStart != null ? ((Date.now() - llmCallStart) / 1000).toFixed(3) : '?';
console.log(`📊 usage: in=${usage.input} cached=${usage.cached} out=${usage.output} cost=${usage.cost} (${elapsed}s)`);
},
});
// Feed pages through LLMOrbiter. If there are fewer than 5 pages, process all
// of them in a single run; otherwise batch them 3 pages per call.
const batchSize = pages.length;//< 5 ? pages.length : 3;
const numBatches = Math.ceil(pages.length / batchSize);
for (let b = 0; b < numBatches; b++) {
const start = b * batchSize;
const end = Math.min(start + batchSize, pages.length);
const batchPages = pages.slice(start, end);
const firstPage = start + 1;
const lastPage = end;
currentPage = firstPage;
console.log(`\n▸ Processing pages ${firstPage}-${lastPage}/${pages.length}...`);
const itemPages = manifestItems.pagesFrom != null
? `page ${manifestItems.pagesFrom} to ${manifestItems.pagesTo}`
: 'no items yet';
const pageContent = batchPages
.map((p, idx) => `--- Page ${firstPage + idx} of ${pages.length} ---\n${p}`)
.join('\n\n');
const prompt = `${BASE_PROMPT}
You are currently processing pages ${firstPage} to ${lastPage} of ${pages.length}.
Current manifest_basedata (fill in what is still missing):
${JSON.stringify(manifestBasedata, null, 2)}
Current notes (add only NEW notes not already present):
${JSON.stringify(manifestNotes, null, 2)}
Current manifest_items (add only NEW items not already present; current items are from ${itemPages}):
${JSON.stringify(manifestItems, null, 2)}
Page content (pages ${firstPage} to ${lastPage} of ${pages.length}):
${pageContent}`;
logPrompt(prompt);
const result = await orbiter.run({
prompt,
model,
tools: [outputManifestTool],
});
logEntry(`LLM OUTPUT pages ${firstPage}-${lastPage}`, result.content);
// The tool throws DirectReturnError to stop the loop and hand back the
// accumulated data. If that happened, we're done — no more batches.
if (result.directReturn) {
console.log(`\n⏹️ Direct return after pages ${firstPage}-${lastPage}.`);
break;
}
}
console.log('\n✅ Done.');
writeOutputTable();
writeVerificationJson();
}
main().catch((err) => {
console.error('FATAL:', err);
process.exit(1);
});

141
examples/tool-error-retry.js Normal file
View File

@@ -0,0 +1,141 @@
'use strict';
/**
* Example & Test: Tool error handling and LLM self-correction
*
* Demonstrates:
* 1. A tool throwing an Error (e.g. invalid parameter format).
* 2. LLMOrbiter catching the error, emitting a 'tool_error' event, and
* formatting the error back to the LLM in the tool message.
* 3. The LLM inspecting the error feedback and retrying the tool call with corrected arguments.
* 4. Successful run completion.
*
* Usage:
* node examples/tool-error-retry.js
* node examples/tool-error-retry.js --model deepseek/deepseek-v4-flash-0731
*/
import path from 'path';
import { fileURLToPath } from 'url';
import dotenv from 'dotenv';
import { LLMOrbiter, OpenRouterProvider, defineTool, ToolError } from '../src/index.js';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
dotenv.config({ path: path.resolve(__dirname, '.env') });
const args = process.argv.slice(2);
function getArg(flag) {
const idx = args.indexOf(flag);
return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
}
const apiKey = getArg('--key') || process.env.OPENROUTER_API_KEY;
const model = getArg('--model') || 'deepseek/deepseek-v4-flash-0731';
if (!apiKey) {
console.error('Error: Missing API key. Set OPENROUTER_API_KEY in examples/.env or pass --key <api-key>');
process.exit(1);
}
// ─── Tool with error throwing ───────────────────────────────────────────────────
let callCount = 0;
const orderLookupTool = defineTool({
name: 'lookup_order',
description: 'Look up an order by order ID.',
parameters: {
type: 'object',
required: ['orderId'],
additionalProperties: false,
properties: {
orderId: {
type: 'string',
description: 'The order ID to check',
},
},
},
invoke: async ({ orderId }) => {
callCount++;
// Enforce the requirement that order IDs must start with "ORD-"
if (!orderId.startsWith('ORD-')) {
throw new ToolError(
`Invalid order ID "${orderId}". Order IDs must start with the prefix "ORD-", e.g. "ORD-${orderId}". Please correct the ID and retry.`
);
}
return {
orderId,
status: 'Delivered',
item: 'Mechanical Keyboard',
trackingNumber: 'TRK-98765432',
};
},
});
// ─── Main ───────────────────────────────────────────────────────────────────────
async function main() {
console.log('🧪 Starting Tool Error & Retry Test...\n');
const provider = new OpenRouterProvider({ apiKey });
const events = [];
const orbiter = new LLMOrbiter(provider, {
onStatus: (status) => {
events.push({ type: 'status', data: status });
console.log(`⚡ ${status}`);
},
onToolCall: (call) => {
events.push({ type: 'tool_call', data: call });
console.log(`🔧 Tool call: ${call.name}(${JSON.stringify(call.args)})`);
},
onToolError: (err) => {
events.push({ type: 'tool_error', data: err });
console.log(`❌ Tool error:`, err.error);
},
onToolResult: (res) => {
events.push({ type: 'tool_result', data: res });
console.log(`📦 Tool result:`, res.result);
},
onUsage: (usage) => {
events.push({ type: 'usage', data: usage });
console.log(`📊 LLM call usage:`, usage);
},
});
const result = await orbiter.run({
prompt: 'Please check the status of order 54321. If the tool reports an error, fix the ID according to the error message and call the tool again.',
model,
tools: [orderLookupTool],
});
console.log('\n💬 Final Response:\n', result.content);
// ─── Test Assertions ─────────────────────────────────────────────────────────
console.log('\n─── Test Results ───');
const errorEvent = events.find((e) => e.type === 'tool_error');
const resultEvent = events.find((e) => e.type === 'tool_result');
const toolCalls = events.filter((e) => e.type === 'tool_call');
const hasError = !!errorEvent;
const hasRetry = toolCalls.length >= 2;
const hasResult = !!resultEvent;
const hasContent = !!result.content;
console.log(hasError ? '✅ PASS: Tool error was thrown and caught' : '❌ FAIL: Tool error was not emitted');
console.log(hasRetry ? '✅ PASS: LLM called the tool again with correction' : '❌ FAIL: Tool was not called again');
console.log(hasResult ? '✅ PASS: Corrected tool call succeeded' : '❌ FAIL: Tool never succeeded');
console.log(hasContent ? '✅ PASS: LLM generated final answer from result' : '❌ FAIL: No final response');
if (hasError && hasRetry && hasResult && hasContent) {
console.log('\n🎉 ALL TESTS PASSED: Tool error and retry workflow verified successfully!\n');
} else {
console.error('\n⚠️ Some assertions failed.\n');
process.exitCode = 1;
}
}
main().catch(console.error);

56
examples/tools/weather.js Normal file
View File

@@ -0,0 +1,56 @@
'use strict';
import { defineTool } from '../../src/index.js';
/**
* Weather tool — returns static weather data for demo/testing.
*/
const weatherTool = defineTool({
name: 'get_weather',
description: 'Get the current weather for a given city.',
parameters: {
type: 'object',
additionalProperties: false,
required: ['city'],
properties: {
city: {
type: 'string',
description: 'City name, e.g. "Berlin"',
},
unit: {
type: 'string',
enum: ['celsius', 'fahrenheit'],
description: 'Temperature unit (default: celsius)',
},
},
},
invoke: async ({ city, unit = 'celsius' }) => {
const db = {
berlin: { temp: 18, condition: 'partly cloudy', humidity: 62 },
munich: { temp: 22, condition: 'sunny', humidity: 45 },
hamburg: { temp: 15, condition: 'rainy', humidity: 80 },
london: { temp: 14, condition: 'overcast', humidity: 75 },
paris: { temp: 20, condition: 'sunny', humidity: 50 },
tokyo: { temp: 28, condition: 'humid', humidity: 85 },
'new york': { temp: 25, condition: 'clear', humidity: 55 },
};
const entry = db[city.toLowerCase()];
if (!entry) {
const available = Object.keys(db).map((c) => `"${c}"`).join(', ');
throw new Error(`City "${city}" not found in database. Available cities are: ${available}.`);
}
let temp = entry.temp;
if (unit === 'fahrenheit') temp = Math.round(temp * 9 / 5 + 32);
return {
city,
temperature: temp,
unit,
condition: entry.condition,
humidity: entry.humidity,
};
},
});
export { weatherTool };

60
examples/weather.js Normal file
View File

@@ -0,0 +1,60 @@
'use strict';
/**
* Example: Weather lookup
*
* Demonstrates basic tool-calling with llmorbiter.
* The LLM is given a weather tool and asked about the weather in a city.
*
* Usage:
* OPENROUTER_API_KEY=sk-or-... node examples/weather.js
* node examples/weather.js --key sk-or-... --city Tokyo
*/
import path from 'path';
import { fileURLToPath } from 'url';
import dotenv from 'dotenv';
import { LLMOrbiter, OpenRouterProvider } from '../src/index.js';
import { weatherTool } from './tools/weather.js';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
dotenv.config({ path: path.resolve(__dirname, '.env') });
const args = process.argv.slice(2);
function getArg(flag) {
const idx = args.indexOf(flag);
return idx !== -1 && args[idx + 1] ? args[idx + 1] : null;
}
const apiKey = getArg('--key') || process.env.OPENROUTER_API_KEY;
const model = getArg('--model') || 'deepseek/deepseek-v4-flash-0731';
const city = getArg('--city') || 'Berlin';
if (!apiKey) {
console.error('Error: Missing API key. Set OPENROUTER_API_KEY in examples/.env or pass --key <api-key>');
process.exit(1);
}
async function main() {
const provider = new OpenRouterProvider({ apiKey });
const orbiter = new LLMOrbiter(provider, {
onLLMCall: (call) => console.log(`🤖 LLM call: model="${call.model}" tools=${call.toolCount} promptSize=${call.promptSize} messages=${call.messages}`),
onStatus: (status) => console.log(`⚡ ${status}`),
onToolCall: (call) => console.log(`🔧 Tool called: ${call.name}(${JSON.stringify(call.args)})`),
onToolError: (err) => console.log(`❌ Tool error:`, err.error),
onToolResult: (res) => console.log(`📦 Tool result:`, res.result),
onUsage: (usage) => console.log(`📊 LLM call usage:`, usage),
});
const result = await orbiter.run({
prompt: `What's the weather like in ${city}?`,
model,
tools: [weatherTool],
});
console.log('\n💬 Response:', result.content);
}
main().catch(console.error);