larkup 0.1.14 → 0.1.21

package/app/api/config/route.ts

@@ -1,73 +1,97 @@
-import { NextResponse } from "next/server"
-import { readConfig, writeConfig } from "@larkup/core/config-store"
-import { getVectorStore, validateStoreConfig } from "@larkup/vector-stores/registry"
-import { getEmbeddingModel } from "@larkup/core/embeddings/registry"
-import { runWithServer } from "@larkup/core/workspace"
-import type { RagConfig } from "@larkup/core/types"
+import { NextResponse } from 'next/server';
+import { readConfig, writeConfig } from '@larkup/core/config-store';
+import { getVectorStore, validateStoreConfig } from '@larkup/vector-stores/registry';
+import { getEmbeddingModel } from '@larkup/core/embeddings/registry';
+import { runWithServer } from '@larkup/core/workspace';
+import type { RagConfig } from '@larkup/core/types';
 
-// Uses node:fs — must run on the Node.js runtime, not edge.
-export const runtime = "nodejs"
-export const dynamic = "force-dynamic"
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
 
 function withServer<T>(serverId: string | null, fn: () => Promise<T>) {
-  return serverId ? runWithServer(serverId, fn) : fn()
+  return serverId ? runWithServer(serverId, fn) : fn();
 }
 
 export async function GET(request: Request) {
-  const serverId = new URL(request.url).searchParams.get("serverId")
+  const serverId = new URL(request.url).searchParams.get('serverId');
   return withServer(serverId, async () => {
-    const config = await readConfig()
-    return NextResponse.json({ config })
-  })
+    const config = await readConfig();
+    return NextResponse.json({ config });
+  });
 }
 
 export async function PUT(request: Request) {
-  const serverId = new URL(request.url).searchParams.get("serverId")
-  let body: RagConfig
+  const serverId = new URL(request.url).searchParams.get('serverId');
+  let body: RagConfig;
   try {
-    body = (await request.json()) as RagConfig
+    body = (await request.json()) as RagConfig;
   } catch {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 })
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const defaultEmbeddingModels: Record<string, string> = {
+    openai: 'openai/text-embedding-3-small',
+    google: 'google/gemini-embedding-2',
+    cohere: 'cohere/embed-english-v3.0',
+    mistral: 'mistral/mistral-embed',
+    vercel_ai_gateway: 'openai/text-embedding-3-small',
+  };
+
+  const resolvedEmbeddingProvider =
+    body.embeddingProvider === 'vercel_ai_gateway' ? 'vercel_ai_gateway' : body.embeddingProvider;
+
+  if (
+    body.embeddingModelId &&
+    resolvedEmbeddingProvider !== 'vercel_ai_gateway' &&
+    resolvedEmbeddingProvider !== 'custom'
+  ) {
+    const modelInfo =
+      getEmbeddingModel(body.embeddingModelId) ||
+      getEmbeddingModel(`${resolvedEmbeddingProvider}/${body.embeddingModelId}`);
+
+    if (modelInfo && modelInfo.provider !== resolvedEmbeddingProvider) {
+      body.embeddingModelId =
+        defaultEmbeddingModels[resolvedEmbeddingProvider] || defaultEmbeddingModels['openai'];
+    }
   }
 
   // Validate the embedding model exists.
-  const isCustom = body.embeddingModelId.startsWith("custom:")
+  const isCustom = body.embeddingModelId.startsWith('custom:');
   if (!isCustom && !getEmbeddingModel(body.embeddingModelId)) {
     return NextResponse.json(
       { error: `Unknown embedding model: ${body.embeddingModelId}` },
       { status: 400 },
-    )
+    );
   }
   if (isCustom) {
-    const modelName = body.embeddingModelId.slice("custom:".length)
-    const found = body.customEmbeddings?.find((m) => m.modelName === modelName)
+    const modelName = body.embeddingModelId.slice('custom:'.length);
+    const found = body.customEmbeddings?.find((m) => m.modelName === modelName);
     if (!found) {
       return NextResponse.json(
         { error: `Custom embedding model "${modelName}" not found in customEmbeddings` },
         { status: 400 },
-      )
+      );
     }
   }
 
   // Validate the store + its dynamic, store-specific fields.
-  const store = getVectorStore(body.vectorStore)
+  const store = getVectorStore(body.vectorStore);
   if (!store) {
     return NextResponse.json(
       { error: `Unknown vector store: ${body.vectorStore}` },
       { status: 400 },
-    )
+    );
   }
