larkup 0.1.14 → 0.1.21

package/app/api/connections/webhook/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { readAgentServerState } from '@larkup/core/generator/server-runtime';
+
+export async function POST(req: Request) {
+  try {
+    const payload = await req.json();
+
+    // In a real implementation, this would validate the webhook signature,
+    // parse the incoming message format (e.g. from Slack/Discord/Custom),
+    // and format it for the agent server.
+
+    const state = await readAgentServerState();
+
+    if (!state.running || !state.endpoint) {
+      return NextResponse.json({ error: 'Agent server is not running locally.' }, { status: 503 });
+    }
+
+    // Forward to the local agent server
+    const agentRes = await fetch(`${state.endpoint}/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages: [
+          { role: 'user', content: payload.text || payload.message || JSON.stringify(payload) },
+        ],
+      }),
+    });
+
+    if (!agentRes.ok) {
+      throw new Error(`Agent server returned ${agentRes.status}`);
+    }
+
+    // The agent server streams text back. We could collect it and return a sync response,
+    // or stream it back. For webhooks, sync response is often expected.
+    // In a real implementation, we might stream the response back to the webhook caller,
+    // or asynchronously send the response back via the channel's API (e.g. Slack API).
+
+    return NextResponse.json({ success: true, message: 'Message forwarded to agent' });
+  } catch (error) {
+    console.error('Webhook error:', error);
+    return NextResponse.json({ error: String(error) }, { status: 500 });
+  }
+}

package/app/api/demo/route.ts

@@ -1,15 +1,15 @@
-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";
+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>) {
@@ -24,7 +24,7 @@ function withServer<T>(serverId: string | null, fn: () => Promise<T>) {
  * `?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");
+  const serverId = new URL(req.url).searchParams.get('serverId');
   return withServer(serverId, () => snapshot());
 }
 
@@ -33,13 +33,13 @@ async function snapshot() {
   const run = await readRun();
   const server = await refreshServerStatus();
 
-  const indexed = run?.status === "completed" && (run.totalChunks ?? 0) > 0;
+  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.",
+      'Build a larkup index (or launch a generated server) before running a demo query.',
     );
   }
 
@@ -61,7 +61,7 @@ async function snapshot() {
 interface DemoResult {
   query: string;
   hits: QueryHit[];
-  source: "server" | "direct";
+  source: 'server' | 'direct';
   endpoint?: string;
   tookMs: number;
 }
@@ -80,37 +80,27 @@ export async function POST(req: Request) {
   try {
     body = await req.json();
   } catch {
-    return NextResponse.json({ error: "Invalid JSON body." }, { status: 400 });
+    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 NextResponse.json({ error: "A non-empty 'query' is required." }, { status: 400 });
   }
 
-  return withServer(body.serverId ?? null, () =>
-    runQuery(query, body.topK, started),
-  );
+  return withServer(body.serverId ?? null, () => runQuery(query, body.topK, started));
 }
 
-async function runQuery(
-  query: string,
-  requestedTopK: number | undefined,
-  started: number,
-) {
+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" },
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ query, topK }),
         signal: AbortSignal.timeout(30_000),
       });
@@ -119,31 +109,30 @@ async function runQuery(
         const result: DemoResult = {
           query,
           hits: data.hits ?? [],
-          source: "server",
+          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.
-    }
+    } catch {}
   }
 
-  // 2) Fallback: in-process retrieval against the toolkit's own store.
   const run = await readRun();
-  if (!run || run.status !== "completed" || (run.totalChunks ?? 0) === 0) {
+  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.",
+          'No index to query yet. Build an index in the Index stage, or launch a server first.',
       },
       { status: 409 },
     );
   }
 
