@andreprado/agentkit 0.1.0-alpha.18 → 0.1.0-alpha.19

package/src/runtime/knowledge/retrieve.ts

@@ -108,7 +108,25 @@ async function searchLexical(db: DatabaseRunner, query: string, limit: number):
 }
 
 async function searchLexicalFallback(db: DatabaseRunner, query: string, limit: number): Promise<KnowledgeSearchResult[]> {
-  const like = `%${query.toLowerCase()}%`;
+  const tokens = queryTokens(query);
+
+  if (tokens.length === 0) {
+    return [];
+  }
+
+  const conditions = tokens
+    .map(
+      () => `(
+        lower(c.content) LIKE ? ESCAPE '\\'
+        OR lower(COALESCE(c.title, '')) LIKE ? ESCAPE '\\'
+        OR lower(COALESCE(c.section, '')) LIKE ? ESCAPE '\\'
+      )`,
+    )
+    .join(" AND ");
+  const args = tokens.flatMap((token) => {
+    const like = likePattern(token);
+    return [like, like, like];
+  });
   const result = await db.query(
     `
     SELECT
@@ -121,13 +139,11 @@ async function searchLexicalFallback(db: DatabaseRunner, query: string, limit: n
       s.source_key AS source_key
     FROM agentkit_knowledge_chunks c
     JOIN agentkit_knowledge_sources s ON s.id = c.source_id
-    WHERE lower(c.content) LIKE ?
-      OR lower(COALESCE(c.title, '')) LIKE ?
-      OR lower(COALESCE(c.section, '')) LIKE ?
+    WHERE ${conditions}
     ORDER BY c.created_at DESC, c.ordinal ASC
     LIMIT ?
   `,
-    [like, like, like, limit],
+    [...args, limit],
   );
 
   return result.rows.map((row, index) => knowledgeSearchResultFromRow(row, lexicalScore(index), null));
@@ -269,6 +285,10 @@ function queryTokens(query: string): string[] {
   return Array.from(new Set(query.toLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? [])).slice(0, 12);
 }
 
+function likePattern(token: string): string {
+  return `%${token.replace(/[\\%_]/g, (value) => `\\${value}`)}%`;
+}
+
 function parseEmbedding(value: unknown): number[] | null {
   if (typeof value !== "string") {
     return null;

package/src/runtime/knowledge/schema.ts

@@ -1,6 +1,12 @@
 export const KNOWLEDGE_MIGRATION_ID = "0006_create_knowledge_tables";
 
-export const KNOWLEDGE_SCHEMA_SQL = `
+type KnowledgeSchemaDatabase = {
+  exec(sql: string): unknown;
+};
+
+export type KnowledgeLexicalIndexMode = "fts5" | "fallback";
+
+export const KNOWLEDGE_BASE_SCHEMA_SQL = `
   CREATE TABLE IF NOT EXISTS agentkit_knowledge_sources (
     id TEXT PRIMARY KEY,
     source_key TEXT NOT NULL UNIQUE,
@@ -43,7 +49,9 @@ export const KNOWLEDGE_SCHEMA_SQL = `
 
   CREATE INDEX IF NOT EXISTS agentkit_knowledge_chunks_source_ordinal_idx
     ON agentkit_knowledge_chunks(source_id, ordinal);
+`;
 
+export const KNOWLEDGE_FTS5_SCHEMA_SQL = `
   CREATE VIRTUAL TABLE IF NOT EXISTS agentkit_knowledge_fts
     USING fts5(
       chunk_id UNINDEXED,
@@ -54,3 +62,39 @@ export const KNOWLEDGE_SCHEMA_SQL = `
       tokenize='unicode61'
     );
 `;
+
+export const KNOWLEDGE_FTS_FALLBACK_SCHEMA_SQL = `
+  CREATE TABLE IF NOT EXISTS agentkit_knowledge_fts (
+    chunk_id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL,
+    title TEXT,
+    section TEXT,
+    content TEXT NOT NULL
+  );
+
+  CREATE INDEX IF NOT EXISTS agentkit_knowledge_fts_source_idx
+    ON agentkit_knowledge_fts(source_id);
+`;
+
+export const KNOWLEDGE_SCHEMA_SQL = `${KNOWLEDGE_BASE_SCHEMA_SQL}\n${KNOWLEDGE_FTS5_SCHEMA_SQL}`;
+
+export function applyKnowledgeSchema(db: KnowledgeSchemaDatabase): KnowledgeLexicalIndexMode {
+  db.exec(KNOWLEDGE_BASE_SCHEMA_SQL);
+
+  try {
+    db.exec(KNOWLEDGE_FTS5_SCHEMA_SQL);
+    return "fts5";
+  } catch (error) {
+    if (!isMissingFts5ModuleError(error)) {
+      throw error;
+    }
+  }
+
+  db.exec(KNOWLEDGE_FTS_FALLBACK_SCHEMA_SQL);
+  return "fallback";
+}
+
+function isMissingFts5ModuleError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /no such module:\s*fts5/i.test(message) || /unknown module:\s*fts5/i.test(message);
+}

package/src/runtime/runtime-contract.ts

@@ -35,6 +35,60 @@ export async function assertRuntimeContract(
   expect(inspect.status).toBe(200);
   expect(inspect.body).toMatchObject({ agent: options.expectedAgentName });
 
+  if (options.auth) {
+    const missingAdmin = await fetchJson(`${baseUrl}/_agentkit`);
+    expect(missingAdmin.status).toBe(401);
+    expect(missingAdmin.body.error.code).toBe("unauthorized");
+
+    const invalidAdmin = await fetchJson(`${baseUrl}/_agentkit`, {
+      headers: { Authorization: "Bearer invalid-admin-token" },
+    });
+    expect(invalidAdmin.status).toBe(401);
+    expect(invalidAdmin.body.error.code).toBe("unauthorized");
+
+    const missingChat = await fetchJson(`${baseUrl}/chat`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ message: "hello" }),
+    });
+    expect(missingChat.status).toBe(401);
+    expect(missingChat.body.error.code).toBe("unauthorized");
+
+    const invalidChat = await fetchJson(`${baseUrl}/chat`, {
+      method: "POST",
+      headers: { "content-type": "application/json", Authorization: "Bearer invalid-chat-token" },
+      body: JSON.stringify({ message: "hello" }),
+    });
+    expect(invalidChat.status).toBe(401);
+    expect(invalidChat.body.error.code).toBe("unauthorized");
+
+    const missingTool = await fetchJson(`${baseUrl}/tools/${encodeURIComponent(options.tool.name)}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ input: options.tool.input }),
+    });
+    expect(missingTool.status).toBe(401);
+    expect(missingTool.body.error.code).toBe("unauthorized");
+
+    const invalidTool = await fetchJson(`${baseUrl}/tools/${encodeURIComponent(options.tool.name)}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", Authorization: "Bearer invalid-admin-token" },
+      body: JSON.stringify({ input: options.tool.input }),
+    });
+    expect(invalidTool.status).toBe(401);
+    expect(invalidTool.body.error.code).toBe("unauthorized");
+
+    const missingConversations = await fetchJson(`${baseUrl}/v1/conversations`);
+    expect(missingConversations.status).toBe(401);
+    expect(missingConversations.body.error.code).toBe("unauthorized");
+
+    const invalidConversations = await fetchJson(`${baseUrl}/v1/conversations`, {
+      headers: { Authorization: "Bearer invalid-admin-token" },
+    });
+    expect(invalidConversations.status).toBe(401);
+    expect(invalidConversations.body.error.code).toBe("unauthorized");
+  }
+
   const unauthorized = await fetchJson(`${baseUrl}/chat`, {
     method: "POST",
     headers: withHeaders({ "content-type": "application/json" }, options.auth?.chat),