@soederpop/luca 0.1.1 → 0.1.3

package/docs/examples/entity.md

@@ -0,0 +1,124 @@
+---
+title: "Entity"
+tags: [entity, state, events, tools, core]
+lastTested: null
+lastTestPassed: null
+---
+
+# entity
+
+Lightweight, composable objects with observable state, a typed event bus, and an optional tool interface.
+
+## Overview
+
+An entity is a plain object — not a class — created via `container.entity(id, options?)`. Same id + options always returns the same underlying state and bus instance. Entities are designed to be extended with methods and getters via `.extend()`, and can expose those methods as AI tools via `.expose()`.
+
+## Basic Entity with Observable State
+
+Create an entity and read/write state through the observable `state` property.
+
+```ts
+const counter = container.entity<{ count: number }>('counter')
+counter.setState({ count: 0 })
+
+counter.state.observe((next) => {
+  console.log('count changed to', next.count)
+})
+
+counter.setState(s => ({ count: s.count + 1 }))
+counter.setState(s => ({ count: s.count + 1 }))
+console.log('final count:', counter.state.get('count'))
+```
+
+`setState` accepts either a partial object or a function that receives the current state. Observers fire synchronously after each change.
+
+## Typed Event Bus
+
+Every entity has a built-in event bus. Declare the event map as the third type parameter.
+
+```ts
+type TimerEvents = {
+  tick: [elapsed: number]
+  done: []
+}
+
+const timer = container.entity<{}, {}, TimerEvents>('timer')
+
+timer.on('tick', (elapsed) => {
+  console.log('tick at', elapsed, 'ms')
+})
+
+timer.once('done', () => {
+  console.log('timer finished')
+})
+
+timer.emit('tick', 100)
+timer.emit('tick', 200)
+timer.emit('done')
+```
+
+`once` auto-detaches after the first fire. `waitFor` returns a promise that resolves on the next emit of that event.
+
+## Extending with Methods
+
+Use `.extend()` to graft methods and getters onto an entity. All base properties — `state`, `options`, `container`, and the event methods — are available via `this`.
+
+```ts
+const session = container.entity('session', { userId: '42' })
+  .extend({
+    greet() {
+      return `Hello user ${this.options.userId}`
+    },
+    get label() {
+      return `Session ${this.id} (user ${this.options.userId})`
+    },
+    bump() {
+      const visits = (this.state.get('visits') ?? 0) + 1
+      this.setState({ visits })
+      this.emit('visited', visits)
+      return visits
+    },
+  })
+
+console.log(session.greet())
+console.log(session.label)
+console.log('visits:', session.bump())
+console.log('visits:', session.bump())
+```
+
+Extensions are chained via prototype delegation — each layer can see everything below it.
+
+## Exposing Methods as AI Tools
+
+Use `.expose(methodName, zodSchema)` to register methods as tools. `.toTools()` returns `{ schemas, handlers }` compatible with `assistant.addTools()`.
+
+```ts
+const search = container.entity('search', {})
+  .extend({
+    async lookup({ query }: { query: string }) {
+      return `Results for: ${query}`
+    },
+    async summarize({ text, maxWords }: { text: string; maxWords: number }) {
+      return text.split(' ').slice(0, maxWords).join(' ')
+    },
+  })
+  .expose('lookup', z.object({
+    query: z.string().describe('The search query'),
+  }))
+  .expose('summarize', z.object({
+    text: z.string().describe('Text to summarize'),
+    maxWords: z.number().describe('Maximum words in summary'),
+  }))
+
+const { schemas, handlers } = search.toTools()
+console.log('registered tools:', Object.keys(schemas))
+
+// Pass directly to an assistant
+// assistant.addTools(search)
+```
+
+`.expose()` is chainable and returns `this`, so you can stack as many as you need.
+
+## Summary
+
+Entities give you observable state, a typed event bus, and prototype-safe method extension — all as a plain object with no class overhead. The `.expose()` / `.toTools()` interface makes it straightforward to surface entity methods as AI tools.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soederpop/luca",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "website": "https://luca.soederpop.com",
   "description": "lightweight universal conversational architecture AKA Le Ultimate Component Architecture AKA Last Universal Common Ancestor, part AI part Human",
   "author": "jon soeder aka the people's champ <jon@soederpop.com>",