-  const fieldErrors = validateStoreConfig(store, body.storeConfig ?? {}, body.indexType)
+  const fieldErrors = validateStoreConfig(store, body.storeConfig ?? {}, body.indexType);
   if (Object.keys(fieldErrors).length > 0) {
     return NextResponse.json(
-      { error: "Missing required vector store fields", fieldErrors },
+      { error: 'Missing required vector store fields', fieldErrors },
       { status: 422 },
-    )
+    );
   }
 
   return withServer(serverId, async () => {
-    const saved = await writeConfig(body)
-    return NextResponse.json({ config: saved })
-  })
+    const saved = await writeConfig(body);
+    return NextResponse.json({ config: saved });
+  });
 }
-

package/app/api/config/test/route.ts

@@ -1,67 +1,68 @@
-import { NextResponse } from "next/server"
-import { getVectorStore, validateStoreConfig } from "@larkup/vector-stores/registry"
-import { createAdapter } from "@larkup/vector-stores/factory"
-import type { RagConfig } from "@larkup/core/types"
+import { NextResponse } from 'next/server';
+import { getVectorStore, validateStoreConfig } from '@larkup/vector-stores/registry';
+import { createAdapter } from '@larkup/vector-stores/factory';
+import type { RagConfig } from '@larkup/core/types';
 
-// Uses node:fs — must run on the Node.js runtime, not edge.
-export const runtime = "nodejs"
+export const runtime = 'nodejs';
 
 export async function POST(request: Request) {
-  let body: RagConfig
+  let body: RagConfig;
   try {
-    body = (await request.json()) as RagConfig
+    body = (await request.json()) as RagConfig;
   } catch {
-    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 })
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
   }
 
   // Validate the store + its dynamic, store-specific fields.
-  const store = getVectorStore(body.vectorStore)
+  const store = getVectorStore(body.vectorStore);
   if (!store) {
     return NextResponse.json(
       { error: `Unknown vector store: ${body.vectorStore}` },
       { status: 400 },
-    )
+    );
   }
 
-  const fieldErrors = validateStoreConfig(store, body.storeConfig ?? {}, body.indexType)
+  const fieldErrors = validateStoreConfig(store, body.storeConfig ?? {}, body.indexType);
   if (Object.keys(fieldErrors).length > 0) {
     return NextResponse.json(
-      { error: "Missing required vector store fields", fieldErrors },
+      { error: 'Missing required vector store fields', fieldErrors },
       { status: 422 },
-    )
+    );
   }
 
-  let dimensions = 1536
-  const isCustom = body.embeddingModelId.startsWith("custom:")
+  let dimensions = 1536;
+  const isCustom = body.embeddingModelId.startsWith('custom:');
   if (isCustom) {
-    const modelName = body.embeddingModelId.slice("custom:".length)
-    const found = body.customEmbeddings?.find((m) => m.modelName === modelName)
+    const modelName = body.embeddingModelId.slice('custom:'.length);
+    const found = body.customEmbeddings?.find((m) => m.modelName === modelName);
     if (!found) {
       return NextResponse.json(
         { error: `Custom embedding model "${modelName}" not found in customEmbeddings` },
         { status: 400 },
-      )
+      );
     }
-    dimensions = found.dimensions
+    dimensions = found.dimensions ?? 1536;
   } else {
-    const embeddingModel = await import("@larkup/core/embeddings/registry").then(m => m.getEmbeddingModel(body.embeddingModelId))
-    if (!embeddingModel) {
-      return NextResponse.json(
-        { error: `Unknown embedding model: ${body.embeddingModelId}` },
-        { status: 400 },
-      )
+    const { getEmbeddingModel, EMBEDDING_DIMENSIONS } = await import(
+      '@larkup/core/embeddings/registry'
+    );
+    const embeddingModel = getEmbeddingModel(body.embeddingModelId);
+    if (embeddingModel) {
+      dimensions = embeddingModel.dimensions;
+    } else {
+      const known = EMBEDDING_DIMENSIONS[body.embeddingModelId];
+      dimensions = known?.dimensions ?? 768;
     }
-    dimensions = embeddingModel.dimensions
   }
 
   try {
-    const adapter = await createAdapter(body)
-    await adapter.testConnection(dimensions)
-    return NextResponse.json({ success: true })
+    const adapter = await createAdapter(body);
+    await adapter.testConnection(dimensions);
+    return NextResponse.json({ success: true });
   } catch (error) {
     return NextResponse.json(
-      { error: error instanceof Error ? error.message : "Connection failed" },
+      { error: error instanceof Error ? error.message : 'Connection failed' },
       { status: 400 },
-    )
+    );
   }
 }

package/app/api/config/test-llm/route.ts

@@ -1,22 +1,22 @@
-import { NextResponse } from "next/server";
-import { createOpenAI } from "@ai-sdk/openai";
-import { generateText } from "ai";
+import { NextResponse } from 'next/server';
+import { createOpenAI } from '@ai-sdk/openai';
+import { generateText } from 'ai';
 
