@soederpop/luca 0.1.2 → 0.2.1

package/src/selector.ts

@@ -135,17 +135,17 @@ export class Selector<
 		}
 
 		// Run the selector
-		this.state.set('running' as any, true)
+		this.state.set('running' as any, true as any)
 		this.emit('started' as any)
 
 		let data: any
 		try {
 			data = await this.run(parsed, this.context)
-			this.state.set('running' as any, false)
-			this.state.set('lastRanAt' as any, Date.now())
+			this.state.set('running' as any, false as any)
+			this.state.set('lastRanAt' as any, Date.now() as any)
 			this.emit('completed' as any, data)
 		} catch (err: any) {
-			this.state.set('running' as any, false)
+			this.state.set('running' as any, false as any)
 			this.emit('failed' as any, err)
 			throw err
 		}
@@ -197,6 +197,76 @@ export class SelectorsRegistry extends Registry<Selector<any>> {
 	override scope = 'selectors'
 	override baseClass = Selector as any
 
+	/**
+	 * Convert all registered selectors into a `{ schemas, handlers }` object
+	 * compatible with `assistant.use()`.
+	 *
+	 * Each selector becomes a tool whose parameters come from the selector's
+	 * `argsSchema` (with internal fields stripped) and whose handler dispatches
+	 * the selector and returns the data directly (cache metadata is not exposed).
+	 *
+	 * @param container - The container used to instantiate and run selectors
+	 * @param options - Optional filter/transform options
+	 * @param options.include - Only include these selector names (default: all)
+	 * @param options.exclude - Exclude these selector names (default: none)
+	 * @param options.prefix - Prefix tool names (e.g. 'sel_' → 'sel_packageInfo')
+	 */
+	toTools(
+		container: Container<any> & SelectorsInterface,
+		options?: { include?: string[], exclude?: string[], prefix?: string },
+	): { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> } {
+		const schemas: Record<string, z.ZodType> = {}
+		const handlers: Record<string, Function> = {}
+		const prefix = options?.prefix ?? ''
+		const includeSet = options?.include ? new Set(options.include) : null
+		const excludeSet = new Set(options?.exclude ?? [])
+
+		// Internal fields from HelperOptionsSchema and SelectorOptionsSchema
+		const internalFields = ['name', '_cacheKey', 'dispatchSource']
+
+		for (const name of this.available) {
+			if (excludeSet.has(name)) continue
+			if (includeSet && !includeSet.has(name)) continue
+
+			const Sel = this.lookup(name) as typeof Selector
+			const rawSchema = Sel.argsSchema
+			const description = Sel.selectorDescription || Sel.description || name
+
+			let toolSchema: z.ZodType
+			try {
+				const shape = typeof (rawSchema as any)?._def?.shape === 'function'
+					? (rawSchema as any)._def.shape()
+					: (rawSchema as any)?._def?.shape
+
+				if (shape) {
+					const cleanShape: Record<string, z.ZodType> = {}
+					for (const [key, val] of Object.entries(shape)) {
+						if (internalFields.includes(key)) continue
+						cleanShape[key] = val as z.ZodType
+					}
+
+					toolSchema = Object.keys(cleanShape).length > 0
+						? z.object(cleanShape).describe(description)
+						: z.object({}).describe(description)
+				} else {
+					toolSchema = z.object({}).describe(description)
+				}
+			} catch {
+				toolSchema = z.object({}).describe(description)
+			}
+
+			const toolName = `${prefix}${name}`
+			schemas[toolName] = toolSchema
+			handlers[toolName] = async (args: Record<string, any>) => {
+				const sel = (container.select as any)(name)
+				const result = await sel.select(args ?? {})
+				return result.data
+			}
+		}
+
+		return { schemas, handlers }
+	}
+
 	/**
 	 * Discover and register selectors from a directory.
 	 * Detection order:

package/src/server.ts

@@ -30,7 +30,7 @@ export class Server<T extends ServerState = ServerState, K extends ServerOptions
     static override eventsSchema = ServerEventsSchema
 
     /** Self-register a Server subclass from a static initialization block. */
-    static register: (SubClass: typeof Server, id?: string) => typeof Server
+    static register: (SubClass: abstract new (options: any, context: any) => Server, id?: string) => abstract new (options: any, context: any) => Server
 
     override get initialState() : T {
       return ({
@@ -203,7 +203,7 @@ export const helperCache = new Map()
  * ```
  */
 Server.register = function registerServer(
-  SubClass: typeof Server,
+  SubClass: abstract new (options: any, context: any) => Server,
   id?: string,
 ) {
   const registryId = id ?? SubClass.name[0]!.toLowerCase() + SubClass.name.slice(1)

package/src/servers/mcp.ts

@@ -33,9 +33,9 @@ export type MCPContext = {
 export interface RegisteredTool {
   name: string
   description?: string
-  schema?: z.ZodObject<any>
+  schema?: z.ZodType
   jsonSchema?: Record<string, any>
-  handler: (args: any, ctx: MCPContext) => any
+  handler: Function
 }
 
 /** A registered MCP resource with its URI, metadata, and handler. */
@@ -61,9 +61,9 @@ export type PromptMessage = {
 }
 
 type ToolRegistrationOptions = {
-  schema?: z.ZodObject<any>
+  schema?: z.ZodType
   description?: string
-  handler: (args: any, ctx: MCPContext) => any
+  handler?: Function | ((args: any, ctx: any) => any)
 }
 
 type ResourceRegistrationOptions = {
@@ -340,7 +340,7 @@ export class MCPServer extends Server<MCPServerState, MCPServerOptions> {
    * @param name - Unique tool name
    * @param options - Tool schema, description, and handler
    */
-  tool(name: string, options: ToolRegistrationOptions): this {
+  override tool(name: string, options: ToolRegistrationOptions): this {
     let jsonSchema: Record<string, any> | undefined
 
     if (options.schema) {
@@ -357,7 +357,7 @@ export class MCPServer extends Server<MCPServerState, MCPServerOptions> {
       description: options.description,
       schema: options.schema,
       jsonSchema,
-      handler: options.handler,
+      handler: options.handler ?? (() => {}),
     }
 
     this._tools.set(name, registered)

package/src/web/features/helpers.ts

@@ -136,7 +136,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
         return {}
       }
 
-      const manifest: Manifest = await response.json()
+      const manifest = await response.json() as Manifest
       this._manifest = manifest
       this.state.set('manifestLoaded', true)
       this.emit('manifestLoaded' as any, manifest)

package/src/web/features/network.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { Feature } from "../feature.js";

package/test/assistant.test.ts

@@ -15,18 +15,27 @@ describe('Assistant', () => {
 			expect(assistant.systemPrompt).toContain('coding assistant')
 		})
 
-		it('loads tools from tools.ts via the VM', () => {
-			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+		it('loads tools from codingTools feature after start', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+			await assistant.start()
 			const tools = assistant.availableTools
 			expect(tools).toContain('rg')
 			expect(tools).toContain('ls')
 			expect(tools).toContain('cat')
-			expect(tools).toContain('pwd')
 			expect(tools.length).toBeGreaterThan(0)
 		})
 
-		it('tools have descriptions and parameter schemas', () => {
-			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+		it('tools have descriptions and parameter schemas', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+			await assistant.start()
 			const { rg, ls, cat } = assistant.tools
 			expect(rg.description.length).toBeGreaterThan(0)
 			expect(rg.parameters.type).toBe('object')

package/test/conversation.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, beforeEach } from 'bun:test'
+import { AGIContainer } from '../src/agi/container.server'
+import type { Conversation } from '../src/agi/features/conversation'
+
+function makeConversation(opts: Record<string, any> = {}): Conversation {
+	const container = new AGIContainer()
+	return container.feature('conversation', { model: 'gpt-5', ...opts }) as Conversation
+}
+
+describe('Conversation', () => {
+	describe('state', () => {
+		it('initializes with empty messages when no history provided', () => {
+			const conv = makeConversation()
+			expect(conv.messages).toEqual([])
+		})
+
+		it('seeds message history from options', () => {
+			const history = [{ role: 'system', content: 'You are helpful.' }]
+			const conv = makeConversation({ history })
+			expect(conv.messages).toHaveLength(1)
+			expect(conv.messages[0]).toEqual(history[0])
+		})
+
+		it('uses provided model', () => {
+			const conv = makeConversation({ model: 'gpt-4.1' })
+			expect(conv.model).toBe('gpt-4.1')
+		})
+
+		it('isStreaming is false initially', () => {
+			const conv = makeConversation()
+			expect(conv.isStreaming).toBe(false)
+		})
+	})
+
+	describe('pushMessage', () => {
+		it('appends to messages', () => {
+			const conv = makeConversation()
+			conv.pushMessage({ role: 'user', content: 'hello' })
+			expect(conv.messages).toHaveLength(1)
+			expect(conv.messages[0]!.role).toBe('user')
+		})
+
+		it('does not mutate prior messages array', () => {
+			const conv = makeConversation()
+			const before = conv.messages
+			conv.pushMessage({ role: 'user', content: 'hi' })
+			expect(conv.messages).not.toBe(before)
+		})
+	})
+
+	describe('tools', () => {
+		it('starts with no tools', () => {
+			const conv = makeConversation()
+			expect(conv.availableTools).toHaveLength(0)
+		})
+
+		it('addTool registers a tool', () => {
+			const conv = makeConversation()
+			conv.addTool('greet', {
+				description: 'Says hello',
+				parameters: { type: 'object', properties: {} },
+				handler: async () => 'hello',
+			})
+			expect(conv.availableTools).toContain('greet')
+		})
+
+		it('removeTool deregisters a tool', () => {
+			const conv = makeConversation()
+			conv.addTool('greet', {
+				description: 'Says hello',
+				parameters: { type: 'object', properties: {} },
+				handler: async () => 'hello',
+			})
+			conv.removeTool('greet')
+			expect(conv.availableTools).not.toContain('greet')
+		})
+
+		it('updateTools merges without replacing unrelated tools', () => {
+			const conv = makeConversation()
+			conv.addTool('a', { description: 'A', parameters: { type: 'object', properties: {} }, handler: async () => 'a' })
+			conv.updateTools({ b: { description: 'B', parameters: { type: 'object', properties: {} }, handler: async () => 'b' } })
+			expect(conv.availableTools).toContain('a')
+			expect(conv.availableTools).toContain('b')
+		})
+
+		it('construction-time tools are available immediately', () => {
+			const conv = makeConversation({
+				tools: {
+					ping: { description: 'Ping', parameters: { type: 'object', properties: {} }, handler: async () => 'pong' }
+				}
+			})
+			expect(conv.availableTools).toContain('ping')
+		})
+	})
+
+	describe('estimateTokens', () => {
+		it('returns a near-zero baseline for empty messages', () => {
+			const conv = makeConversation()
+			expect(conv.estimateTokens()).toBeLessThan(10)
+		})
+
+		it('returns a positive number when messages exist', () => {
+			const conv = makeConversation({
+				history: [{ role: 'user', content: 'What is the capital of France?' }]
+			})
+			expect(conv.estimateTokens()).toBeGreaterThan(0)
+		})
+
+		it('increases as more messages are added', () => {
+			const conv = makeConversation()
+			conv.pushMessage({ role: 'user', content: 'Hello' })
+			const first = conv.estimateTokens()
+			conv.pushMessage({ role: 'assistant', content: 'Hi there, how can I help you today?' })
+			const second = conv.estimateTokens()
+			expect(second).toBeGreaterThan(first)
+		})
+	})
+
+	describe('stub()', () => {
+		it('exact string match returns the stub response', async () => {
+			const conv = makeConversation()
+			conv.stub('ping', 'pong')
+			const result = await conv.ask('ping')
+			expect(result).toBe('pong')
+		})
+
+		it('substring match triggers the stub', async () => {
+			const conv = makeConversation()
+			conv.stub('weather', 'Sunny and 72°F.')
+			const result = await conv.ask('what is the weather today?')
+			expect(result).toBe('Sunny and 72°F.')
+		})
+
+		it('regex match triggers the stub', async () => {
+			const conv = makeConversation()
+			conv.stub(/hello/i, 'Hey there!')
+			const result = await conv.ask('HELLO')
+			expect(result).toBe('Hey there!')
+		})
+
+		it('function response is called on each match', async () => {
+			const conv = makeConversation()
+			let callCount = 0
+			conv.stub('count', () => `call ${++callCount}`)
+			expect(await conv.ask('count')).toBe('call 1')
+			expect(await conv.ask('count')).toBe('call 2')
+		})
+
+		it('first matching stub wins', async () => {
+			const conv = makeConversation()
+			conv.stub('hello', 'first')
+			conv.stub('hello', 'second')
+			expect(await conv.ask('hello')).toBe('first')
+		})
+
+		it('appends user and assistant messages to history', async () => {
+			const conv = makeConversation()
+			conv.stub('hi', 'hello back')
+			await conv.ask('hi')
+			expect(conv.messages).toHaveLength(2)
+			expect(conv.messages[0]).toMatchObject({ role: 'user', content: 'hi' })
+			expect(conv.messages[1]).toMatchObject({ role: 'assistant', content: 'hello back' })
+		})
+
+		it('isStreaming is false after the call resolves', async () => {
+			const conv = makeConversation()
+			conv.stub('test', 'response')
+			await conv.ask('test')
+			expect(conv.isStreaming).toBe(false)
+		})
+
+		it('emits chunk events for each word', async () => {
+			const conv = makeConversation()
+			conv.stub('go', 'one two three')
+			const chunks: string[] = []
+			conv.on('chunk', (delta: string) => chunks.push(delta))
+			await conv.ask('go')
+			expect(chunks.join('')).toBe('one two three')
+		})
+
+		it('emits preview events with accumulating text', async () => {
+			const conv = makeConversation()
+			conv.stub('go', 'alpha beta')
+			const previews: string[] = []
+			conv.on('preview', (text: string) => previews.push(text))
+			await conv.ask('go')
+			expect(previews.at(-1)).toBe('alpha beta')
+			// Each preview should be longer than or equal to the previous
+			for (let i = 1; i < previews.length; i++) {
+				expect(previews[i]!.length).toBeGreaterThanOrEqual(previews[i - 1]!.length)
+			}
+		})
+
+		it('emits turnStart and turnEnd events', async () => {
+			const conv = makeConversation()
+			conv.stub('x', 'y')
+			const events: string[] = []
+			conv.on('turnStart', () => events.push('turnStart'))
+			conv.on('turnEnd', () => events.push('turnEnd'))
+			await conv.ask('x')
+			expect(events).toEqual(['turnStart', 'turnEnd'])
+		})
+
+		it('emits response event with the full text', async () => {
+			const conv = makeConversation()
+			conv.stub('question', 'the answer')
+			let emitted = ''
+			conv.on('response', (text: string) => { emitted = text })
+			await conv.ask('question')
+			expect(emitted).toBe('the answer')
+		})
+
+		it('stub is chainable', () => {
+			const conv = makeConversation()
+			const result = conv.stub('a', 'A').stub('b', 'B')
+			expect(result).toBe(conv)
+			expect(conv.availableTools).toHaveLength(0) // stubs don't affect tools
+		})
+	})
+})

package/test-integration/memory.test.ts

@@ -0,0 +1,204 @@
+import {
+  requireEnv,
+  describeWithRequirements,
+  createAGIContainer,
+  API_TIMEOUT,
+} from './helpers'
+import type { AGIContainer } from '../src/agi/container.server'
+import type { Memory } from '../src/agi/features/agent-memory'
+
+const openaiKey = requireEnv('OPENAI_API_KEY')
+
+describeWithRequirements('Memory Integration', [openaiKey], () => {
+  let container: AGIContainer
+  let mem: Memory
+
+  beforeAll(async () => {
+    container = createAGIContainer()
+    mem = container.feature('memory', { namespace: 'test-integration' }) as unknown as Memory
+    await mem.initDb()
+    await mem.wipeAll()
+  })
+
+  afterAll(async () => {
+    await mem.wipeAll()
+  })
+
+  describe('Feature registration', () => {
+    it('registers in the container', () => {
+      expect(container.features.available).toContain('memory')
+    })
+
+    it('has correct shortcut', () => {
+      const { Memory: MemClass } = require('../src/agi/features/agent-memory')
+      expect(MemClass.shortcut).toBe('features.memory')
+    })
+
+    it('initializes database', () => {
+      expect(mem.state.get('dbReady')).toBe(true)
+    })
+  })
+
+  describe('CRUD operations', () => {
+    it('creates and retrieves a memory', async () => {
+      const m = await mem.create('facts', 'Jonathan is a software engineer based in Austin')
+      expect(m.id).toBeGreaterThan(0)
+      expect(m.category).toBe('facts')
+      expect(m.document).toBe('Jonathan is a software engineer based in Austin')
+
+      const fetched = await mem.get('facts', m.id)
+      expect(fetched).not.toBeNull()
+      expect(fetched!.document).toBe(m.document)
+    }, API_TIMEOUT)
+
+    it('updates a memory', async () => {
+      const m = await mem.create('facts', 'Prefers dark mode')
+      const updated = await mem.update('facts', m.id, {
+        text: 'Prefers dark mode, especially Dracula theme',
+        metadata: { updated: 'true' },
+      })
+      expect(updated!.document).toBe('Prefers dark mode, especially Dracula theme')
+      expect(updated!.metadata.updated).toBe('true')
+    }, API_TIMEOUT)
+
+    it('deletes a memory', async () => {
+      const m = await mem.create('scratch', 'temporary memory')
+      expect(await mem.delete('scratch', m.id)).toBe(true)
+      expect(await mem.get('scratch', m.id)).toBeNull()
+    }, API_TIMEOUT)
+
+    it('lists categories', async () => {
+      const cats = await mem.categories()
+      expect(cats).toContain('facts')
+    })
+
+    it('counts memories', async () => {
+      const total = await mem.count()
+      expect(total).toBeGreaterThan(0)
+      const factCount = await mem.count('facts')
+      expect(factCount).toBeGreaterThan(0)
+    })
+
+    it('gets all memories with filtering', async () => {
+      await mem.create('prefs', 'Likes iterative delivery', { source: 'onboarding' })
+      await mem.create('prefs', 'Prefers concise responses')
+
+      const onboarding = await mem.getAll('prefs', { filterMetadata: { source: 'onboarding' } })
+      expect(onboarding.length).toBeGreaterThan(0)
+      expect(onboarding.every(m => m.metadata.source === 'onboarding')).toBe(true)
+    }, API_TIMEOUT)
+  })
+
+  describe('Semantic search', () => {
+    it('finds relevant memories by query', async () => {
+      const results = await mem.search('facts', 'Where does the user live?', 3)
+      expect(results.length).toBeGreaterThan(0)
+      expect(results[0].distance).toBeLessThan(1)
+    }, API_TIMEOUT)
+  })
+
+  describe('Deduplication', () => {
+    it('blocks near-duplicate memories', async () => {
+      const before = await mem.count('facts')
+      const dup = await mem.createUnique('facts', 'Jonathan is a software engineer living in Austin, TX')
+      const after = await mem.count('facts')
+      expect(dup).toBeNull()
+      expect(after).toBe(before)
+    }, API_TIMEOUT)
+  })
+
+  describe('Epochs and events', () => {
+    it('tracks epoch state', () => {
+      expect(mem.getEpoch()).toBe(1)
+    })
+
+    it('creates events and increments epoch', async () => {
+      await mem.createEvent('User started a new project')
+      await mem.incrementEpoch()
+      expect(mem.getEpoch()).toBe(2)
+
+      await mem.createEvent('User requested a test script')
+
+      const e1 = await mem.getEvents({ epoch: 1 })
+      const e2 = await mem.getEvents({ epoch: 2 })
+      expect(e1.length).toBeGreaterThan(0)
+      expect(e2.length).toBeGreaterThan(0)
+    }, API_TIMEOUT)
+  })
+
+  describe('Export and import', () => {
+    it('roundtrips through export/import', async () => {
+      const exported = await mem.exportToJson()
+      expect(exported.memories.length).toBeGreaterThan(0)
+
+      await mem.wipeAll()
+      expect(await mem.count()).toBe(0)
+
+      const imported = await mem.importFromJson(exported)
+      expect(imported).toBe(exported.memories.length)
+      expect(await mem.count()).toBe(exported.memories.length)
+    }, API_TIMEOUT * 3)
+  })
+
+  describe('Tool interface (toTools)', () => {
+    it('exposes tools via standard toTools() pattern', () => {
+      const { schemas, handlers } = mem.toTools()
+      expect(Object.keys(schemas)).toContain('remember')
+      expect(Object.keys(schemas)).toContain('recall')
+      expect(Object.keys(schemas)).toContain('forgetCategory')
+      expect(Object.keys(schemas)).toContain('listCategories')
+      expect(typeof handlers.remember).toBe('function')
+      expect(typeof handlers.recall).toBe('function')
+      expect(typeof handlers.forgetCategory).toBe('function')
+      expect(typeof handlers.listCategories).toBe('function')
+    })
+
+    it('toTools only/except filtering works', () => {
+      const { schemas: onlySchemas } = mem.toTools({ only: ['remember', 'recall'] })
+      expect(Object.keys(onlySchemas)).toEqual(['remember', 'recall'])
+
+      const { schemas: exceptSchemas } = mem.toTools({ except: ['forgetCategory'] })
+      expect(Object.keys(exceptSchemas)).not.toContain('forgetCategory')
+      expect(Object.keys(exceptSchemas)).toContain('remember')
+    })
+
+    it('remember tool stores and deduplicates', async () => {
+      const { handlers } = mem.toTools()
+      const result = await handlers.remember({ category: 'facts', text: 'Has a golden retriever named Max' })
+      expect(result.stored).toBe(true)
+
+      const dup = await handlers.remember({ category: 'facts', text: 'Has a golden retriever named Max' })
+      expect(dup.stored).toBe(false)
+    }, API_TIMEOUT)
+
+    it('recall tool searches memories', async () => {
+      const { handlers } = mem.toTools()
+      const results = await handlers.recall({ category: 'facts', query: 'pets and animals', n_results: 2 })
+      expect(results.length).toBeGreaterThan(0)
+      expect(results[0]).toHaveProperty('document')
+      expect(results[0]).toHaveProperty('distance')
+    }, API_TIMEOUT)
+
+    it('listCategories tool returns counts', async () => {
+      const { handlers } = mem.toTools()
+      const result = await handlers.listCategories()
+      expect(result.categories).toBeDefined()
+      expect(typeof result.categories.facts).toBe('number')
+    })
+  })
+
+  describe('Wipe operations', () => {
+    it('wipeCategory removes only that category', async () => {
+      const before = await mem.count()
+      const deleted = await mem.wipeCategory('scratch')
+      const after = await mem.count()
+      expect(after).toBeLessThanOrEqual(before)
+    })
+
+    it('wipeAll removes everything and resets epoch', async () => {
+      await mem.wipeAll()
+      expect(await mem.count()).toBe(0)
+      expect(mem.getEpoch()).toBe(1)
+    })
+  })
+})

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     // Environment setup & latest features
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "dom", "dom.iterable"],
     "target": "ESNext",
     "module": "Preserve",
     "moduleDetection": "force",