-  if (!getEmbeddingModel(config.embeddingModelId)) {
+  if (
+    !getEmbeddingModel(config.embeddingModelId) &&
+    !config.embeddingModelId?.startsWith('custom:')
+  ) {
     return NextResponse.json(
       { error: `Unknown embedding model "${config.embeddingModelId}".` },
       { status: 400 },
@@ -164,13 +153,12 @@ async function runQuery(
     const result: DemoResult = {
       query,
       hits,
-      source: "direct",
+      source: 'direct',
       tookMs: Date.now() - started,
     };
     return NextResponse.json(result);
   } catch (err) {
-    const message =
-      err instanceof Error ? err.message : "Retrieval failed unexpectedly.";
+    const message = err instanceof Error ? err.message : 'Retrieval failed unexpectedly.';
     return NextResponse.json({ error: message }, { status: 500 });
   }
 }

package/app/api/deploy/cloud-project/route.ts

@@ -0,0 +1,125 @@
+import { NextResponse } from 'next/server';
+import { readConfig, writeConfig } from '@larkup/core/config-store';
+import { readDocuments, replaceDocuments } from '@larkup/core/documents-store';
+import { createRun, runIndexer } from '@larkup/core/indexing/indexer';
+import { createServer, runWithServer, setActiveServer } from '@larkup/core/workspace';
+import { createAdapter } from '@larkup/vector-stores/factory';
+import { getVectorStore, validateStoreConfig } from '@larkup/vector-stores/registry';
+import type { IndexType, RagConfig, VectorStoreId } from '@larkup/core/types';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+type CloudProjectRequest = {
+  sourceServerId: string;
+  name?: string;
+  vectorStore: VectorStoreId;
+  storeConfig: Record<string, string>;
+  indexType?: IndexType;
+  copyKnowledgeBase?: boolean;
+  embeddingModelId?: string;
+};
+
+function requiresCloudStorage(config: Pick<RagConfig, 'vectorStore' | 'storeConfig'>) {
+  return config.vectorStore === 'lancedb' && (config.storeConfig.mode ?? 'local') === 'local';
+}
+
+async function getEmbeddingDimensions(config: RagConfig) {
+  if (config.embeddingModelId.startsWith('custom:')) {
+    const modelName = config.embeddingModelId.slice('custom:'.length);
+    return (
+      config.customEmbeddings?.find((model) => model.modelName === modelName)?.dimensions ?? 1536
+    );
+  }
+
+  const { getEmbeddingModel, EMBEDDING_DIMENSIONS } = await import(
+    '@larkup/core/embeddings/registry'
+  );
+  return (
+    getEmbeddingModel(config.embeddingModelId)?.dimensions ??
+    EMBEDDING_DIMENSIONS[config.embeddingModelId]?.dimensions ??
+    768
+  );
+}
+
+/**
+ * Creates an isolated cloud-ready project. Raw source documents can be copied
+ * and re-indexed, but the existing local vectors are intentionally never
+ * transferred because they are incompatible with a different vector store.
+ */
+export async function POST(request: Request) {
+  let body: CloudProjectRequest;
+  try {
+    body = (await request.json()) as CloudProjectRequest;
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body.' }, { status: 400 });
+  }
+
+  const store = getVectorStore(body.vectorStore);
+  if (!store || store.installStatus === 'coming-soon') {
+    return NextResponse.json({ error: 'Select an available storage engine.' }, { status: 400 });
+  }
+  const fieldErrors = validateStoreConfig(store, body.storeConfig ?? {}, body.indexType);
+  if (Object.keys(fieldErrors).length > 0) {
+    return NextResponse.json(
+      { error: 'Complete the required storage fields.', fieldErrors },
+      { status: 422 },
+    );
+  }
+  if (requiresCloudStorage({ vectorStore: body.vectorStore, storeConfig: body.storeConfig })) {
+    return NextResponse.json({ error: 'Choose cloud storage for deployment.' }, { status: 422 });
+  }
+
+  const source = await runWithServer(body.sourceServerId, async () => ({
+    config: await readConfig(),
+    documents: body.copyKnowledgeBase ? await readDocuments() : [],
+  }));
+  const storageConfig: RagConfig = {
+    ...source.config,
+    vectorStore: body.vectorStore,
+    storeConfig: body.storeConfig,
+    embeddingModelId: body.embeddingModelId || source.config.embeddingModelId,
+  };
+  try {
+    const adapter = await createAdapter(storageConfig);
+    await adapter.testConnection(await getEmbeddingDimensions(storageConfig));
+  } catch (error) {
+    return NextResponse.json(
+      { error: error instanceof Error ? error.message : 'Storage connection failed.' },
+      { status: 400 },
+    );
+  }
+  const { server } = await createServer(body.name?.trim() || `${source.config.projectName}-cloud`);
+  // Creating a workspace server makes it active by default. The storage selection
+  // is isolated to the new cloud project, so keep the source project active.
+  await setActiveServer(body.sourceServerId);
+
+  const config = await runWithServer(server.id, async () => {
+    const nextConfig: RagConfig = {
+      ...source.config,
+      projectName: body.name?.trim() || `${source.config.projectName}-cloud`,
+      vectorStore: body.vectorStore,
+      storeConfig: body.storeConfig,
+      embeddingModelId: body.embeddingModelId || source.config.embeddingModelId,
+      updatedAt: new Date().toISOString(),
+    };
+    await writeConfig(nextConfig);
+    if (source.documents.length > 0) await replaceDocuments(source.documents);
+    return nextConfig;
+  });
+
+  let run = null;
+  if (source.documents.length > 0) {
+    run = await runWithServer(server.id, async () => {
+      const nextRun = await createRun(config);
+      // Run the indexer asynchronously but ensure it stays within the new server's context
+      void runWithServer(server.id, () => runIndexer(nextRun.id, config));
+      return nextRun;
+    });
+  }
+
+  return NextResponse.json(
+    { server, copiedDocuments: source.documents.length, run },
+    { status: 201 },
+  );
+}