@gmickel/gno 1.19.0 → 1.20.0

package/src/serve/public/pages/Ask.tsx

@@ -21,6 +21,10 @@ import {
   SourcesTrigger,
 } from "../components/ai-elements/sources";
 import { AIModelSelector } from "../components/AIModelSelector";
+import {
+  type AskVerification,
+  AskVerificationPanel,
+} from "../components/AskVerificationPanel";
 import {
   ThoroughnessSelector,
   type Thoroughness,
@@ -57,6 +61,7 @@ interface PageProps {
 }
 
 interface Citation {
+  evidenceId?: string;
   docid: string;
   uri: string;
   startLine?: number;
@@ -88,12 +93,15 @@ interface AskResponse {
     vectorsUsed: boolean;
     answerGenerated: boolean;
     totalResults: number;
+    verificationRequested?: boolean;
+    abstained?: boolean;
     queryModes?: {
       term: number;
       intent: number;
       hyde: boolean;
     };
   };
+  verification?: AskVerification;
 }
 
 interface Capabilities {
@@ -139,7 +147,7 @@ function renderAnswer(
   const parts: React.ReactNode[] = [];
   let key = 0;
 
-  const citationRegex = /\[(\d+)\]/g;
+  const citationRegex = /\[(?:evidence:([a-f0-9]{64})|(\d+))\]/g;
   let lastIndex = 0;
   let match: RegExpExecArray | null;
 
@@ -149,8 +157,13 @@ function renderAnswer(
       parts.push(answer.slice(lastIndex, match.index));
     }
 
-    const citationNum = Number(match[1]);
-    const citation = citations[citationNum - 1];
+    const evidenceId = match[1];
+    const numericCitation = match[2] ? Number(match[2]) : undefined;
+    const citationIndex = evidenceId
+      ? citations.findIndex((citation) => citation.evidenceId === evidenceId)
+      : (numericCitation ?? 0) - 1;
+    const citationNum = citationIndex + 1;
+    const citation = citations[citationIndex];
 
     if (citation) {
       parts.push(
@@ -186,6 +199,7 @@ export default function Ask({ navigate }: PageProps) {
   const [collections, setCollections] = useState<Collection[]>([]);
   const [thoroughness, setThoroughness] = useState<Thoroughness>("balanced");
   const [activePreset, setActivePreset] = useState("slim-tuned");
+  const [verify, setVerify] = useState(false);
 
   const [showAdvanced, setShowAdvanced] = useState(false);
   const [selectedCollection, setSelectedCollection] = useState("");
@@ -318,6 +332,7 @@ export default function Ask({ navigate }: PageProps) {
       const requestBody: Record<string, unknown> = {
         query: currentQuery,
         limit: 5,
+        verify,
       };
 
       if (selectedCollection) {
@@ -394,6 +409,7 @@ export default function Ask({ navigate }: PageProps) {
       tagsInput,
       thoroughness,
       until,
+      verify,
     ]
   );
 
@@ -443,6 +459,7 @@ export default function Ask({ navigate }: PageProps) {
     parseTagsCsv(tagsInput).length > 0
       ? `${tagMode}:${parseTagsCsv(tagsInput).join(",")}`
       : null,
+    verify ? "verified" : null,
   ].filter((pill): pill is string => Boolean(pill));
 
   return (
@@ -475,6 +492,16 @@ export default function Ask({ navigate }: PageProps) {
               value={thoroughness}
             />
 
+            <Button
+              aria-pressed={verify}
+              onClick={() => setVerify((value) => !value)}
+              size="sm"
+              type="button"
+              variant={verify ? "default" : "outline"}
+            >
+              Verify
+            </Button>
+
             <div className="h-6 w-px bg-border/40" />
 
             <AIModelSelector onPresetChange={setActivePreset} />
@@ -878,8 +905,19 @@ export default function Ask({ navigate }: PageProps) {
                         </Sources>
                       )}
 
+                    {entry.response.verification && (
+                      <AskVerificationPanel
+                        navigate={navigate}
+                        verification={entry.response.verification}
+                      />
+                    )}
+
                     <div className="flex items-center gap-2 text-muted-foreground/60 text-xs">
-                      <span>{entry.response.results.length} results</span>
+                      <span>
+                        {entry.response.verification
+                          ? `${entry.response.verification.capsule.evidence.length} evidence spans`
+                          : `${entry.response.results.length} results`}
+                      </span>
                       {entry.response.meta.vectorsUsed && (
                         <Badge
                           className="font-mono text-[9px]"

package/src/serve/routes/api.ts

@@ -36,6 +36,7 @@ import type { StartJobError } from "../jobs";
 import type { ResidentStatus } from "../status-model";
 import type { CollectionWatchService } from "../watch-service";
 
+import { buildVerifiedAsk } from "../../app/verified-ask";
 import { modelsPull } from "../../cli/commands/models/pull";
 import {
   addCollection,
@@ -125,6 +126,7 @@ import {
   resolveModelUri,
 } from "../../llm/registry";
 import {
+  answerTraceTerminalStatus,
   generateGroundedAnswer,
   processAnswerResultWithTrace,
 } from "../../pipeline/answer";
@@ -289,14 +291,46 @@ export interface AskRequestBody {
   category?: string;
   author?: string;
   maxAnswerTokens?: number;
+  verify?: boolean;
+  contextBudgetTokens?: number;
+  contextBudgetBytes?: number;
+  minScore?: number;
   noExpand?: boolean;
   noRerank?: boolean;
+  graph?: boolean;
+  noGraph?: boolean;
   /** Comma-separated tags - filter to docs having ALL (AND) */
   tagsAll?: string;
   /** Comma-separated tags - filter to docs having ANY (OR) */
   tagsAny?: string;
 }
 
+const ASK_REQUEST_KEYS = new Set<keyof AskRequestBody>([
+  "query",
+  "limit",
+  "collection",
+  "lang",
+  "intent",
+  "candidateLimit",
+  "exclude",
+  "queryModes",
+  "since",
+  "until",
+  "category",
+  "author",
+  "maxAnswerTokens",
+  "verify",
+  "contextBudgetTokens",
+  "contextBudgetBytes",
+  "minScore",
+  "noExpand",
+  "noRerank",
+  "graph",
+  "noGraph",
+  "tagsAll",
+  "tagsAny",
+]);
+
 export interface CreateCollectionRequestBody {
   path: string;
   name?: string;
@@ -512,11 +546,12 @@ async function startRestTrace(
 async function finishRestTrace(
   request: Request,
   session: RetrievalTraceSession | null,
-  status: "completed" | "partial" | "failed",
+  status: "completed" | "partial" | "failed" | "cancelled",
   response: Response
 ): Promise<Response> {
   if (!session) return response;
-  const terminalStatus = request.signal.aborted ? "cancelled" : status;
+  const terminalStatus =
+    request.signal.aborted || status === "cancelled" ? "cancelled" : status;
   const finished = await session.finish(terminalStatus);
   if (!finished.ok) {
     return withRetrievalTraceHeader(
@@ -3503,6 +3538,9 @@ export async function handleSearch(
     return errorResponse("VALIDATION", "Invalid JSON body");
   }
 
+  if (body === null || typeof body !== "object" || Array.isArray(body)) {
+    return errorResponse("VALIDATION", "Request body must be an object");
+  }
   if (!body.query || typeof body.query !== "string") {
     return errorResponse("VALIDATION", "Missing or invalid query");
   }
@@ -4028,15 +4066,84 @@ export async function handleAsk(
     return errorResponse("VALIDATION", "Invalid JSON body");
   }
 
+  if (body === null || typeof body !== "object" || Array.isArray(body)) {
+    return errorResponse("VALIDATION", "Request body must be an object");
+  }
+  const unknownKey = Object.keys(body).find(
+    (key) => !ASK_REQUEST_KEYS.has(key as keyof AskRequestBody)
+  );
+  if (unknownKey) {
+    return errorResponse(
+      "VALIDATION",
+      `Unknown Ask request field: ${unknownKey}`
+    );
+  }
   if (!body.query || typeof body.query !== "string") {
     return errorResponse("VALIDATION", "Missing or invalid query");
   }
 
+  for (const field of [
+    "verify",
+    "noExpand",
+    "noRerank",
+    "graph",
+    "noGraph",
+  ] as const) {
+    if (body[field] !== undefined && typeof body[field] !== "boolean") {
+      return errorResponse("VALIDATION", `${field} must be a boolean`);
+    }
+  }
+  for (const [field, value, maximum] of [
+    ["limit", body.limit, 20],
+    ["candidateLimit", body.candidateLimit, 100],
+    ["maxAnswerTokens", body.maxAnswerTokens, Number.MAX_SAFE_INTEGER],
+  ] as const) {
+    if (
+      value !== undefined &&
+      (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+    ) {
+      return errorResponse(
+        "VALIDATION",
+        `${field} must be a positive integer${maximum < Number.MAX_SAFE_INTEGER ? ` no greater than ${maximum}` : ""}`
+      );
+    }
+  }
+
   const rawQuery = body.query.trim();
   if (!rawQuery) {
     return errorResponse("VALIDATION", "Query cannot be empty");
   }
 
+  if (
+    body.minScore !== undefined &&
+    (typeof body.minScore !== "number" ||
+      !Number.isFinite(body.minScore) ||
+      body.minScore < 0 ||
+      body.minScore > 1)
+  ) {
+    return errorResponse("VALIDATION", "minScore must be between 0 and 1");
+  }
+  if (
+    body.contextBudgetTokens !== undefined &&
+    (!Number.isSafeInteger(body.contextBudgetTokens) ||
+      body.contextBudgetTokens < 1)
+  ) {
+    return errorResponse(
+      "VALIDATION",
+      "contextBudgetTokens must be a positive integer"
+    );
+  }
+  if (
+    body.contextBudgetBytes !== undefined &&
+    (!Number.isSafeInteger(body.contextBudgetBytes) ||
+      body.contextBudgetBytes < 1)
+  ) {
+    return errorResponse(
+      "VALIDATION",
+      "contextBudgetBytes must be a positive integer"
+    );
+  }
+
   // Parse tag filters
   let tagsAll: string[] | undefined;
   let tagsAny: string[] | undefined;
@@ -4128,6 +4235,7 @@ export async function handleAsk(
     collection: body.collection,
     lang: body.lang,
     intent: body.intent?.trim() || undefined,
+    minScore: body.minScore,
     noExpand: body.noExpand,
     noRerank: body.noRerank,
     candidateLimit:
@@ -4135,6 +4243,8 @@ export async function handleAsk(
         ? Math.min(body.candidateLimit, 100)
         : undefined,
     exclude,
+    graph: body.graph,
+    noGraph: body.noGraph,
     queryModes: normalizedQueryModes,
     tagsAll,
     tagsAny,
@@ -4142,6 +4252,10 @@ export async function handleAsk(
     until: body.until,
     categories,
     author,
+    verify: body.verify,
+    contextBudgetTokens: body.contextBudgetTokens,
+    contextBudgetBytes: body.contextBudgetBytes,
+    maxAnswerTokens: body.maxAnswerTokens,
   };
   const trace = await startRestTrace(ctx, {
     query: normalizedQuery,
@@ -4166,7 +4280,7 @@ export async function handleAsk(
       return finishRestTrace(
         req,
         trace.session,
-        "failed",
+        req.signal.aborted ? "cancelled" : "failed",
         errorResponse("RUNTIME", unavailable.error.message, 500)
       );
     }
@@ -4182,6 +4296,38 @@ export async function handleAsk(
     );
   }
 
+  if (body.verify && ctx.answerPort) {
+    try {
+      const verified = await buildVerifiedAsk(normalizedQuery, askOptions, {
+        store: ctx.store,
+        config: ctx.config,
+        indexName: ctx.indexName,
+        vectorIndex: ctx.vectorIndex,
+        embedPort: ctx.embedPort,
+        rerankPort: ctx.rerankPort,
+        genPort: ctx.answerPort,
+        traceSession: trace.session ?? undefined,
+      });
+      return finishRestTrace(
+        req,
+        trace.session,
+        answerTraceTerminalStatus(verified.citations),
+        jsonResponse(verified)
+      );
+    } catch (error) {
+      return finishRestTrace(
+        req,
+        trace.session,
+        "failed",
+        errorResponse(
+          "RUNTIME",
+          error instanceof Error ? error.message : String(error),
+          500
+        )
+      );
+    }
+  }
+
   // Run hybrid search first
   const searchResult = await searchHybrid(
     {