synthos 0.10.1 → 0.11.1

package/src/service/useExtractRoutes.ts

@@ -0,0 +1,331 @@
+import { Application } from 'express';
+import express from 'express';
+import path from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import { SynthOSConfig } from '../init';
+import { createCompletePrompt } from './createCompletePrompt';
+import { loadSettings, getModelEntry } from '../settings';
+import { ContentBlock } from '../models';
+
+const DEFAULT_PROMPT = `You are a data extraction service. The user has provided a file. Extract the requested fields and return JSON matching the provided schema exactly. If a field is not present in the file, omit it unless it is required by the schema, in which case use the closest reasonable value. Do not include explanatory prose — return only the JSON object.`;
+
+const MAX_FILE_BYTES = 50 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 120_000;
+const MAX_TIMEOUT_MS = 300_000;
+const MIN_TIMEOUT_MS = 1_000;
+
+const TEXT_MIMES = new Set([
+    'application/json',
+    'application/xml',
+    'application/yaml',
+    'application/x-yaml',
+    'application/javascript',
+    'application/typescript',
+    'application/x-www-form-urlencoded',
+]);
+
+const IMAGE_MIMES = new Set([
+    'image/png',
+    'image/jpeg',
+    'image/jpg',
+    'image/webp',
+    'image/gif',
+]);
+
+function isTextMime(mime: string): boolean {
+    return mime.startsWith('text/') || TEXT_MIMES.has(mime);
+}
+
+function isImageMime(mime: string): boolean {
+    return IMAGE_MIMES.has(mime);
+}
+
+function isPdfMime(mime: string): boolean {
+    return mime === 'application/pdf';
+}
+
+function isValidSchema(s: unknown): s is Record<string, unknown> {
+    return !!s && typeof s === 'object' && !Array.isArray(s);
+}
+
+function pageFilesFolder(config: SynthOSConfig, page: string): string {
+    return path.join(config.pagesFolder, 'pages', page, 'files');
+}
+
+function safeFilenameInPageDir(config: SynthOSConfig, page: string, filename: string): string | null {
+    if (!filename || filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+        return null;
+    }
+    const folder = pageFilesFolder(config, page);
+    const resolved = path.resolve(folder, filename);
+    if (!resolved.startsWith(path.resolve(folder))) return null;
+    return resolved;
+}
+
+export function useExtractRoutes(config: SynthOSConfig, app: Application): void {
+    const sp = config.storageProvider;
+
+    // 50 MB raw → ~67 MB base64; allow ~70 MB JSON envelope.
+    app.post('/api/extract', express.json({ limit: '70mb' }), async (req, res) => {
+        try {
+            const body = (req.body ?? {}) as Record<string, unknown>;
+            const page = typeof body.page === 'string' ? body.page : '';
+            const filename = typeof body.filename === 'string' ? body.filename : '';
+            const mimeType = typeof body.mimeType === 'string' ? body.mimeType : '';
+            const data = typeof body.data === 'string' ? body.data : '';
+            const schema = body.schema;
+            const userPromptIn = typeof body.prompt === 'string' && body.prompt.length > 0 ? body.prompt : DEFAULT_PROMPT;
+            const modelOverride = typeof body.model === 'string' && body.model.length > 0 ? body.model : undefined;
+            const persist = body.persist === true;
+            const timeoutIn = typeof body.timeout === 'number' && Number.isFinite(body.timeout) ? body.timeout : DEFAULT_TIMEOUT_MS;
+            const timeoutMs = Math.min(Math.max(timeoutIn, MIN_TIMEOUT_MS), MAX_TIMEOUT_MS);
+
+            // ---- request validation ----
+            if (!page) {
+                res.status(400).json({ error: 'invalid_request', message: 'page is required' });
+                return;
+            }
+            if (!filename) {
+                res.status(400).json({ error: 'invalid_request', message: 'filename is required' });
+                return;
+            }
+            if (!mimeType) {
+                res.status(400).json({ error: 'invalid_request', message: 'mimeType is required' });
+                return;
+            }
+            if (!data) {
+                res.status(400).json({ error: 'invalid_request', message: 'data (base64) is required' });
+                return;
+            }
+            if (!isValidSchema(schema)) {
+                res.status(400).json({ error: 'malformed_schema', message: 'schema must be a JSON Schema object' });
+                return;
+            }
+
+            // ---- decode + size check ----
+            let buffer: Buffer;
+            try {
+                buffer = Buffer.from(data, 'base64');
+            } catch {
+                res.status(400).json({ error: 'invalid_request', message: 'data must be valid base64' });
+                return;
+            }
+            if (buffer.length === 0) {
+                res.status(400).json({ error: 'invalid_request', message: 'data decoded to empty buffer' });
+                return;
+            }
+            if (buffer.length > MAX_FILE_BYTES) {
+                res.status(413).json({
+                    error: 'oversize',
+                    message: `File exceeds 50 MB limit (${buffer.length} bytes)`,
+                });
+                return;
+            }
+
+            // ---- resolve active model ----
+            const settings = await loadSettings(config);
+            const entry = getModelEntry(settings, 'chat');
+            const provider = entry.provider;
+            const modelUsed = modelOverride ?? entry.configuration.model;
+
+            // ---- routing ----
+            const isText = isTextMime(mimeType);
+            const isImage = isImageMime(mimeType);
+            const isPdf = isPdfMime(mimeType);
+
+            if (!isText && !isImage && !isPdf) {
+                res.status(415).json({
+                    error: 'unsupported_file_type',
+                    message: `MIME type "${mimeType}" is not supported in v1.`,
+                    modelUsed,
+                });
+                return;
+            }
+            if (provider === 'ClaudeCode') {
+                res.status(415).json({
+                    error: 'unsupported_file_type',
+                    message: `The "ClaudeCode" provider is not supported by /api/extract in v1. Switch to a direct Anthropic, OpenAI, or FireworksAI chat model.`,
+                    modelUsed,
+                });
+                return;
+            }
+            if (isImage && provider === 'FireworksAI') {
+                res.status(415).json({
+                    error: 'unsupported_file_type',
+                    message: `The active model "${modelUsed}" cannot read images. Switch to a Claude or GPT model.`,
+                    modelUsed,
+                });
+                return;
+            }
+            if (isPdf && provider !== 'Anthropic') {
+                res.status(415).json({
+                    error: 'unsupported_file_type',
+                    message: `PDF extraction requires a Claude (Anthropic) model. The active model is "${modelUsed}".`,
+                    modelUsed,
+                });
+                return;
+            }
+            if (!entry.configuration.apiKey) {
+                res.status(500).json({
+                    error: 'invalid_request',
+                    message: 'API key not configured for the active chat model.',
+                    modelUsed,
+                });
+                return;
+            }
+
+            // ---- optional persist ----
+            let savedFile: { name: string; size: number; url: string } | undefined;
+            if (persist) {
+                const filePath = safeFilenameInPageDir(config, page, filename);
+                if (!filePath) {
+                    res.status(400).json({ error: 'invalid_request', message: 'invalid filename for persist' });
+                    return;
+                }
+                await sp.ensureFolderExists(pageFilesFolder(config, page));
+                await sp.saveBuffer(filePath, buffer);
+                savedFile = {
+                    name: filename,
+                    size: buffer.length,
+                    url: `/api/files/${encodeURIComponent(page)}/${encodeURIComponent(filename)}`,
+                };
+            }
+
+            // ---- run extraction with timeout ----
+            const runP: Promise<string> = (async () => {
+                if (isPdf) {
+                    return await extractPdfWithAnthropic({
+                        apiKey: entry.configuration.apiKey!,
+                        model: modelUsed,
+                        filename,
+                        base64: buffer.toString('base64'),
+                        userPrompt: userPromptIn,
+                        schema: schema as Record<string, unknown>,
+                    });
+                }
+
+                const completePromptFn = await createCompletePrompt(config, 'chat', modelOverride);
+
+                if (isText) {
+                    const textBody = buffer.toString('utf8');
+                    const fullText =
+                        `Filename: ${filename}\nMIME type: ${mimeType}\n\n--- FILE CONTENTS ---\n${textBody}\n--- END FILE CONTENTS ---\n\n${userPromptIn}`;
+                    const result = await completePromptFn({
+                        system: { role: 'system', content: DEFAULT_PROMPT },
+                        prompt: { role: 'user', content: fullText },
+                        outputSchema: schema as Record<string, unknown>,
+                        jsonSchema: schema as Record<string, unknown>,
+                    });
+                    if (!result.completed) throw result.error ?? new Error('extraction failed');
+                    return result.value ?? '';
+                }
+
+                // image branch (Anthropic | OpenAI)
+                const promptContent: ContentBlock[] = [
+                    { type: 'image', mediaType: mimeType, data: buffer.toString('base64') },
+                    { type: 'text', text: `Filename: ${filename}\n\n${userPromptIn}` },
+                ];
+                const result = await completePromptFn({
+                    system: { role: 'system', content: DEFAULT_PROMPT },
+                    prompt: { role: 'user', content: promptContent },
+                    outputSchema: schema as Record<string, unknown>,
+                    jsonSchema: schema as Record<string, unknown>,
+                });
+                if (!result.completed) throw result.error ?? new Error('extraction failed');
+                return result.value ?? '';
+            })();
+
+            let raw: string;
+            try {
+                raw = await Promise.race([
+                    runP,
+                    new Promise<string>((_resolve, reject) =>
+                        setTimeout(() => reject(new Error('extraction timed out')), timeoutMs),
+                    ),
+                ]);
+            } catch (err) {
+                const msg = (err as Error).message ?? 'unknown error';
+                if (/timed out/i.test(msg)) {
+                    res.status(504).json({ error: 'timeout', message: msg, modelUsed });
+                    return;
+                }
+                console.error('EXTRACT ERROR:', msg);
+                res.status(502).json({ error: 'extraction_failed', message: msg, modelUsed });
+                return;
+            }
+
+            // ---- parse + return ----
+            let parsed: unknown;
+            try {
+                parsed = JSON.parse(raw);
+            } catch (err) {
+                console.error('EXTRACT PARSE ERROR:', (err as Error).message, '| raw head:', raw.slice(0, 500));
+                res.status(502).json({
+                    error: 'extraction_failed',
+                    message: `Model response was not valid JSON: ${(err as Error).message}`,
+                    modelUsed,
+                });
+                return;
+            }
+
+            const responsePayload: Record<string, unknown> = { data: parsed, modelUsed };
+            if (savedFile) responsePayload.savedFile = savedFile;
+            res.json(responsePayload);
+        } catch (err: unknown) {
+            console.error('EXTRACT ERROR:', (err as Error).message);
+            res.status(500).json({ error: 'internal_error', message: (err as Error).message });
+        }
+    });
+}
+
+interface AnthropicPdfArgs {
+    apiKey: string;
+    model: string;
+    filename: string;
+    base64: string;
+    userPrompt: string;
+    schema: Record<string, unknown>;
+}
+
+/**
+ * Direct Anthropic SDK call for PDF extraction. Streams with a raw iterator —
+ * structured-output deltas may arrive as input_json_delta, not text_delta.
+ */
+async function extractPdfWithAnthropic(args: AnthropicPdfArgs): Promise<string> {
+    const client = new Anthropic({ apiKey: args.apiKey });
+
+    const userContent: Anthropic.ContentBlockParam[] = [
+        {
+            type: 'document',
+            source: { type: 'base64', media_type: 'application/pdf', data: args.base64 },
+            title: args.filename,
+        },
+        { type: 'text', text: `Filename: ${args.filename}\n\n${args.userPrompt}` },
+    ];
+
+    const params: Anthropic.MessageCreateParamsStreaming = {
+        model: args.model,
+        max_tokens: 32768,
+        temperature: 0,
+        system: DEFAULT_PROMPT,
+        messages: [{ role: 'user', content: userContent }],
+        stream: true,
+        output_config: { format: { type: 'json_schema', schema: args.schema } },
+    };
+
+    const stream = await client.messages.create(params);
+    const textByIndex = new Map<number, string>();
+    for await (const event of stream) {
+        if (event.type === 'content_block_delta') {
+            if (event.delta.type === 'text_delta') {
+                textByIndex.set(event.index, (textByIndex.get(event.index) ?? '') + event.delta.text);
+            } else if (event.delta.type === 'input_json_delta') {
+                textByIndex.set(event.index, (textByIndex.get(event.index) ?? '') + event.delta.partial_json);
+            }
+        }
+    }
+    return Array.from(textByIndex.entries())
+        .sort(([a], [b]) => a - b)
+        .map(([, v]) => v)
+        .join('');
+}