larkup 0.1.14

package/app/api/chat/suggestions/route.ts

@@ -0,0 +1,115 @@
+import { NextResponse } from "next/server";
+import { readConfig, writeConfig } from "@larkup/core/config-store";
+import { readRun } from "@larkup/core/index-store";
+import { runWithServer } from "@larkup/core/workspace";
+import { createAdapter } from "@larkup/vector-stores/factory";
+import { embedQuery } from "@larkup/core/indexing/embedder";
+import { generateObject } from "ai";
+import { z } from "zod";
+import { getChatModel } from "@larkup/core/chat-models/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 { createGateway } from "@ai-sdk/gateway";
+
+export const dynamic = "force-dynamic";
+
+function withServer<T>(serverId: string | null, fn: () => Promise<T>) {
+  return serverId ? runWithServer(serverId, fn) : fn();
+}
+
+function createChatModel(provider: string, modelId: string, apiKey?: string) {
+  const modelName = modelId.includes("/")
+    ? modelId.split("/").slice(1).join("/")
+    : modelId;
+  const key = apiKey;
+
+  switch (provider) {
+    case "google":
+      return createGoogleGenerativeAI({ apiKey: key })(modelName);
+    case "cohere":
+      return createCohere({ apiKey: key })(modelName);
+    case "mistral":
+      return createMistral({ apiKey: key })(modelName);
+    case "deepseek":
+      return createDeepSeek({ apiKey: key })(modelName);
+    case "vercel_ai_gateway":
+      return createGateway({ apiKey: key })(modelId);
+    case "openai":
+    default:
+      return createOpenAI({ apiKey: key })(modelName);
+  }
+}
+
+export async function POST(req: Request) {
+  const serverId = new URL(req.url).searchParams.get("serverId");
+  return withServer(serverId, async () => {
+    const config = await readConfig();
+    const run = await readRun();
+
+    if (config.chatSuggestions && config.chatSuggestions.length > 0) {
+      return NextResponse.json({ suggestions: config.chatSuggestions });
+    }
+
+    const indexed = run?.status === "completed" && (run.totalChunks ?? 0) > 0;
+    if (!indexed) {
+      return NextResponse.json({
+        suggestions: [
+          "What is this corpus about?",
+          "Summarize the key concepts",
+        ],
+      });
+    }
+
+    try {
+      // Pull a dummy vector (just embedded "summary" or similar) to get some chunks
+      const vector = await embedQuery(config, "overview summary");
+      const adapter = await createAdapter(config);
+      const hits = await adapter.query(vector, 5, "overview summary");
+
+      const context = hits
+        ?.map((h) => h.text)
+        ?.join("\n\n")
+        ?.slice(0, 3000);
+
+      const provider = config.chatProvider || config.embeddingProvider;
+      const chatModelId = config.chatModelId || "openai/gpt-4o-mini";
+      const descriptor = getChatModel(chatModelId);
+      const resolvedProvider =
+        provider === "vercel_ai_gateway"
+          ? "vercel_ai_gateway"
+          : descriptor?.provider || provider;
+
+      const aiModel = createChatModel(
+        resolvedProvider,
+        chatModelId,
+        config.chatApiKey || config.embeddingApiKey,
+      );
+
+      const { object } = await generateObject({
+        model: aiModel,
+        system:
+          "You are an AI that suggests 3 very short and concise questions a user could ask based on the provided text.",
+        prompt: `Text:\n${context}`,
+        schema: z.object({
+          suggestions: z.array(z.string()).length(3),
+        }),
+      });
+
+      config.chatSuggestions = object.suggestions;
+      await writeConfig(config);
+
+      return NextResponse.json({ suggestions: object.suggestions });
+    } catch (e: any) {
+      console.error("Failed to generate suggestions:", e.message);
+      return NextResponse.json({
+        suggestions: [
+          "What is this corpus about?",
+          "Summarize the key concepts",
+        ],
+      });
+    }
+  });
+}

package/app/api/config/route.ts