@@ -19,26 +19,77 @@
     "coding assistant"
   ],
   "main": "./src/node.ts",
-  "types": "./src/node.ts",
+  "types": "./dist/node.d.ts",
   "browser": "./src/browser.ts",
   "exports": {
-    ".": "./src/node.ts",
-    "./node": "./src/node.ts",
-    "./node/*": "./src/node/*",
-    "./web": "./src/browser.ts",
-    "./web/*": "./src/web/*",
-    "./agi": "./src/agi/index.ts",
-    "./agi/*": "./src/agi/*",
-    "./schemas": "./src/schemas/base.ts",
-    "./schemas/*": "./src/schemas/*",
-    "./container": "./src/container.ts",
-    "./client": "./src/client.ts",
-    "./clients/*": "./src/clients/*",
-    "./server": "./src/server.ts",
-    "./servers/*": "./src/servers/*",
-    "./feature": "./src/feature.ts",
-    "./react": "./src/react/index.ts",
-    "./introspection": "./src/introspection/index.ts"
+    ".": {
+      "types": "./dist/node.d.ts",
+      "default": "./src/node.ts"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./src/node.ts"
+    },
+    "./node/*": {
+      "types": "./dist/node/*.d.ts",
+      "default": "./src/node/*"
+    },
+    "./web": {
+      "types": "./dist/browser.d.ts",
+      "default": "./src/browser.ts"
+    },
+    "./web/*": {
+      "types": "./dist/web/*.d.ts",
+      "default": "./src/web/*"
+    },
+    "./agi": {
+      "types": "./dist/agi/index.d.ts",
+      "default": "./src/agi/index.ts"
+    },
+    "./agi/*": {
+      "types": "./dist/agi/*.d.ts",
+      "default": "./src/agi/*"
+    },
+    "./schemas": {
+      "types": "./dist/schemas/base.d.ts",
+      "default": "./src/schemas/base.ts"
+    },
+    "./schemas/*": {
+      "types": "./dist/schemas/*.d.ts",
+      "default": "./src/schemas/*"
+    },
+    "./container": {
+      "types": "./dist/container.d.ts",
+      "default": "./src/container.ts"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "default": "./src/client.ts"
+    },
+    "./clients/*": {
+      "types": "./dist/clients/*.d.ts",
+      "default": "./src/clients/*"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./src/server.ts"
+    },
+    "./servers/*": {
+      "types": "./dist/servers/*.d.ts",
+      "default": "./src/servers/*"
+    },
+    "./feature": {
+      "types": "./dist/feature.d.ts",
+      "default": "./src/feature.ts"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./src/react/index.ts"
+    },
+    "./introspection": {
+      "types": "./dist/introspection/index.d.ts",
+      "default": "./src/introspection/index.ts"
+    }
   },
   "bin": {
     "luca": "./src/cli/cli.ts"
@@ -51,13 +102,14 @@
     "build:web": "bun run scripts/build-web.ts",
     "build:introspection": "bun run src/cli/cli.ts introspect",
     "compile": "bun run build:introspection && bun run build:scaffolds && bun run build:bootstrap && bun run build:python-bridge && bash scripts/stamp-build.sh && bun build ./src/cli/cli.ts --compile --outfile dist/luca --external node-llama-cpp",
+    "build:types": "tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "build:scaffolds": "bun run src/cli/cli.ts build-scaffolds",
     "build:bootstrap": "bun run src/cli/cli.ts build-bootstrap",
     "build:python-bridge": "bun run src/cli/cli.ts build-python-bridge",
     "test": "bun test test/*.test.ts",
     "update-all-docs": "bun run test && bun run build:introspection && bun run src/cli/cli.ts generate-api-docs && bun run build:scaffolds && bun run build:bootstrap && bun run build:python-bridge",
-    "precommit": "bun run update-all-docs && git add docs/apis/ src/introspection/generated.*.ts src/scaffolds/generated.ts src/bootstrap/generated.ts src/python/generated.ts && bun compile",
+    "precommit": "bun run typecheck && bun run update-all-docs && git add docs/apis/ src/introspection/generated.*.ts src/scaffolds/generated.ts src/bootstrap/generated.ts src/python/generated.ts && bun compile",
     "test:integration": "bun test ./test-integration/"
   },
   "devDependencies": {
@@ -97,7 +149,7 @@
     "@supabase/supabase-js": "^2.95.3",
     "@types/marked": "^6.0.0",
     "@types/marked-terminal": "^6.1.1",
-    "axios": "^1.3.5",
+    "axios": "1.13.6",
     "cacache": "^17.0.7",
     "chalk": "^5.2.0",
     "child-process-promise": "^2.2.1",

package/scripts/test-assistant-hooks.ts

@@ -0,0 +1,13 @@
+import container from '@soederpop/luca/agi'
+
+const coder = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+
+await coder.start()
+console.log("Available Tools", coder.availableTools)
+
+if (coder.state.get('startedHookRan')) {
+	console.log('Started Hook Ran')
+}
+
+
+

package/src/agi/feature.ts

@@ -0,0 +1,13 @@
+import type { AGIFeatures, AGIContainer } from './container.server.js'
+import type { FeatureOptions, FeatureState } from '../feature.ts'
+import { features, Feature as NodeFeature } from '../node/feature.ts'
+
+export { features }
+
+export type { FeatureState, FeatureOptions }
+
+export class Feature<T extends FeatureState = FeatureState, K extends FeatureOptions = FeatureOptions> extends NodeFeature<T, K> {
+    override get container(): AGIContainer<AGIFeatures> {
+        return super.container as AGIContainer<AGIFeatures>
+    }
+}

package/src/agi/features/assistant.ts

@@ -1,9 +1,8 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { type AvailableFeatures } from '@soederpop/luca/feature'
-import { Feature } from '@soederpop/luca/feature'
+import { Feature } from '../feature.js'
 import type { Conversation, ConversationTool, ContentPart, AskOptions, Message } from './conversation'
-import type { AGIContainer } from '../container.server.js'
 import type { ContentDb } from '@soederpop/luca/node'
 import type { ConversationHistory, ConversationMeta } from './conversation-history'
 import hashObject from '../../hash-object.js'
@@ -152,6 +151,10 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 	 * @returns this, for chaining
 	 */
 	intercept<K extends InterceptorPoint>(point: K, fn: InterceptorFn<InterceptorPoints[K]>): this {
+		if (!(point in this.interceptors)) {
+			const available = Object.keys(this.interceptors).join(', ')
+			throw new Error(`Unknown intercept point "${point}". Available points: ${available}`)
+		}
 		this.interceptors[point].add(fn as any)
 		return this
 	}
@@ -176,12 +179,9 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 		}
 	}
 
