@larkup/workspace-server 0.0.0-stage → 0.2.0

package/src/app/api/config/test-embedding/route.ts

@@ -0,0 +1,39 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import { embed } from 'ai';
+
+export const runtime = 'nodejs';
+
+export async function POST(request: Request) {
+  let body: { baseUrl: string; apiKey?: string; modelName: string };
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { baseUrl, apiKey, modelName } = body;
+
+  if (!baseUrl || !modelName) {
+    return Response.json(
+      { error: 'Missing required fields: baseUrl and modelName' },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const customProvider = createOpenAI({
+      baseURL: baseUrl,
+      apiKey: apiKey || 'empty', // some backends require any string
+    });
+
+    const model = customProvider.embedding(modelName);
+    const { embedding } = await embed({ model, value: 'test connection' });
+
+    return Response.json({ success: true, dimensions: embedding.length });
+  } catch (error) {
+    return Response.json(
+      { error: error instanceof Error ? error.message : 'Embedding connection failed' },
+      { status: 400 },
+    );
+  }
+}

package/src/app/api/config/verify/route.ts

@@ -0,0 +1,309 @@
+import { embed, generateText } from 'ai';
+import { getAIModel } from '@larkup/core/embeddings/providers';
+import { getEmbeddingModel } from '@larkup/core/embeddings/registry';
+import { createOpenAI } from '@ai-sdk/openai';
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { createCohere } from '@ai-sdk/cohere';
+import { createMistral } from '@ai-sdk/mistral';
+import { createDeepSeek } from '@ai-sdk/deepseek';
+import { createAnthropic } from '@ai-sdk/anthropic';
+import { createGateway } from '@ai-sdk/gateway';
+import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
+import type { CustomModelConfig } from '@larkup/core/types';
+import { formatErrorMessage } from '@larkup/core/error-formatter';
+import { normalizeNativeChatModelId } from '@larkup/core/chat-models/registry';
+
+export const runtime = 'nodejs';
+
+const DEFAULT_CHAT_MODELS: Record<string, string> = {
+  openai: 'gpt-4o-mini',
+  anthropic: 'claude-sonnet-4-20250514',
+  google: 'gemini-3.6-flash',
+  mistral: 'mistral-small-latest',
+  deepseek: 'deepseek-chat',
+  cohere: 'command-r',
+  vercel_ai_gateway: 'openai/gpt-4o-mini',
+};
+
+const DEFAULT_EMBEDDING_MODELS: Record<string, string> = {
+  openai: 'openai/text-embedding-3-small',
+  google: 'google/gemini-embedding-001',
+  cohere: 'cohere/embed-english-v3.0',
+  mistral: 'mistral/mistral-embed',
+  vercel_ai_gateway: 'openai/text-embedding-3-small',
+};
+
+function createChatModel(
+  provider: string,
+  modelId: string,
+  apiKey?: string,
+  customChatModels?: CustomModelConfig[],
+) {
+  if (modelId.startsWith('custom:')) {
+    const customName = modelId.slice('custom:'.length);
+    const custom = (customChatModels ?? []).find((m) => m.modelName === customName);
+    if (custom) {
+      const customProvider = createOpenAICompatible({
+        name: 'custom_chat_provider',
+        baseURL: custom.baseUrl,
+        apiKey: custom.apiKey || apiKey || undefined,
+      });
+      return customProvider(custom.modelName);
+    }
+  }
+
+  const modelName = modelId.includes('/') ? modelId.split('/').slice(1).join('/') : modelId;
+
+  switch (provider) {
+    case 'google':
+      return createGoogleGenerativeAI({ apiKey })(modelName);
+    case 'cohere':
+      return createCohere({ apiKey })(modelName);
+    case 'mistral':
+      return createMistral({ apiKey })(modelName);
+    case 'deepseek':
+      return createDeepSeek({ apiKey })(modelName);
+    case 'anthropic':
+      return createAnthropic({ apiKey })(modelName);
+    case 'openai':
+      return createOpenAI({ apiKey })(modelName);
+    case 'vercel_ai_gateway':
+      return createGateway({ apiKey })(modelId);
+    default:
+      throw new Error(`Unsupported chat provider "${provider}".`);
+  }
+}
+
+export async function POST(request: Request) {
+  const body = await request.json();
+  const {
+    embeddingProvider,
+    embeddingApiKey,
+    embeddingModelId,
+    chatProvider,
+    chatApiKey,
+    chatModelId,
+    customChatModels,
+    customEmbeddings,
+    audioProvider,
+    audioApiKey,
+    audioModelId,
+  } = body;
+
+  if (!embeddingProvider && !chatProvider && !audioProvider) {
+    return Response.json({ error: 'No provider fields to verify' }, { status: 400 });
+  }
+
+  // Verify embedding.
+  if (embeddingProvider) {
+    try {
+      const resolvedEmbeddingProvider =
+        embeddingProvider === 'vercel_ai_gateway' ? 'vercel_ai_gateway' : embeddingProvider;
+
+      let resolvedEmbeddingModelId = embeddingModelId;
+
+      if (
+        resolvedEmbeddingModelId &&
+        resolvedEmbeddingProvider !== 'vercel_ai_gateway' &&
+        resolvedEmbeddingProvider !== 'custom'
+      ) {
+        const modelInfo =
+          getEmbeddingModel(resolvedEmbeddingModelId) ||
+          getEmbeddingModel(`${resolvedEmbeddingProvider}/${resolvedEmbeddingModelId}`);
+
+        if (!modelInfo || modelInfo.provider !== resolvedEmbeddingProvider) {
+          resolvedEmbeddingModelId = ''; // mismatch or unknown, force fallback
+        }
+      }
+
+      if (!resolvedEmbeddingModelId) {
+        resolvedEmbeddingModelId =
+          DEFAULT_EMBEDDING_MODELS[resolvedEmbeddingProvider] || DEFAULT_EMBEDDING_MODELS['openai'];
+      }
+
+      // Handle custom embedding models
+      if (
+        resolvedEmbeddingProvider === 'custom' &&
+        customEmbeddings &&
+        customEmbeddings.length > 0
+      ) {
+        resolvedEmbeddingModelId = `custom:${customEmbeddings[0].modelName}`;
+      }
+
+      const configMock = {
+        embeddingProvider,
+        embeddingApiKey,
+        embeddingModelId: resolvedEmbeddingModelId,
+        customEmbeddings,
+      } as any;
+      const model = getAIModel(configMock);
+
+      try {
+        await embed({ model, value: 'test' });
+      } catch (err: any) {
+        const msg = err.message || '';
+
+        if (
+          msg.includes('not found') ||
+          msg.includes('not available') ||
+          msg.includes('no longer available') ||
+          msg.includes('does not exist')
+        ) {
+          // For Google, try to list available models
+          if (resolvedEmbeddingProvider === 'google') {
+            try {
+              const res = await fetch(
+                `https://generativelanguage.googleapis.com/v1beta/models?key=${embeddingApiKey}`,
+              );
+              const data = await res.json();
+              const embedModels = (data.models || [])
+                .filter((m: any) => m.supportedGenerationMethods?.includes('embedContent'))
+                .map((m: any) => m.name);
+              return Response.json(
+                {
+                  error: `Embedding model "${resolvedEmbeddingModelId}" is not available for your API key. Available models: ${embedModels.join(
+                    ', ',
+                  )}`,
+                },
+                { status: 400 },
+              );
+            } catch {
+              // ignore listing error
+            }
+          }
+
+          return Response.json(
+            {
+              error: `Embedding model "${resolvedEmbeddingModelId}" is not available. Please select a different model or check your API key.`,
+            },
+            { status: 400 },
+          );
+        }
+
+        return Response.json({ error: formatErrorMessage(err) }, { status: 400 });
+      }
+    } catch (err: any) {
+      return Response.json({ error: formatErrorMessage(err) }, { status: 400 });
+    }
+  }
+
+  // Verify chat.
+  if (chatProvider) {
+    try {
+      const resolvedProvider =
+        chatProvider === 'vercel_ai_gateway' ? 'vercel_ai_gateway' : chatProvider;
+
+      let modelId: string;
+      if (resolvedProvider === 'custom' && customChatModels && customChatModels.length > 0) {
+        modelId = `custom:${customChatModels[0].modelName}`;
+      } else if (chatModelId) {
+        modelId = chatModelId;
+      } else {
+        modelId =
+          resolvedProvider === 'vercel_ai_gateway'
+            ? DEFAULT_CHAT_MODELS['vercel_ai_gateway']
+            : `${resolvedProvider}/${DEFAULT_CHAT_MODELS[resolvedProvider] || 'gpt-4o-mini'}`;
+      }
+
+      modelId = normalizeNativeChatModelId(resolvedProvider, modelId) || modelId;
+      const model = createChatModel(resolvedProvider, modelId, chatApiKey, customChatModels) as any;
+
+      try {
+        await generateText({ model, prompt: 'hi', maxOutputTokens: 16 });
+      } catch (err: any) {
+        const msg = err.message || '';
+
+        if (
+          msg.includes('not found') ||
+          msg.includes('not available') ||
+          msg.includes('no longer available') ||
+          msg.includes('does not exist') ||
+          msg.includes('is not supported for generateContent')
+        ) {
+          if (chatModelId) {
+            return Response.json(
+              {
+                error: `Chat model "${modelId}" is not available for your API key. Please select a different model.`,
+              },
+              { status: 400 },
+            );
+          }
+
+          return Response.json(
+            {
+              error: `The default test model for ${chatProvider} could not be verified. Your API key might only support specific models. Please select a model manually.`,
+            },
+            { status: 400 },
+          );
+        }
+
+        // Authentication / quota errors
+        if (
+          msg.includes('API key') ||
+          msg.includes('authentication') ||
+          msg.includes('unauthorized') ||
+          msg.includes('401')
+        ) {
+          return Response.json(
+            {
+              error: `Chat API key is invalid or unauthorized for ${chatProvider}. Please check your key.`,
+            },
+            { status: 400 },
+          );
+        }
+
+        return Response.json({ error: formatErrorMessage(err) }, { status: 400 });
+      }
+    } catch (err: any) {
+      return Response.json({ error: formatErrorMessage(err) }, { status: 400 });
+    }
+  }
+
+  // Verify audio.
+  if (audioProvider && audioProvider !== 'local') {
+    try {
+      let url = '';
+      let headers: Record<string, string> = {
+        Authorization: `Bearer ${audioApiKey}`,
+      };
+
+      if (audioProvider === 'openai') {
+        url = 'https://api.openai.com/v1/audio/transcriptions';
+      } else if (audioProvider === 'groq') {
+        url = 'https://api.groq.com/openai/v1/audio/transcriptions';
+      } else if (audioProvider === 'deepgram') {
+        url = 'https://api.deepgram.com/v1/listen';
+        headers = { Authorization: `Token ${audioApiKey}` };
+      } else if (audioProvider === 'assemblyai') {
+        url = 'https://api.assemblyai.com/v2/transcript';
+        headers = { Authorization: audioApiKey };
+      } else if (audioProvider === 'elevenlabs') {
+        url = 'https://api.elevenlabs.io/v1/speech-to-text';
+        headers = { 'xi-api-key': audioApiKey };
+      } else if (audioProvider === 'azure openai') {
+        return Response.json({ success: true }); // Skip verify for now
+      } else if (audioProvider === 'rev.ai') {
+        url = 'https://api.rev.ai/speechtotext/v1/jobs';
+      } else if (audioProvider === 'fal') {
+        return Response.json({ success: true }); // Skip verify for now
+      } else if (audioProvider === 'google') {
+        return Response.json({ success: true }); // Skip verify for now
+      }
+
+      if (url) {
+        const verifyRes = await fetch(url, {
+          method: 'POST',
+          headers,
+        });
+
+        if (verifyRes.status === 401 || verifyRes.status === 403) {
+          return Response.json({ error: `Invalid API Key for ${audioProvider}` }, { status: 400 });
+        }
+      }
+    } catch (err: any) {
+      return Response.json({ error: `Audio verification failed: ${err.message}` }, { status: 400 });
+    }
+  }
+
+  return Response.json({ success: true });
+}

package/src/app/api/describe-image/route.ts

@@ -0,0 +1,108 @@
+import { generateText } from 'ai';
+import { readConfig } from '@larkup/core/config-store';
+import { getModelsByType } from '@larkup/core/models-cache';
+import { runWithProject } from '@larkup/core/project-store';
+import {
+  createImageDescriptionSignal,
+  isImageDescriptionAbort,
+} from '@larkup/workspace-server/lib/chat/image-description';
+import {
+  createChatModel,
+  resolveConfiguredVisionModel,
+} from '@larkup/workspace-server/lib/chat/model-provider';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function POST(req: Request) {
+  const serverId = new URL(req.url).searchParams.get('serverId');
+  const describe = () => describeImage(req);
+  return serverId ? runWithProject(serverId, describe) : describe();
+}
+
+async function describeImage(req: Request) {
+  try {
+    const { base64, base64Images, prompt } = (await req.json()) as {
+      base64?: string;
+      base64Images?: string[];
+      prompt?: string;
+    };
+    const images = (base64Images?.length ? base64Images : base64 ? [base64] : []).slice(0, 6);
+    if (images.length === 0) {
+      return Response.json({ error: 'Missing image data' }, { status: 400 });
+    }
+
+    const config = await readConfig();
+    const models = await getModelsByType('language');
+    const resolved = resolveConfiguredVisionModel(config, models);
+    const model = createChatModel(
+      resolved.provider,
+      resolved.modelId,
+      resolved.apiKey,
+      config.customVisionModels,
+    ) as any;
+
+    const defaultPrompt =
+      'Provide a very brief, high-level summary of what this image contains (e.g., "A database ER diagram about films and actors", "A bar chart showing quarterly revenue"). Do NOT extract all text or exhaustively describe relationships. Keep it under 2 sentences.';
+
+    const { text, usage } = await generateText({
+      model,
+      // Do not use req.signal here. Media jobs and PDF uploads can retry or
+      // complete their outer request while the vision provider is backing off,
+      // which used to abort the AI SDK retry delay with "Delay was aborted".
+      abortSignal: createImageDescriptionSignal(),
+      messages: [
+        {
+          role: 'user',
+          content: [
+            {
+              type: 'text',
+              text: prompt || defaultPrompt,
+            },
+            ...images.map((image) => {
+              const data = image.startsWith('data:') ? image : `data:image/jpeg;base64,${image}`;
+              const mediaType = data.match(/^data:([^;,]+)/)?.[1] || 'image/jpeg';
+              return {
+                // AI SDK 6 uses file parts for every binary attachment. The
+                // legacy `image` part emits a deprecation warning on every
+                // PDF/image analysis request.
+                type: 'file' as const,
+                mediaType,
+                data,
+              };
+            }),
+          ],
+        },
+      ],
+    });
+
+    const { estimateCost, trackUsageEvent } = await import('@larkup/core/analytics-store');
+    await trackUsageEvent({
+      type: 'media_processing',
+      mediaType: 'image',
+      modelId: resolved.modelId,
+      provider: resolved.provider,
+      promptTokens: usage.inputTokens ?? 0,
+      completionTokens: usage.outputTokens ?? 0,
+      totalTokens: usage.totalTokens ?? 0,
+      estimatedCost: estimateCost(
+        resolved.modelId,
+        usage.inputTokens ?? 0,
+        usage.outputTokens ?? 0,
+      ),
+      timestamp: new Date().toISOString(),
+    });
+
+    return Response.json({ description: text });
+  } catch (err: any) {
+    if (isImageDescriptionAbort(err)) {
+      console.warn('Image description timed out before the vision provider responded.');
+      return Response.json(
+        { error: 'Image description timed out. The image can be retried.' },
+        { status: 504 },
+      );
+    }
+    console.error('Image description failed:', err);
+    return Response.json({ error: err.message }, { status: 500 });
+  }
+}

package/src/app/api/doc-editor/edit/route.ts

@@ -0,0 +1,87 @@
+import { applyFieldEdits, applyContentEdits, getSession } from '@larkup/tool-doc-editor';
+import type { FieldEdit, ContentEdit } from '@larkup/tool-doc-editor';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/doc-editor/edit
+ *
+ * Applies edits (field fills or content changes) to a document session.
+ * Returns the updated parsed document and a flag for live preview refresh.
+ */
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    const { sessionId, fieldEdits, contentEdits } = body as {
+      sessionId: string;
+      fieldEdits?: FieldEdit[];
+      contentEdits?: ContentEdit[];
+    };
+
+    if (!sessionId) {
+      return Response.json({ error: 'sessionId required' }, { status: 400 });
+    }
+
+    const session = getSession(sessionId);
+    if (!session) {
+      return Response.json({ error: 'Session not found' }, { status: 404 });
+    }
+
+    // Apply field edits if provided
+    if (fieldEdits && fieldEdits.length > 0) {
+      const result = await applyFieldEdits(sessionId, fieldEdits);
+
+      if (!result.success) {
+        return Response.json(
+          { error: result.error, fields: session.parsed.fields },
+          { status: 500 },
+        );
+      }
+
+      return Response.json({
+        success: true,
+        updatedFields: result.updatedFields,
+        fields: result.parsed.fields,
+        pages: result.parsed.pages.map((p) => ({
+          index: p.index,
+          text: p.text.slice(0, 2000),
+          html: p.html,
+          fields: p.fields,
+          dimensions: p.dimensions,
+        })),
+        totalPages: result.parsed.totalPages,
+        // Include base64 for live preview
+        fileBase64: result.fileBase64,
+      });
+    }
+
+    // Apply content edits if provided
+    if (contentEdits && contentEdits.length > 0) {
+      const result = await applyContentEdits(sessionId, contentEdits);
+
+      if (!result.success) {
+        return Response.json({ error: result.error }, { status: 500 });
+      }
+
+      return Response.json({
+        success: true,
+        updatedFields: result.updatedFields,
+        pages: result.parsed.pages.map((p) => ({
+          index: p.index,
+          text: p.text.slice(0, 2000),
+          html: p.html,
+          fields: p.fields,
+          dimensions: p.dimensions,
+        })),
+        totalPages: result.parsed.totalPages,
+        fileBase64: result.fileBase64,
+      });
+    }
+
+    return Response.json({ error: 'No edits provided' }, { status: 400 });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Edit failed';
+    return Response.json({ error: message }, { status: 500 });
+  }
+}