@@ -0,0 +1,73 @@
+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"
+
+function withServer<T>(serverId: string | null, fn: () => Promise<T>) {
+  return serverId ? runWithServer(serverId, fn) : fn()
+}
+
+export async function GET(request: Request) {
+  const serverId = new URL(request.url).searchParams.get("serverId")
+  return withServer(serverId, async () => {
+    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
+  try {
+    body = (await request.json()) as RagConfig
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 })
+  }
+
+  // Validate the embedding model exists.
+  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)
+    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)
+  if (!store) {
+    return NextResponse.json(
+      { error: `Unknown vector store: ${body.vectorStore}` },
+      { status: 400 },
+    )
+  }
+  const fieldErrors = validateStoreConfig(store, body.storeConfig ?? {}, body.indexType)
+  if (Object.keys(fieldErrors).length > 0) {
+    return NextResponse.json(
+      { error: "Missing required vector store fields", fieldErrors },
+      { status: 422 },
+    )
+  }
+
+  return withServer(serverId, async () => {
+    const saved = await writeConfig(body)
+    return NextResponse.json({ config: saved })
+  })
+}
+

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

@@ -0,0 +1,67 @@
+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 async function POST(request: Request) {
+  let body: RagConfig
+  try {
+    body = (await request.json()) as RagConfig
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 })
+  }
+
+  // Validate the store + its dynamic, store-specific fields.
+  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)
+  if (Object.keys(fieldErrors).length > 0) {
+    return NextResponse.json(
+      { error: "Missing required vector store fields", fieldErrors },
+      { status: 422 },
+    )
+  }
+
+  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)
+    if (!found) {
+      return NextResponse.json(
+        { error: `Custom embedding model "${modelName}" not found in customEmbeddings` },
+        { status: 400 },
+      )
+    }
+    dimensions = found.dimensions
+  } 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 },
+      )
+    }
+    dimensions = embeddingModel.dimensions
+  }
+
+  try {
+    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" },
+      { status: 400 },
+    )
+  }
+}

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

@@ -0,0 +1,40 @@
+import { NextResponse } from "next/server"
+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 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" },
+      { 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 NextResponse.json({ success: true, dimensions: embedding.length })
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Embedding connection failed" },
+      { status: 400 },
+    )
+  }
+}

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

@@ -0,0 +1,47 @@
+import { NextResponse } from "next/server";
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } 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 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" },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const customProvider = createOpenAI({
+      baseURL: baseUrl,
+      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,
+    });
+
+    return NextResponse.json({ success: true, text });
+  } catch (error) {
+    return NextResponse.json(
+      {
+        error: error instanceof Error ? error.message : "LLM connection failed",
+      },
+      { status: 400 },
+    );
+  }
+}

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

@@ -0,0 +1,36 @@
+import { NextResponse } from "next/server"
+import { embed } from "ai"
+import { getAIModel } from "@larkup/core/embeddings/providers"
+import type { RagConfig } from "@larkup/core/types"
+
+export const runtime = "nodejs"
+
+export async function POST(request: Request) {
+  let body: Partial<RagConfig>
+  try {
+    body = await request.json()
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body" }, { status: 400 })
+  }
+
+  const { embeddingProvider, embeddingModelId } = body
+
+  if (!embeddingProvider || !embeddingModelId) {
+    return NextResponse.json(
+      { error: "Missing required fields: embeddingProvider or embeddingModelId" },
+      { status: 400 },
+    )
+  }
+
+  try {
+    const model = getAIModel(body as RagConfig)
+    const { embedding } = await embed({ model, value: "test connection" })
+
+    return NextResponse.json({ success: true, dimensions: embedding.length })
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : "Connection failed. Please check your API key." },
+      { status: 400 },
+    )
+  }
+}

package/app/api/demo/route.ts

