Reverse refactor, use hono/client

Mostly taming errors unsure if anything works

Author: bfollington

typescript/packages/toolshed/lib/behavior/agent.ts renamed to typescript/packages/toolshed/lib/agent.ts

@@ -0,0 +1,17 @@
+export async function handleResponse<T>(response: Response): Promise<T> {
+  const data = await response.json();
+
+  if ('error' in data) {
+    throw new Error(data.error);
+  }
+
+  if (data.type === 'json') {
+    return data.body;
+  }
+
+  if (data instanceof Response) {
+    throw new Error(data.statusText);
+  }
+
+  return null as never;
+}

typescript/packages/toolshed/lib/response.ts

@@ -16,15 +16,15 @@ import type { Context } from "hono";
 export interface GenerateTextParams {
   model?: string;
   task?: string;
-  messages: { role: string; content: string }[];
+  messages: { role: 'user' | 'assistant'; content: string }[];
   system?: string;
   stream?: boolean;
   stop_token?: string;
   abortSignal?: AbortSignal;
 }
 
 export interface GenerateTextResult {
-  message: { role: string; content: string };
+  message: { role: 'user' | 'assistant'; content: string };
   stream?: ReadableStream;
 }
 
@@ -48,15 +48,15 @@ export async function generateText(
   }
 
   // Validate and configure model