package/src/app/api/doc-editor/export/route.ts

@@ -0,0 +1,32 @@
+import { exportDocument } from '@larkup/tool-doc-editor';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * GET /api/doc-editor/export?sessionId=xxx
+ *
+ * Downloads the current (possibly modified) document as a binary file.
+ */
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const sessionId = url.searchParams.get('sessionId');
+
+  if (!sessionId) {
+    return Response.json({ error: 'sessionId required' }, { status: 400 });
+  }
+
+  const result = exportDocument(sessionId);
+  if (!result) {
+    return Response.json({ error: 'Session not found' }, { status: 404 });
+  }
+
+  return new Response(new Uint8Array(result.buffer), {
+    status: 200,
+    headers: {
+      'Content-Type': result.mimeType,
+      'Content-Disposition': `attachment; filename="${encodeURIComponent(result.fileName)}"`,
+      'Content-Length': String(result.buffer.length),
+    },
+  });
+}

package/src/app/api/doc-editor/parse/route.ts

@@ -0,0 +1,74 @@
+import { createSession, enrichPDFWithText, getSession } from '@larkup/tool-doc-editor';
+import { PDFParse } from 'pdf-parse';
+import { getData } from 'pdf-parse/worker';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+/**
+ * POST /api/doc-editor/parse
+ *
+ * Accepts a file upload (FormData), parses it, creates an editor session,
+ * and returns the parsed document structure.
+ */
+export async function POST(req: Request) {
+  try {
+    const formData = await req.formData();
+    const file = formData.get('file') as File | null;
+
+    if (!file) {
+      return Response.json({ error: 'No file provided' }, { status: 400 });
+    }
+
+    const buffer = Buffer.from(await file.arrayBuffer());
+    const session = await createSession(buffer, file.name, file.type);
+
+    // For PDFs, enrich with full text extraction via pdf-parse
+    // Skip heavy text extraction for long PDFs (e.g. > 5 pages) to just "view" them quickly
+    if (session.type === 'pdf' && session.parsed.rawText === '') {
+      if (session.parsed.totalPages <= 5) {
+        try {
+          // Keep the worker inside the standalone bundle instead of relying on
+          // a source-tree path that does not exist in production containers.
+          PDFParse.setWorker(getData());
+          const parser = new PDFParse({ data: buffer });
+          let text = '';
+          try {
+            text = (await parser.getText()).text;
+          } finally {
+            await parser.destroy();
+          }
+          const enrichedParsed = enrichPDFWithText(session.parsed, text);
+          session.parsed = enrichedParsed;
+        } catch {
+          // pdf-parse failed — continue with whatever we have
+        }
+      } else {
+        session.parsed.rawText = `[Long PDF - Text extraction skipped for performance. You can still view it.]`;
+      }
+    }
+
+    // Return a lightweight response (no base64 file data)
+    return Response.json({
+      sessionId: session.id,
+      fileName: session.fileName,
+      type: session.type,
+      mimeType: session.mimeType,
+      fileSize: session.parsed.fileSize,
+      totalPages: session.parsed.totalPages,
+      fields: session.parsed.fields,
+      pages: session.parsed.pages.map((p) => ({
+        index: p.index,
+        text: p.text.slice(0, 2000), // Limit text for response size
+        html: p.html,
+        fields: p.fields,
+        dimensions: p.dimensions,
+      })),
+      rawText: session.parsed.rawText.slice(0, 5000),
+      metadata: session.parsed.metadata,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Failed to parse file';
+    return Response.json({ error: message }, { status: 500 });
+  }
+}