@@ -0,0 +1,176 @@
+import { NextResponse } from "next/server";
+import { readConfig } from "@larkup/core/config-store";
+import { readRun } from "@larkup/core/index-store";
+import { refreshServerStatus } from "@larkup/core/generator/server-runtime";
+import { createAdapter } from "@larkup/vector-stores/factory";
+import { getEmbeddingModel } from "@larkup/core/embeddings/registry";
+import { getVectorStore } from "@larkup/vector-stores/registry";
+import type { QueryHit } from "@larkup/vector-stores/adapter";
+import { runWithServer } from "@larkup/core/workspace";
+import { embedQuery } from "@larkup/core/indexing/embedder";
+
+export const dynamic = "force-dynamic";
+
+/** Run a handler against a specific server when `serverId` is provided. */
+function withServer<T>(serverId: string | null, fn: () => Promise<T>) {
+  return serverId ? runWithServer(serverId, fn) : fn();
+}
+
+/**
+ * GET /api/demo — readiness snapshot for the Demo stage.
+ *
+ * Reports whether there's a built index to query and whether a generated
+ * server is live, so the UI can label which path a query will take. Accepts
+ * `?serverId=` to inspect a specific server instead of the active one.
+ */
+export async function GET(req: Request) {
+  const serverId = new URL(req.url).searchParams.get("serverId");
+  return withServer(serverId, () => snapshot());
+}
+
+async function snapshot() {
+  const config = await readConfig();
+  const run = await readRun();
+  const server = await refreshServerStatus();
+
+  const indexed = run?.status === "completed" && (run.totalChunks ?? 0) > 0;
+  const ready = indexed || server.running;
+
+  const blockers: string[] = [];
+  if (!ready) {
+    blockers.push(
+      "Build a larkup index (or launch a generated server) before running a demo query.",
+    );
+  }
+
+  return NextResponse.json({
+    ready,
+    blockers,
+    indexed,
+    server: { running: server.running, endpoint: server.endpoint },
+    config: {
+      projectName: config.projectName,
+      embeddingModelId: config.embeddingModelId,
+      vectorStore: config.vectorStore,
+      indexType: config.indexType,
+      topK: config.topK,
+    },
+  });
+}
+
+interface DemoResult {
+  query: string;
+  hits: QueryHit[];
+  source: "server" | "direct";
+  endpoint?: string;
+  tookMs: number;
+}
+
+/**
+ * POST /api/demo — run a retrieval query.
+ *
+ * Prefers a running generated server (the artifact you'd deploy), so the demo
+ * exercises the real serving path. Falls back to in-process retrieval against
+ * the toolkit's own store when no server is running.
+ */
+export async function POST(req: Request) {
+  const started = Date.now();
+
+  let body: { query?: string; topK?: number; serverId?: string };
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: "Invalid JSON body." }, { status: 400 });
+  }
+
+  const query = body.query?.trim();
+  if (!query) {
+    return NextResponse.json(
+      { error: "A non-empty 'query' is required." },
+      { status: 400 },
+    );
+  }
+
+  return withServer(body.serverId ?? null, () =>
+    runQuery(query, body.topK, started),
+  );
+}
+
+async function runQuery(
+  query: string,
+  requestedTopK: number | undefined,
+  started: number,
+) {
+  const config = await readConfig();
+  const topK = Math.min(Math.max(Number(requestedTopK) || config.topK, 1), 20);
+
+  // 1) Prefer the running generated server — the real serving path.
+  const server = await refreshServerStatus();
+  if (server.running) {
+    try {
+      const res = await fetch(`${server.endpoint}/query`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query, topK }),
+        signal: AbortSignal.timeout(30_000),
+      });
+      const data = await res.json();
+      if (res.ok) {
+        const result: DemoResult = {
+          query,
+          hits: data.hits ?? [],
+          source: "server",
+          endpoint: server.endpoint,
+          tookMs: Date.now() - started,
+        };
+        return NextResponse.json(result);
+      }
+      // Fall through to direct retrieval if the server errored.
+    } catch {
+      // Server unreachable — fall back to direct retrieval below.
+    }
+  }
+
+  // 2) Fallback: in-process retrieval against the toolkit's own store.
+  const run = await readRun();
+  if (!run || run.status !== "completed" || (run.totalChunks ?? 0) === 0) {
+    return NextResponse.json(
+      {
+        error:
+          "No index to query yet. Build an index in the Index stage, or launch a server first.",
+      },
+      { status: 409 },
+    );
+  }
+
+  if (!getEmbeddingModel(config.embeddingModelId)) {
+    return NextResponse.json(
+      { error: `Unknown embedding model "${config.embeddingModelId}".` },
+      { status: 400 },
+    );
+  }
+  if (!getVectorStore(config.vectorStore)) {
+    return NextResponse.json(
+      { error: `Unknown vector store "${config.vectorStore}".` },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const vector = await embedQuery(config, query);
+    const adapter = await createAdapter(config);
+    const hits = await adapter.query(vector, topK, query);
+
+    const result: DemoResult = {
+      query,
+      hits,
+      source: "direct",
+      tookMs: Date.now() - started,
+    };
+    return NextResponse.json(result);
+  } catch (err) {
+    const message =
+      err instanceof Error ? err.message : "Retrieval failed unexpectedly.";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}