|
|
|
|
@@ -1,593 +0,0 @@
|
|
|
|
|
'use strict';
|
|
|
|
|
|
|
|
|
|
import { execFileSync } from 'child_process';
|
|
|
|
|
import multer from 'multer';
|
|
|
|
|
import { LLMOrbiter, OpenRouterProvider, defineTool, DirectReturnError } from 'libllmorbiter';
|
|
|
|
|
import * as dbCompanySetting from '../../db/companysetting.js';
|
|
|
|
|
import * as dbSupplier from '../../db/supplier.js';
|
|
|
|
|
import env from '../../config/env.js';
|
|
|
|
|
import { resolveDefaultModel } from '../../tools/llm-key.js';
|
|
|
|
|
|
|
|
|
|
// #region Helpers
|
|
|
|
|
|
|
|
|
|
// ─── Multer — memory storage (no temp files); accepts PDF or text ───────────────
|
|
|
|
|
const upload = multer({
|
|
|
|
|
storage: multer.memoryStorage(),
|
|
|
|
|
limits: { fileSize: 50 * 1024 * 1024 }, // 50 MB
|
|
|
|
|
fileFilter: (_req, file, cb) => {
|
|
|
|
|
const name = file.originalname?.toLowerCase() || '';
|
|
|
|
|
const isPdf = file.mimetype === 'application/pdf' || name.endsWith('.pdf');
|
|
|
|
|
const isText =
|
|
|
|
|
file.mimetype.startsWith('text/') ||
|
|
|
|
|
/\.(txt|text|md|csv|log|json)$/.test(name);
|
|
|
|
|
if (isPdf || isText) {
|
|
|
|
|
cb(null, true);
|
|
|
|
|
} else {
|
|
|
|
|
cb(new Error('Only PDF or text files are accepted'));
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
/** Detects whether an uploaded file is a PDF (else treated as text). */
|
|
|
|
|
function isPdfUpload(file) {
|
|
|
|
|
const name = file.originalname?.toLowerCase() || '';
|
|
|
|
|
return file.mimetype === 'application/pdf' || name.endsWith('.pdf');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ─── SSE helpers ────────────────────────────────────────────────────────────────
|
|
|
|
|
function sseWrite(res, event, data) {
|
|
|
|
|
if (res.writableEnded || res.destroyed) return;
|
|
|
|
|
res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ─── PDF → pages via pdftotext ──────────────────────────────────────────────────
|
|
|
|
|
function readPdfPages(buffer) {
|
|
|
|
|
// Write buffer to stdin by passing '-' as output and reading from stdin via
|
|
|
|
|
// execFileSync input option. pdftotext reads from '-' for stdin.
|
|
|
|
|
const raw = execFileSync('pdftotext', ['-layout', '-', '-'], {
|
|
|
|
|
input: buffer,
|
|
|
|
|
encoding: 'utf8',
|
|
|
|
|
maxBuffer: 50 * 1024 * 1024,
|
|
|
|
|
});
|
|
|
|
|
return raw
|
|
|
|
|
.split('\f')
|
|
|
|
|
.map((p) => p.trim())
|
|
|
|
|
.filter((p) => p.length > 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ─── Text → pages split by form feed (same convention as pdftotext) ─────────────
|
|
|
|
|
function readTxtPages(textOrBuffer) {
|
|
|
|
|
const text = Buffer.isBuffer(textOrBuffer) ? textOrBuffer.toString('utf8') : String(textOrBuffer);
|
|
|
|
|
return text
|
|
|
|
|
.split('\f')
|
|
|
|
|
.map((p) => p.trim())
|
|
|
|
|
.filter((p) => p.length > 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ─── 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 lieferant_id and lieferantName. For unknown suppliers, extract lieferantName and set lieferant_id 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 means 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).`;
|
|
|
|
|
|
|
|
|
|
function buildSystemPrompt(suppliers = []) {
|
|
|
|
|
const supplierList = suppliers.length > 0
|
|
|
|
|
? suppliers.map((s) => `${s.id} | ${s.name}`).join('\n')
|
|
|
|
|
: '(no suppliers registered)';
|
|
|
|
|
|
|
|
|
|
return `${BASE_PROMPT}
|
|
|
|
|
|
|
|
|
|
Suppliers (lieferant_id | lieferant_name):
|
|
|
|
|
${supplierList}`;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ─── Shared SSE manifest extraction (POST /delivery/parse) ─────────────────────
|
|
|
|
|
/**
|
|
|
|
|
* Fetches the OpenRouter API key, opens the SSE stream, and runs the LLM
|
|
|
|
|
* manifest extraction over the given pages. Closes the stream when done.
|
|
|
|
|
*
|
|
|
|
|
* @param {object} opts
|
|
|
|
|
* @param {import('express').Request} opts.req
|
|
|
|
|
* @param {import('express').Response} opts.res
|
|
|
|
|
* @param {string[]} opts.pages Trimmed, non-empty document pages
|
|
|
|
|
* @param {string} opts.sourceLabel e.g. 'PDF' or 'Text'
|
|
|
|
|
*/
|
|
|
|
|
async function parseDocumentManifest({ req, res, pages, sourceLabel }) {
|
|
|
|
|
// ── Fetch OpenRouter API key from company settings (or fallback) ──
|
|
|
|
|
let apiKey;
|
|
|
|
|
try {
|
|
|
|
|
const setting = await dbCompanySetting.getByKey(req.user.id, 'keys.openrouter', { maskWriteonly: false });
|
|
|
|
|
apiKey = setting?.value?.trim();
|
|
|
|
|
} catch (err) {
|
|
|
|
|
console.error('delivery parse: failed to read OpenRouter key:', err);
|
|
|
|
|
}
|
|
|
|
|
if (!apiKey) {
|
|
|
|
|
apiKey = env.openrouterFreeKey?.trim();
|
|
|
|
|
if (apiKey) {
|
|
|
|
|
console.log('delivery parse: using fallback OPENROUTER_FREE_KEY');
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!apiKey) {
|
|
|
|
|
return res.status(400).json({ error: 'OpenRouter API key not configured (companysetting: keys.openrouter)' });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ── Fetch suppliers from Lieferanten group ────────────────────────
|
|
|
|
|
let suppliers = [];
|
|
|
|
|
try {
|
|
|
|
|
suppliers = await dbSupplier.list(req.user.id);
|
|
|
|
|
} catch (err) {
|
|
|
|
|
console.warn('delivery parse: failed to list suppliers:', err?.message || err);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ── Open SSE stream ──────────────────────────────────────────────
|
|
|
|
|
res.setHeader('Content-Type', 'text/event-stream');
|
|
|
|
|
res.setHeader('Cache-Control', 'no-cache');
|
|
|
|
|
res.setHeader('Connection', 'keep-alive');
|
|
|
|
|
res.flushHeaders();
|
|
|
|
|
|
|
|
|
|
sseWrite(res, 'status', { message: `${sourceLabel} parsed: ${pages.length} page(s)` });
|
|
|
|
|
|
|
|
|
|
// ── Accumulated state ────────────────────────────────────────────
|
|
|
|
|
const manifestBasedata = {
|
|
|
|
|
date: null,
|
|
|
|
|
lieferant_id: null,
|
|
|
|
|
lieferantName: null,
|
|
|
|
|
manifestNr: null,
|
|
|
|
|
manifestType: null,
|
|
|
|
|
};
|
|
|
|
|
const manifestNotes = [];
|
|
|
|
|
const manifestItems = { items: [], pagesFrom: null, pagesTo: null };
|
|
|
|
|
let currentPage = 0;
|
|
|
|
|
|
|
|
|
|
// ── Tool definition ──────────────────────────────────────────────
|
|
|
|
|
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)' },
|
|
|
|
|
lieferant_id: { 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.',
|
|
|
|
|
},
|
|
|
|
|
items: {
|
|
|
|
|
anyOf: [
|
|
|
|
|
{
|
|
|
|
|
type: 'object',
|
|
|
|
|
additionalProperties: false,
|
|
|
|
|
properties: {
|
|
|
|
|
numberOfItemsToAdd: { type: 'number', description: 'Number of NEW line items being added in this call.' },
|
|
|
|
|
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.' },
|
|
|
|
|
unit: { type: 'string', description: 'Unit of the individual sellable item. NEVER "VE" or "VPE".' },
|
|
|
|
|
articleName: { type: 'string', description: 'Article name' },
|
|
|
|
|
liefArtNr: { type: 'string', description: 'Supplier article number' },
|
|
|
|
|
mwst: {
|
|
|
|
|
anyOf: [{ type: 'string', enum: ['7', '19'] }, { type: 'null' }],
|
|
|
|
|
description: 'VAT rate; null if missing',
|
|
|
|
|
},
|
|
|
|
|
eknetto: { type: ['number', 'null'], description: 'Net price per vpe in euro cents; null if missing' },
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
{ type: 'null' },
|
|
|
|
|
],
|
|
|
|
|
description: 'New product line items.',
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
invoke: async (args) => {
|
|
|
|
|
const basedataKeys = args.basedata && typeof args.basedata === 'object' ? Object.keys(args.basedata) : [];
|
|
|
|
|
const notesCount = Array.isArray(args.notes) ? args.notes.length : 0;
|
|
|
|
|
const itemsCount = args.items?.items && Array.isArray(args.items.items) ? args.items.items.length : 0;
|
|
|
|
|
console.log(`[llmorbiter] Tool invoke output_manifest: basedata=[${basedataKeys.join(', ')}], notes=${notesCount}, items=${itemsCount}`);
|
|
|
|
|
|
|
|
|
|
// Merge basedata
|
|
|
|
|
if (args.basedata && typeof args.basedata === 'object') {
|
|
|
|
|
for (const key of ['date', 'lieferant_id', 'lieferantName', 'manifestNr', 'manifestType']) {
|
|
|
|
|
if (args.basedata[key] != null) manifestBasedata[key] = args.basedata[key];
|
|
|
|
|
}
|
|
|
|
|
if (args.basedata.kLieferant != null && manifestBasedata.lieferant_id == null) {
|
|
|
|
|
manifestBasedata.lieferant_id = args.basedata.kLieferant;
|
|
|
|
|
}
|
|
|
|
|
if (args.basedata.lieferant_name != null && manifestBasedata.lieferantName == null) {
|
|
|
|
|
manifestBasedata.lieferantName = args.basedata.lieferant_name;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// Merge notes
|
|
|
|
|
if (Array.isArray(args.notes)) {
|
|
|
|
|
for (const n of args.notes) {
|
|
|
|
|
if (n && !manifestNotes.includes(n)) manifestNotes.push(n);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
// Merge items
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
const itemPages = manifestItems.items.map((it) => it.page).filter((p) => p != null);
|
|
|
|
|
if (itemPages.length) {
|
|
|
|
|
manifestItems.pagesFrom = Math.min(...itemPages);
|
|
|
|
|
manifestItems.pagesTo = Math.max(...itemPages);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Emit intermediate progress
|
|
|
|
|
sseWrite(res, 'progress', {
|
|
|
|
|
basedata: manifestBasedata,
|
|
|
|
|
notes: manifestNotes,
|
|
|
|
|
items: manifestItems,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
throw new DirectReturnError({
|
|
|
|
|
basedata: manifestBasedata,
|
|
|
|
|
notes: manifestNotes,
|
|
|
|
|
items: manifestItems,
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
// ── LLMOrbiter setup ─────────────────────────────────────────────
|
|
|
|
|
const model = await resolveDefaultModel(req.user.id);
|
|
|
|
|
const provider = new OpenRouterProvider({ apiKey, apiUrl: env.openrouterApiUrl });
|
|
|
|
|
const orbiter = new LLMOrbiter(provider, {
|
|
|
|
|
onStatus: (status) => {
|
|
|
|
|
console.log(`[llmorbiter] Status: ${status}`);
|
|
|
|
|
sseWrite(res, 'status', { message: status });
|
|
|
|
|
},
|
|
|
|
|
onLLMCall: (call) => {
|
|
|
|
|
console.log(
|
|
|
|
|
`[llmorbiter] LLM call (iteration ${call.iteration}): model=${call.model}, promptSize=${call.promptSize} chars, messages=${call.messageCount || call.messages}`
|
|
|
|
|
);
|
|
|
|
|
sseWrite(res, 'llm_call', {
|
|
|
|
|
model: call.model,
|
|
|
|
|
promptSize: call.promptSize,
|
|
|
|
|
messages: call.messages,
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
onToolCall: (call) => {
|
|
|
|
|
const details = [];
|
|
|
|
|
if (call.args?.basedata) details.push(`basedata: [${Object.keys(call.args.basedata).join(', ')}]`);
|
|
|
|
|
if (call.args?.items?.items) details.push(`items: ${call.args.items.items.length}`);
|
|
|
|
|
if (call.args?.notes) details.push(`notes: ${call.args.notes.length}`);
|
|
|
|
|
const suffix = details.length ? ` (${details.join(', ')})` : '';
|
|
|
|
|
console.log(`[llmorbiter] Tool call: ${call.name}${suffix}`);
|
|
|
|
|
sseWrite(res, 'tool_call', { name: call.name });
|
|
|
|
|
},
|
|
|
|
|
onToolResult: (call) => {
|
|
|
|
|
console.log(`[llmorbiter] Tool result: ${call.name}`);
|
|
|
|
|
},
|
|
|
|
|
onToolError: (call) => {
|
|
|
|
|
console.error(`[llmorbiter] Tool error in ${call.name}:`, call.error);
|
|
|
|
|
},
|
|
|
|
|
onUsage: (usage) => {
|
|
|
|
|
const costStr = usage.cost != null ? `, cost=$${usage.cost.toFixed(4)}` : '';
|
|
|
|
|
console.log(
|
|
|
|
|
`[llmorbiter] Usage: input=${usage.input}, cached=${usage.cached}, output=${usage.output}${costStr}`
|
|
|
|
|
);
|
|
|
|
|
sseWrite(res, 'usage', {
|
|
|
|
|
input: usage.input,
|
|
|
|
|
cached: usage.cached,
|
|
|
|
|
output: usage.output,
|
|
|
|
|
cost: usage.cost,
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
const abortController = new AbortController();
|
|
|
|
|
abortController.signal.addEventListener('abort', () => {
|
|
|
|
|
const reason = abortController.signal.reason;
|
|
|
|
|
const msg = reason instanceof Error ? reason.message : String(reason || 'aborted');
|
|
|
|
|
console.log(`[llmorbiter] Abort signal triggered: ${msg}`);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
const originalAbort = orbiter.abort.bind(orbiter);
|
|
|
|
|
orbiter.abort = (reason) => {
|
|
|
|
|
const reasonMsg = reason instanceof Error ? reason.message : String(reason || 'aborted');
|
|
|
|
|
console.log(`[llmorbiter] orbiter.abort() called (reason: ${reasonMsg})`);
|
|
|
|
|
return originalAbort(reason);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const onDisconnect = () => {
|
|
|
|
|
if (!res.writableEnded && !abortController.signal.aborted) {
|
|
|
|
|
console.log('[llmorbiter] Client connection closed, aborting request');
|
|
|
|
|
abortController.abort('Client connection closed');
|
|
|
|
|
orbiter.abort('Client connection closed');
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
res.on('close', onDisconnect);
|
|
|
|
|
|
|
|
|
|
// ── Process all pages in one batch ───────────────────────────────
|
|
|
|
|
try {
|
|
|
|
|
if (res.destroyed || res.writableEnded) {
|
|
|
|
|
console.log('[llmorbiter] Response already closed or destroyed before run, aborting');
|
|
|
|
|
abortController.abort('Response closed before run');
|
|
|
|
|
orbiter.abort('Response closed before run');
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const pageContent = pages
|
|
|
|
|
.map((p, idx) => `--- Page ${idx + 1} of ${pages.length} ---\n${p}`)
|
|
|
|
|
.join('\n\n');
|
|
|
|
|
|
|
|
|
|
const systemPrompt = buildSystemPrompt(suppliers);
|
|
|
|
|
|
|
|
|
|
const prompt = `You are processing all ${pages.length} page(s) of this document.
|
|
|
|
|
|
|
|
|
|
Current manifest_basedata (fill in what is still missing):
|
|
|
|
|
${JSON.stringify(manifestBasedata, null, 2)}
|
|
|
|
|
|
|
|
|
|
Current notes:
|
|
|
|
|
${JSON.stringify(manifestNotes, null, 2)}
|
|
|
|
|
|
|
|
|
|
Current manifest_items:
|
|
|
|
|
${JSON.stringify(manifestItems, null, 2)}
|
|
|
|
|
|
|
|
|
|
Page content:
|
|
|
|
|
${pageContent}`;
|
|
|
|
|
|
|
|
|
|
console.log(`[llmorbiter] Starting run: model=${model}, pages=${pages.length} (${sourceLabel}), suppliers=${suppliers.length}`);
|
|
|
|
|
currentPage = 1;
|
|
|
|
|
await orbiter.run({
|
|
|
|
|
prompt,
|
|
|
|
|
systemPrompt,
|
|
|
|
|
model,
|
|
|
|
|
tools: [outputManifestTool],
|
|
|
|
|
signal: abortController.signal,
|
|
|
|
|
});
|
|
|
|
|
console.log(`[llmorbiter] Run completed successfully. Extracted ${manifestItems.items.length} item(s), ${manifestNotes.length} note(s)`);
|
|
|
|
|
} catch (err) {
|
|
|
|
|
if (err.name === 'AbortError' || abortController.signal.aborted) {
|
|
|
|
|
console.log(`[llmorbiter] Run aborted: ${err.message || abortController.signal.reason?.message || 'AbortError'}`);
|
|
|
|
|
} else {
|
|
|
|
|
console.error('[llmorbiter] Run failed with error:', err);
|
|
|
|
|
}
|
|
|
|
|
if (!res.writableEnded && !res.destroyed) {
|
|
|
|
|
sseWrite(res, 'error', { message: 'LLM processing failed: ' + err.message });
|
|
|
|
|
}
|
|
|
|
|
} finally {
|
|
|
|
|
res.off('close', onDisconnect);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (res.writableEnded || res.destroyed) {
|
|
|
|
|
console.log('[llmorbiter] Response ended or destroyed, skipping final result');
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// ── Final result ─────────────────────────────────────────────────
|
|
|
|
|
console.log(`[llmorbiter] Emitting final result event and closing stream`);
|
|
|
|
|
sseWrite(res, 'result', {
|
|
|
|
|
basedata: manifestBasedata,
|
|
|
|
|
notes: manifestNotes,
|
|
|
|
|
items: manifestItems,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
res.end();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// #endregion
|
|
|
|
|
|
|
|
|
|
// ─── Route ───────────────────────────────────────────────────────────────────────
|
|
|
|
|
/**
|
|
|
|
|
* @param {import('express').Application} app
|
|
|
|
|
* @param {string} [basePath='']
|
|
|
|
|
*/
|
|
|
|
|
export function register(app, basePath = '') {
|
|
|
|
|
/**
|
|
|
|
|
* @openapi
|
|
|
|
|
* /delivery/parse:
|
|
|
|
|
* post:
|
|
|
|
|
* tags: [Delivery]
|
|
|
|
|
* summary: Parse document (SSE)
|
|
|
|
|
* description: |
|
|
|
|
|
* Accepts an invoice or delivery note as PDF or text file
|
|
|
|
|
* (`multipart/form-data`, field `file`) and streams extraction results as
|
|
|
|
|
* Server-Sent Events until parsing is complete.
|
|
|
|
|
*
|
|
|
|
|
* PDFs are read via `pdftotext -layout`; text files are decoded as UTF-8.
|
|
|
|
|
* Pages are separated by the form feed character (`\f`). If no form feed
|
|
|
|
|
* is present, the input is treated as a single page.
|
|
|
|
|
*
|
|
|
|
|
* The extracted pages are fed to an LLM (OpenRouter) which fills a structured
|
|
|
|
|
* manifest of header data and line items. The OpenRouter API key is read from
|
|
|
|
|
* the authenticated user's company setting `keys.openrouter` (or the server's
|
|
|
|
|
* `OPENROUTER_FREE_KEY` if not configured); the endpoint
|
|
|
|
|
* returns `400` if the key is not configured.
|
|
|
|
|
*
|
|
|
|
|
* The stream ends after the final `result` event (or an `error` event on failure).
|
|
|
|
|
* security:
|
|
|
|
|
* - cookieAuth: []
|
|
|
|
|
* x-markdown: delivery/parse.md
|
|
|
|
|
* x-sse-events:
|
|
|
|
|
* - name: status
|
|
|
|
|
* description: Document parse confirmation and LLM status messages
|
|
|
|
|
* payload: '{ "message": "…" }'
|
|
|
|
|
* - name: llm_call
|
|
|
|
|
* description: Fired before each LLM request
|
|
|
|
|
* payload: '{ "model": "…", "promptSize": 0, "messages": 0 }'
|
|
|
|
|
* - name: tool_call
|
|
|
|
|
* description: Fired when the output_manifest tool is invoked
|
|
|
|
|
* payload: '{ "name": "output_manifest" }'
|
|
|
|
|
* - name: usage
|
|
|
|
|
* description: Token usage after each LLM response
|
|
|
|
|
* payload: '{ "input": 0, "cached": 0, "output": 0, "cost": 0 }'
|
|
|
|
|
* - name: progress
|
|
|
|
|
* description: Intermediate accumulated extraction state (basedata / notes / items)
|
|
|
|
|
* payload: ManifestResult
|
|
|
|
|
* - name: result
|
|
|
|
|
* description: Final accumulated extraction — emitted just before the stream closes
|
|
|
|
|
* payload: ManifestResult
|
|
|
|
|
* - name: error
|
|
|
|
|
* description: Emitted on document parse or LLM failure; stream closes immediately after
|
|
|
|
|
* payload: '{ "message": "…" }'
|
|
|
|
|
* requestBody:
|
|
|
|
|
* required: true
|
|
|
|
|
* content:
|
|
|
|
|
* multipart/form-data:
|
|
|
|
|
* schema:
|
|
|
|
|
* type: object
|
|
|
|
|
* required: [file]
|
|
|
|
|
* properties:
|
|
|
|
|
* file:
|
|
|
|
|
* type: string
|
|
|
|
|
* format: binary
|
|
|
|
|
* description: Document to parse (max 50 MB, application/pdf or text file)
|
|
|
|
|
* responses:
|
|
|
|
|
* 200:
|
|
|
|
|
* description: |
|
|
|
|
|
* `text/event-stream` — emits `status`, `llm_call`, `tool_call`, `usage`,
|
|
|
|
|
* `progress`, `result` (and `error` on failure). See SSE Events table below.
|
|
|
|
|
*
|
|
|
|
|
* **ManifestResult shape** (used by `progress` and `result`):
|
|
|
|
|
*
|
|
|
|
|
* ```json
|
|
|
|
|
* {
|
|
|
|
|
* "basedata": {
|
|
|
|
|
* "date": "2026-01-15",
|
|
|
|
|
* "lieferant_id": 42,
|
|
|
|
|
* "lieferantName": "Muster GmbH",
|
|
|
|
|
* "manifestNr": "LS-2026-001",
|
|
|
|
|
* "manifestType": "lieferschein"
|
|
|
|
|
* },
|
|
|
|
|
* "notes": ["Pos. 3: VPE-Angabe fehlte, Standardwert 1 angenommen."],
|
|
|
|
|
* "items": {
|
|
|
|
|
* "pagesFrom": 1,
|
|
|
|
|
* "pagesTo": 2,
|
|
|
|
|
* "items": [
|
|
|
|
|
* {
|
|
|
|
|
* "position": 1,
|
|
|
|
|
* "count": 10,
|
|
|
|
|
* "vpe": 1,
|
|
|
|
|
* "unit": "Stk.",
|
|
|
|
|
* "articleName": "Einhängesieb Stahl",
|
|
|
|
|
* "liefArtNr": "ES-100",
|
|
|
|
|
* "mwst": "19",
|
|
|
|
|
* "eknetto": 450,
|
|
|
|
|
* "page": 1
|
|
|
|
|
* }
|
|
|
|
|
* ]
|
|
|
|
|
* }
|
|
|
|
|
* }
|
|
|
|
|
* ```
|
|
|
|
|
* content:
|
|
|
|
|
* text/event-stream:
|
|
|
|
|
* schema:
|
|
|
|
|
* type: string
|
|
|
|
|
* 400:
|
|
|
|
|
* description: No file uploaded, unsupported file type, or OpenRouter key not configured
|
|
|
|
|
* content:
|
|
|
|
|
* application/json:
|
|
|
|
|
* schema:
|
|
|
|
|
* $ref: '#/components/schemas/Error'
|
|
|
|
|
* 401:
|
|
|
|
|
* description: Unauthorized
|
|
|
|
|
* content:
|
|
|
|
|
* application/json:
|
|
|
|
|
* schema:
|
|
|
|
|
* $ref: '#/components/schemas/Error'
|
|
|
|
|
*/
|
|
|
|
|
// #region POST /delivery/parse
|
|
|
|
|
|
|
|
|
|
app.post(
|
|
|
|
|
`${basePath}/delivery/parse`,
|
|
|
|
|
upload.single('file'),
|
|
|
|
|
async (req, res) => {
|
|
|
|
|
if (!req.file?.buffer) {
|
|
|
|
|
return res.status(400).json({ error: 'A document file is required (field name: file)' });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const sourceLabel = isPdfUpload(req.file) ? 'PDF' : 'Text';
|
|
|
|
|
console.log(`[deliveryParse] Received file "${req.file.originalname}" (${req.file.size} bytes, type=${sourceLabel})`);
|
|
|
|
|
|
|
|
|
|
let pages;
|
|
|
|
|
try {
|
|
|
|
|
pages = sourceLabel === 'PDF' ? readPdfPages(req.file.buffer) : readTxtPages(req.file.buffer);
|
|
|
|
|
} catch (err) {
|
|
|
|
|
console.error(`[deliveryParse] Failed to parse document: ${err.message}`);
|
|
|
|
|
return res.status(400).json({ error: 'Failed to parse document: ' + err.message });
|
|
|
|
|
}
|
|
|
|
|
if (pages.length === 0) {
|
|
|
|
|
console.warn('[deliveryParse] Document content is empty');
|
|
|
|
|
return res.status(400).json({ error: 'Document content is empty' });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
await parseDocumentManifest({
|
|
|
|
|
req,
|
|
|
|
|
res,
|
|
|
|
|
pages,
|
|
|
|
|
sourceLabel,
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
// #endregion
|
|
|
|
|
}
|
seb