-  const modelConfig = findModel(modelName);
+  const modelConfig = findModel(modelName!);
   if (!modelConfig) {
     console.error("Unsupported model:", modelName);
     throw new Error(`Unsupported model: ${modelName}`);
   }
 
   const messages = params.messages;
   const streamParams = {
-    model: modelConfig.model || modelName,
+    model: modelConfig.model || modelName!,
     messages,
     stream: params.stream,
     system: params.system,

typescript/packages/toolshed/lib/behavior/schema-match.ts renamed to typescript/packages/toolshed/lib/schema-match.ts

@@ -0,0 +1,20 @@
+import { AppType } from "@/app.ts";
+import { hc } from "hono/client";
+import { handleResponse } from "@/lib/response.ts";
+
+const client = hc<AppType>("http://localhost:8000/");
+
+export async function generateText(query: Parameters<typeof client.api.ai.llm.$post>[0]["json"]) {
+  const res = await client.api.ai.llm.$post({ json: query });
+  return handleResponse<{ content: string, role: string }>(res).then(data => data.content);
+}
+
+export async function getAllBlobs(): Promise<string[]> {
+  const res = await client.api.storage.blobby.get$();
+  return handleResponse(res);
+}
+
+export async function getBlob(key: string): Promise<string> {
+  const res = await client.api.storage.blobby.get$(key);
+  return handleResponse(res);
+}

typescript/packages/toolshed/lib/llm/cache.ts renamed to typescript/packages/toolshed/routes/ai/llm/cache.ts

@@ -1,11 +1,10 @@
 import { BehaviourTree, State } from "mistreevous";
-import { BaseAgent } from "./agent.ts";
+import { BaseAgent } from "@/lib/agent.ts";
 import { scanForKey } from "./strategies/scanForKey.ts";
 import { scanForText } from "./strategies/scanForText.ts";
 import { generateSchema, scanBySchema } from "./strategies/scanBySchema.ts";
 import { scanByCollections } from "./strategies/scanByCollections.ts";
-import { Logger } from "../prefixed-logger.ts";
-import type { RedisClientType } from "redis";
+import { Logger } from "@/lib/prefixed-logger.ts";
 
 export interface SearchResult {
   source: string;
@@ -47,12 +46,10 @@ class SearchAgent extends BaseAgent {
   private query: string = "";
   private results: SearchResult[] = [];
   private searchPromises: Map<string, Promise<SearchResult>> = new Map();
-  private redis: RedisClientType;
 
-  constructor(query: string, redis: RedisClientType, logger: Logger) {
+  constructor(query: string, logger: Logger) {
     super(logger, "SearchAgent");
     this.query = query;
-    this.redis = redis;
     this.resetSearch();
   }
 
@@ -77,7 +74,7 @@ class SearchAgent extends BaseAgent {
         this.logger.info("Starting key match search");
         this.searchPromises.set(
           "key-search",
-          scanForKey(this.query, this.redis, this.logger),
+          scanForKey(this.query, this.logger),
         );
       }
       return await resolve(State.SUCCEEDED);
@@ -90,7 +87,7 @@ class SearchAgent extends BaseAgent {
         this.logger.info("Starting text match search");
         this.searchPromises.set(
           "text-search",
-          scanForText(this.query, this.redis, this.logger),
+          scanForText(this.query, this.logger),
         );
       }
       return await resolve(State.SUCCEEDED);
@@ -106,7 +103,7 @@ class SearchAgent extends BaseAgent {
 
         this.searchPromises.set(
           "schema-match",
-          scanBySchema(schema, this.redis, this.logger),
+          scanBySchema(schema, this.logger),
         );
       }
       return await resolve(State.SUCCEEDED);
@@ -119,7 +116,7 @@ class SearchAgent extends BaseAgent {
         this.logger.info("Starting collection match search");
         this.searchPromises.set(
           "collection-match",
-          scanByCollections(this.query, this.redis, this.logger),
+          scanByCollections(this.query, this.logger),
         );
       }
       return await resolve(State.SUCCEEDED);
@@ -171,11 +168,10 @@ class SearchAgent extends BaseAgent {
 
 export function performSearch(
   query: string,
-  redis: RedisClientType,
   logger: Logger,
 ): Promise<CombinedResults> {
   return new Promise((resolve, reject) => {
-    const agent = new SearchAgent(query, redis, logger);
+    const agent = new SearchAgent(query, logger);
     const tree = new BehaviourTree(searchTreeDefinition, agent);
 
     logger.info("Starting behavior tree execution");

typescript/packages/toolshed/lib/llm/generateText.ts renamed to typescript/packages/toolshed/routes/ai/llm/generateText.ts

@@ -1,33 +1,25 @@
-import { storage } from "@/storage.ts";
 import { SearchResult } from "../search.ts";
-import { Logger, PrefixedLogger } from "../../prefixed-logger.ts";
-import { generateText } from "../../llm/generateText.ts";
-import type { RedisClientType } from "redis";
+import { Logger, PrefixedLogger } from "@/lib/prefixed-logger.ts";
+import { generateText, getBlob} from "../effects.ts";
 
 async function generateKeywords(
   query: string,
   logger: Logger,
 ): Promise<string[]> {
   logger.info(`Generating keywords for query: ${query}`);
-
   const keywordPrompt = {
     model: "claude-3-5-sonnet",
     messages: [
       {
-        role: "system",
-        content:
-          "Generate exactly 3 single-word collection names that would be relevant for organizing content related to this query. Return only a JSON array of 3 strings.",
-      },
-      {
-        role: "user",
+        role: "user" as const,
         content: query,
       },
     ],
+    system: "Generate exactly 3 single-word collection names that would be relevant for organizing content related to this query. Return only a JSON array of 3 strings.",
     stream: false,
   };
-
   const keywordText = await generateText(keywordPrompt);
-  const keywords = JSON.parse(keywordText.message.content);
+  const keywords = JSON.parse(keywordText);
 
   // Add original query if it's a single word
   if (query.trim().split(/\s+/).length === 1) {
@@ -40,7 +32,6 @@ async function generateKeywords(
 
 export async function scanByCollections(
   query: string,
-  redis: RedisClientType,
   logger: Logger,
 ): Promise<SearchResult> {
   const prefixedLogger = new PrefixedLogger(logger, "scanByCollections");
@@ -58,7 +49,7 @@ export async function scanByCollections(
 
   for (const collectionKey of collectionKeys) {
     try {
-      const content = await storage.getBlob(collectionKey);
+      const content = await getBlob(collectionKey);
       if (!content) {
         prefixedLogger.info(
           `No content found for collection: ${collectionKey}`,
@@ -69,7 +60,7 @@ export async function scanByCollections(
       const keys = JSON.parse(content);
       for (const key of keys) {
         try {
-          const blobContent = await storage.getBlob(key);
+          const blobContent = await getBlob(key);
           if (blobContent) {
             matchingExamples.push({
               key,

typescript/packages/toolshed/lib/llm/models.ts renamed to typescript/packages/toolshed/routes/ai/llm/models.ts

@@ -1,10 +1,9 @@
-import { getAllBlobs } from "@/lib/redis/redis.ts";
-import { storage } from "@/storage.ts";
-import { checkSchemaMatch } from "../schema-match.ts";
+import { checkSchemaMatch } from "@/lib/schema-match.ts";
 import { SearchResult } from "../search.ts";
-import { Logger, PrefixedLogger } from "../../prefixed-logger.ts";
-import { generateText } from "../../llm/generateText.ts";
+import { Logger, PrefixedLogger } from "@/lib/prefixed-logger.ts";
 import type { RedisClientType } from "redis";
+import { generateText, getBlob, getAllBlobs } from "../effects.ts";
+import { Schema } from 'jsonschema'
 
 export async function generateSchema(
   query: string,
@@ -16,33 +15,28 @@ export async function generateSchema(
     model: "claude-3-5-sonnet",
     messages: [
       {
-        role: "system",
-        content:
-          "Generate a minimal JSON schema to match data that relates to this search query, aim for the absolute minimal number of fields that cature the essence of the data. (e.g. articles are really just title and url) Return only valid JSON schema.",
-      },
-      {
-        role: "user",
+        role: "user" as const,
         content: query,
       },
     ],
+    system: "Generate a minimal JSON schema to match data that relates to this search query, aim for the absolute minimal number of fields that cature the essence of the data. (e.g. articles are really just title and url) Return only valid JSON schema.",
     stream: false,
   };
 
   const schemaText = await generateText(schemaPrompt);
-  const schema = JSON.parse(schemaText.message.content);
+  const schema = JSON.parse(schemaText);
   prefixedLogger.info(`Generated schema:\n${JSON.stringify(schema, null, 2)}`);
   return schema;
 }
 
 export async function scanBySchema(
   schema: unknown,
-  redis: RedisClientType,
   logger: Logger,
 ): Promise<SearchResult> {
   const prefixedLogger = new PrefixedLogger(logger, "scanBySchema");
   prefixedLogger.info("Starting schema scan");
   prefixedLogger.info(`Using schema:\n${JSON.stringify(schema, null, 2)}`);
-  const allBlobs = await getAllBlobs(redis);
+  const allBlobs = await getAllBlobs();
   prefixedLogger.info(`Retrieved ${allBlobs.length} blobs to scan`);
 
   const matchingExamples: Array<{
@@ -52,14 +46,14 @@ export async function scanBySchema(
 
   for (const blobKey of allBlobs) {
     try {
-      const content = await storage.getBlob(blobKey);
+      const content = await getBlob(blobKey);
       if (!content) {
         prefixedLogger.info(`No content found for key: ${blobKey}`);
         continue;
       }
 
       const blobData = JSON.parse(content);
-      const matches = checkSchemaMatch(blobData, schema);
+      const matches = checkSchemaMatch(blobData, schema as Schema);
 
       if (matches) {
         matchingExamples.push({