-export const runtime = "nodejs";
+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 NextResponse.json({ error: "Invalid JSON body" }, { status: 400 });
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
   }
 
   const { baseUrl, apiKey, modelName } = body;
 
   if (!baseUrl || !modelName) {
     return NextResponse.json(
-      { error: "Missing required fields: baseUrl and modelName" },
+      { error: 'Missing required fields: baseUrl and modelName' },
       { status: 400 },
     );
   }
@@ -24,22 +24,21 @@ export async function POST(request: Request) {
   try {
     const customProvider = createOpenAI({
       baseURL: baseUrl,
-      apiKey: apiKey || "empty", // some backends require any string
+      apiKey: apiKey || 'empty', // some backends require any string
     });
 
     const model = customProvider.chat(modelName);
-    // We just need a simple prompt to verify connection
     const { text } = await generateText({
       model,
       prompt: "Reply with the word 'OK'",
-      maxOutputTokens: 5,
+      maxOutputTokens: 16,
     });
 
     return NextResponse.json({ success: true, text });
   } catch (error) {
     return NextResponse.json(
       {
-        error: error instanceof Error ? error.message : "LLM connection failed",
+        error: error instanceof Error ? error.message : 'LLM connection failed',
       },
       { status: 400 },
     );

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

@@ -0,0 +1,315 @@
+import { NextResponse } from 'next/server';
+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';
+
+export const runtime = 'nodejs';
+
+const DEFAULT_CHAT_MODELS: Record<string, string> = {
+  openai: 'gpt-4o-mini',
+  anthropic: 'claude-sonnet-4-20250514',
+  google: 'gemini-2.0-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':
+    default:
+      return createGateway({ apiKey })(modelId);
+  }
+}
+
+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 NextResponse.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 NextResponse.json(
+                {
+                  error: `Embedding model "${resolvedEmbeddingModelId}" is not available for your API key. Available models: ${embedModels.join(
+                    ', ',
+                  )}`,
+                },
+                { status: 400 },
+              );
+            } catch {
+              // ignore listing error
+            }
+          }
+
+          return NextResponse.json(
+            {
+              error: `Embedding model "${resolvedEmbeddingModelId}" is not available. Please select a different model or check your API key.`,
+            },
+            { status: 400 },
+          );
+        }
+
+        return NextResponse.json(
+          { error: `Embedding verification failed: ${msg}` },
+          { status: 400 },
+        );
+      }
+    } catch (err: any) {
+      return NextResponse.json({ error: `Embedding Error: ${err.message}` }, { 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'}`;
+      }
+
+      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 NextResponse.json(
+              {
+                error: `Chat model "${modelId}" is not available for your API key. Please select a different model.`,
+              },
+              { status: 400 },
+            );
+          }
+
+          return NextResponse.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 NextResponse.json(
+            {
+              error: `Chat API key is invalid or unauthorized for ${chatProvider}. Please check your key.`,
+            },
+            { status: 400 },
+          );
+        }
+
+        return NextResponse.json({ error: `Chat verification failed: ${msg}` }, { status: 400 });
+      }
+    } catch (err: any) {
+      return NextResponse.json({ error: `Chat Error: ${err.message}` }, { 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 NextResponse.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 NextResponse.json({ success: true }); // Skip verify for now
+      } else if (audioProvider === 'google') {
+        return NextResponse.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 NextResponse.json(
+            { error: `Invalid API Key for ${audioProvider}` },
+            { status: 400 },
+          );
+        }
+      }
+    } catch (err: any) {
+      return NextResponse.json(
+        { error: `Audio verification failed: ${err.message}` },
+        { status: 400 },
+      );
+    }
+  }
+
+  return NextResponse.json({ success: true });
+}

package/app/api/connections/route.ts

@@ -0,0 +1,39 @@
+import { NextResponse } from 'next/server';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { getDataDir, requireDataDir } from '@larkup/core/workspace';
+
+async function getConnectionsFile(create: boolean) {
+  const dir = create ? await requireDataDir() : await getDataDir();
+  if (!dir) return null;
+  return path.join(dir, 'connections.json');
+}
+
+export async function GET() {
+  try {
+    const file = await getConnectionsFile(false);
+    if (!file) return NextResponse.json({});
+
+    try {
+      const raw = await fs.readFile(file, 'utf8');
+      return NextResponse.json(JSON.parse(raw));
+    } catch {
+      return NextResponse.json({});
+    }
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}
+
+export async function PUT(req: Request) {
+  try {
+    const body = await req.json();
+    const file = await getConnectionsFile(true);
+    if (!file) throw new Error('No workspace directory');
+
+    await fs.writeFile(file, JSON.stringify(body, null, 2), 'utf8');
+    return NextResponse.json({ success: true });
+  } catch (error) {
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}