-	override get container(): AGIContainer {
-		return super.container as AGIContainer
-	}
 
 	get name() {
-		return this.resolvedFolder.split('/').pop()
+		return this.options.name || this.resolvedFolder.split('/').pop()
 	}
 
 	/** The absolute resolved path to the assistant folder. */
@@ -213,11 +213,11 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 	get voiceConfig(): Record<string, any> | undefined {
 		if (!this.hasVoice) return undefined
 		const yaml = this.container.feature('yaml')
-		return yaml.parse(this.container.fs.readFile(this.paths.resolve('voice.yaml')))
+		return yaml.parse(String(this.container.fs.readFile(this.paths.resolve('voice.yaml'))))
 	}
 
 	get resolvedDocsFolder() {
-		const { docsFolder = this.options.docsFolder || 'docs' } = this.state.current
+		const { docsFolder = this.effectiveOptions.docsFolder || 'docs' } = this.state.current
 
 		if (this.container.fs.exists(docsFolder)) {
 			return this.container.paths.resolve(docsFolder)
@@ -268,17 +268,17 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 		let conv = this.state.get('conversation') as Conversation | null
 		if (!conv) {
 			conv = this.container.feature('conversation', {
-				model: this.options.model || 'gpt-5.4',
-				local: !!this.options.local,
+				model: this.effectiveOptions.model || 'gpt-5.4',
+				local: !!this.effectiveOptions.local,
 				tools: this.tools,
 				api: 'chat',
-				...(this.options.maxTokens ? { maxTokens: this.options.maxTokens } : {}),
-				...(this.options.temperature != null ? { temperature: this.options.temperature } : {}),
-				...(this.options.topP != null ? { topP: this.options.topP } : {}),
-				...(this.options.topK != null ? { topK: this.options.topK } : {}),
-				...(this.options.frequencyPenalty != null ? { frequencyPenalty: this.options.frequencyPenalty } : {}),
-				...(this.options.presencePenalty != null ? { presencePenalty: this.options.presencePenalty } : {}),
-				...(this.options.stop ? { stop: this.options.stop } : {}),
+				...(this.effectiveOptions.maxTokens ? { maxTokens: this.effectiveOptions.maxTokens } : {}),
+				...(this.effectiveOptions.temperature != null ? { temperature: this.effectiveOptions.temperature } : {}),
+				...(this.effectiveOptions.topP != null ? { topP: this.effectiveOptions.topP } : {}),
+				...(this.effectiveOptions.topK != null ? { topK: this.effectiveOptions.topK } : {}),
+				...(this.effectiveOptions.frequencyPenalty != null ? { frequencyPenalty: this.effectiveOptions.frequencyPenalty } : {}),
+				...(this.effectiveOptions.presencePenalty != null ? { presencePenalty: this.effectiveOptions.presencePenalty } : {}),
+				...(this.effectiveOptions.stop ? { stop: this.effectiveOptions.stop } : {}),
 				history: [
 					{ role: 'system', content: this.effectiveSystemPrompt },
 				],
@@ -372,7 +372,7 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 	 * allowTools is applied first (strict allowlist), then forbidTools removes from whatever remains.
 	 */
 	private applyToolFilters(tools: Record<string, ConversationTool>): Record<string, ConversationTool> {
-		const { allowTools, forbidTools, toolNames } = this.options
+		const { allowTools, forbidTools, toolNames } = this.effectiveOptions
 		if (!allowTools && !forbidTools && !toolNames) return tools
 
 		let names = Object.keys(tools)
@@ -395,7 +395,8 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 
 		const result: Record<string, ConversationTool> = {}
 		for (const n of names) {
-			result[n] = tools[n]
+			const tool = tools[n]
+			if (tool) result[n] = tool
 		}
 		return result
 	}
@@ -607,6 +608,15 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 		return (this.state.get('meta') || {}) as Record<string, any>
 	}
 
+	/**
+	 * Merged options where CORE.md frontmatter provides defaults and
+	 * constructor options take precedence. Prefer this over `this.options`
+	 * anywhere model parameters or runtime config is consumed.
+	 */
+	get effectiveOptions(): AssistantOptions & Record<string, any> {
+		return { ...this.meta, ...this.options }
+	}
+
 	/**
 	 * Load the system prompt from CORE.md, applying any prepend/append options.
 	 * YAML frontmatter (between --- fences) is stripped from the prompt and
@@ -831,8 +841,9 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 			return `${stamp} ${content}`
 		}
 
-		if (content.length > 0 && content[0].type === 'text') {
-			return [{ type: 'text' as const, text: `${stamp} ${content[0].text}` }, ...content.slice(1)]
+		const firstPart = content[0]
+		if (firstPart && firstPart.type === 'text') {
+			return [{ type: 'text' as const, text: `${stamp} ${firstPart.text}` }, ...content.slice(1)]
 		}
 
 		return [{ type: 'text' as const, text: stamp }, ...content]
@@ -919,7 +930,7 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 	 * Called from start() for non-lifecycle modes.
 	 */
 	private async loadConversationHistory(): Promise<void> {
-		const mode = this.options.historyMode || 'lifecycle'
+		const mode = this.effectiveOptions.historyMode || 'lifecycle'
 		if (mode === 'lifecycle') return
 
 		const threadId = (this.state.get('resumeThreadId') as string | undefined) || this.buildThreadId(mode)
@@ -1104,7 +1115,7 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 		await this.loadConversationHistory()
 
 		// Enable autoCompact for modes that accumulate history
-		const mode = this.options.historyMode || 'lifecycle'
+		const mode = this.effectiveOptions.historyMode || 'lifecycle'
 		if (mode === 'daily' || mode === 'persistent') {
 			(this.conversation.options as any).autoCompact = true
 		}
@@ -1146,7 +1157,7 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 		const count = (this.state.get('conversationCount') || 0) + 1
 		this.state.set('conversationCount', count)
 
-		if (this.options.injectTimestamps) {
+		if (this.effectiveOptions.injectTimestamps) {
 			question = this.prependTimestamp(question)
 		}
 
@@ -1169,7 +1180,7 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 		}
 
 		// Auto-save for non-lifecycle modes
-		if (this.options.historyMode !== 'lifecycle' && this.state.get('threadId')) {
+		if (this.effectiveOptions.historyMode !== 'lifecycle' && this.state.get('threadId')) {
 			await this.conversation.save({ thread: this.state.get('threadId') })
 		}
 

package/src/agi/features/assistants-manager.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { type AvailableFeatures } from '@soederpop/luca/feature'
-import { Feature } from '@soederpop/luca/feature'
-import type { AGIContainer } from '../container.server.js'
+import { Feature } from '../feature.js'
 import type { Assistant } from './assistant.js'
+import type { InterceptorFn, InterceptorPoint, InterceptorPoints } from '../lib/interceptor-chain.js'
 
 declare module '@soederpop/luca/feature' {
 	interface AvailableFeatures {
@@ -47,6 +47,7 @@ export const AssistantsManagerStateSchema = FeatureStateSchema.extend({
 	entries: z.record(z.string(), z.any()).describe('Discovered assistant entries keyed by name'),
 	instances: z.record(z.string(), z.any()).describe('Active assistant instances keyed by name'),
 	factories: z.record(z.string(), z.any()).describe('Registered factory functions keyed by name'),
+	extraFolders: z.array(z.string()).describe('Additional folders to scan during discovery'),
 })
 
 export const AssistantsManagerOptionsSchema = FeatureOptionsSchema.extend({})
@@ -91,12 +92,10 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 			entries: {},
 			instances: {},
 			factories: {},
+			extraFolders: [],
 		}
 	}
 
-	override get container(): AGIContainer {
-		return super.container as AGIContainer
-	}
 
 	/** Discovered assistant entries keyed by name. */
 	get entries(): Record<string, AssistantEntry> {
@@ -113,12 +112,60 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 		return (this.state.get('factories') || {}) as Record<string, (options: Record<string, any>) => Assistant>
 	}
 
+	/** Interceptor registrations to be applied to every assistant this manager creates. */
+	private _interceptors: Array<{ point: InterceptorPoint; fn: InterceptorFn<any> }> = []
+
+	/**
+	 * Registers a pipeline interceptor that is applied to every assistant created by this manager.
+	 * Interceptors are applied at the given interception point on each assistant at creation time.
+	 * This mirrors the per-assistant `assistant.intercept(point, fn)` API, but scopes it globally
+	 * across all assistants managed here — useful for cross-cutting concerns like logging, tracing,
+	 * or policy enforcement.
+	 *
+	 * @param {InterceptorPoint} point - The interception point (beforeAsk, beforeTurn, beforeToolCall, afterToolCall, beforeResponse)
+	 * @param {InterceptorFn<InterceptorPoints[K]>} fn - Middleware function receiving (ctx, next)
+	 * @returns {this} This instance, for chaining
+	 *
+	 * @example
+	 * ```typescript
+	 * manager.intercept('beforeAsk', async (ctx, next) => {
+	 *   console.log(`[${ctx.assistant.name}] asking: ${ctx.message}`)
+	 *   await next()
+	 * })
+	 * ```
+	 */
+	intercept<K extends InterceptorPoint>(point: K, fn: InterceptorFn<InterceptorPoints[K]>): this {
+		this._interceptors.push({ point, fn })
+		return this
+	}
+
 	/**
 	 * Discovers assistants by listing subdirectories in ~/.luca/assistants/
 	 * and cwd/assistants/. Each subdirectory containing a CORE.md is an assistant.
 	 *
 	 * @returns {Promise<this>} This instance, for chaining
 	 */
+	/**
+	 * Registers an additional folder to scan during assistant discovery and
+	 * immediately triggers a new discovery pass.
+	 *
+	 * @param {string} folderPath - Absolute path to a folder containing assistant subdirectories
+	 * @returns {Promise<this>} This instance, for chaining
+	 *
+	 * @example
+	 * ```typescript
+	 * await manager.addDiscoveryFolder('/path/to/more/assistants')
+	 * console.log(manager.available) // includes assistants from the new folder
+	 * ```
+	 */
+	async addDiscoveryFolder(folderPath: string): Promise<this> {
+		const current = this.state.get('extraFolders') as string[]
+		if (!current.includes(folderPath)) {
+			this.state.set('extraFolders', [...current, folderPath])
+		}
+		return this.discover()
+	}
+
 	async discover(): Promise<this> {
 		const { fs, paths, os } = this.container
 
@@ -127,6 +174,7 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 		const locations = [
 			`${os.homedir}/.luca/assistants`,
 			paths.resolve('assistants'),
+			...(this.state.get('extraFolders') as string[]),
 		]
 
 		for (const location of locations) {
@@ -262,6 +310,7 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 		const factory = this.factories[name]
 		if (factory) {
 			const instance = factory(options)
+			this._bindAssistant(instance)
 			const updated = { ...this.instances, [name]: instance }
 			this.state.setState({ instances: updated, activeCount: Object.keys(updated).length })
 			this.emit('assistantCreated', name, instance)
@@ -281,6 +330,7 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 			...options,
 		})
 
+		this._bindAssistant(instance)
 		const updated = { ...this.instances, [name]: instance }
 		this.state.setState({ instances: updated, activeCount: Object.keys(updated).length })
 		this.emit('assistantCreated', name, instance)
@@ -288,6 +338,21 @@ export class AssistantsManager extends Feature<AssistantsManagerState, Assistant
 		return instance
 	}
 
+	/**
+	 * Wires an assistant into the manager: bridges all assistant events up to the manager
+	 * as `assistantEvent:<eventName>` with (assistant, ...originalArgs), and applies any
+	 * globally registered interceptors.
+	 */
+	private _bindAssistant(instance: Assistant): void {
+		instance.on('*', (event: string, ...args: any[]) => {
+			this.emit(`assistantEvent:${event}` as any, instance, ...args)
+		})
+
+		for (const { point, fn } of this._interceptors) {
+			instance.intercept(point, fn)
+		}
+	}
+
 	/**
 	 * Returns a previously created assistant instance by name.
 	 *

package/src/agi/features/autonomous-assistant.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { Feature } from '@soederpop/luca/feature'
-import type { AGIContainer } from '../container.server.js'
+import { Feature } from '../feature.js'
 import type { Assistant } from './assistant.js'
 import type { ToolCallCtx } from '../lib/interceptor-chain.js'
 
@@ -158,9 +157,6 @@ export class AutonomousAssistant extends Feature<AutonomousAssistantState, Auton
 		}
 	}
 
-	override get container(): AGIContainer {
-		return super.container as AGIContainer
-	}
 
 	/** The inner assistant. Throws if not started. */
 	get assistant(): Assistant {

package/src/agi/features/browser-use.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { Feature } from '@soederpop/luca/feature'
+import { Feature } from '../feature.js'
 
 declare module '@soederpop/luca/feature' {
   interface AvailableFeatures {
@@ -61,7 +61,7 @@ export class BrowserUse extends Feature<BrowserUseState, BrowserUseOptions> {
   static override optionsSchema = BrowserUseOptionsSchema
   static override eventsSchema = BrowserUseEventsSchema
 
-  static tools = {
+  static override tools = {
     browserOpen: {
       description: 'Navigate the browser to a URL. Call this first to open a page before any interaction.',
       schema: z.object({